Development updates

Animation clips and blend spaces now open in dedicated editors, each with a 3D preview, a details panel and a list of related clips.

The clip editor adds a timeline for everything attached to an animation: notifies that trigger events such as footstep sounds, notify windows that span a range of frames, curves that change over the course of the clip, and sync markers that keep different animations in step. Sync markers can be placed automatically by detecting when each foot touches the ground, and curves such as speed can be generated from the clip's own motion. Notifies are stored with the clip, so every character that plays it triggers them.

The blend space editor shows the blended result moving in its preview, and can place each clip on the grid automatically by measuring how fast and in which direction the clip really moves.

The animation system has been rebuilt around Animation Blueprints. Every frame, a blueprint first works out how much each animation contributes to the final pose, then builds the pose from the animations that matter. Knowing those weights keeps transitions smooth, footsteps in sync and root motion accurate.

Blueprints include state machines edited as boxes and arrows, montages for one-off animations such as attacks, and foot IK that plants each foot on uneven ground. While the game runs, the editor shows the active state, the progress of each blend and the playback position of every animation.

To put it through its paces, I built a complete third-person character with it, and then a second one on a full locomotion set with crouching, going prone and turning in place.

The volumetric clouds have been rewritten from the ground up. They now have real depth and shading, stretch all the way to the horizon, and respond properly to the coverage setting.

Exposure is now based on how much light actually reaches the ground, so the camera adjusts naturally as the sun goes down, and sunsets glow instead of fading to black.

The clouds cast shadows on the ground and into fog, add their light to the scene and appear in reflections, and an overcast sky softens the lighting across the whole level. Distant clouds use a cheaper rendering path to keep performance in check.

The Hub is the first thing you see: it lists your projects, creates new ones from templates and manages installed engine versions. It has been rebuilt page by page to match the rest of the engine's design.

It now has a sidebar for navigation, a project list and a card grid with thumbnails, a preview panel with details about the selected project, new dialogs for creating and importing projects, and pages for engines and settings. Thumbnails are captured automatically from the editor's viewport when a project is closed.

Projects can now be packaged into a standalone build: a single archive containing all of the game's assets, next to a copy of the runtime. The packaged game renders pixel for pixel the same as it does during development.

The standalone runtime also gained full mouse look and a camera that follows the player's character, so a packaged game plays just as it does in the editor.

The sample character now uses a complete locomotion set: walking, jogging, running and crouching in every direction, along with starts, stops, pivots and turns in place. The animations drive the character's movement directly, so feet stay planted instead of sliding.

Every clip is measured to find how fast and in which direction it really moves, and is placed on the blend grid from those measurements rather than from its name. The result is smooth blending in every direction, and turns in place that land exactly on their target angle.

The sky has been rebuilt on real-world units: sunlight in lux, lamps in candela and exposure in photographic stops. Physical units make lighting predictable, and the engine can report the exact brightness of any pixel, so lighting can be checked with numbers instead of guesswork.

The atmosphere is recalculated every frame, so the sun can move freely through a full day and night, and it is verified against a slower, path-traced reference to make sure it is accurate.

Weather and wind came with it. A level describes its weather as a schedule, for example clear in the morning and stormy by evening, and the sky blends smoothly from one condition to the next. A single wind drives both the clouds and the fog.

The sample game's logic, including crates, moving platforms, a trigger zone, a lift, the HUD and the pause menu, has been rebuilt entirely with visual scripting. It shows that a complete project can be made without writing any C++.

Along the way, interface screens gained scripts of their own, so a menu can handle its own buttons, and the game mode can now choose which character and controller each player gets.

The first version of the sky came together quickly, with an atmosphere, volumetric clouds, stars and a moon with phases. But it was expensive, hard to tune and difficult to verify, and a second attempt based on a published renderer came with assets that could not be shipped.

So I removed the whole system and started again with a clear set of goals: real-world light units, a single clock driving the entire environment, and a way to check the results against a reference instead of by eye. That became the physically based sky the engine uses today.

The in-game interface now supports right-to-left languages such as Arabic and Hebrew, including text that mixes both directions, with a cursor that moves through it correctly. Lines wrap according to Unicode's line breaking rules.

Text rendering has improved too: text is now drawn at its exact size with hinting and correct colour blending, which makes it noticeably sharper.

The widget set is now complete. Popups such as dropdowns and tooltips always appear on top, and lists stay fast however many items they hold, because only the visible rows are created.

Projects can now write their own material shaders in Slang. A custom shader is a single function that can call the engine's standard lighting, so it starts from a correctly lit result and only changes what it needs to, whether that is a stylised look such as cel shading or a special effect.

Shaders are edited in a new built-in code editor with syntax highlighting, error markers and programming ligatures. For now, surfaces that use a custom shader do not cast shadows.

Games can now be translated through string tables, one per language, and an editor shows every language side by side with missing translations highlighted. Each project chooses its own default language.

Accessibility options can be tried live in the editor: subtitles, interface scaling that enlarges the whole layout rather than just the text, and a colour-vision filter. The filter works independently of each level's colour grading, so it always does its job.

Vilanel now supports networked multiplayer, built into the gameplay framework from the start: network roles and replicated variables are part of every actor class.

Your own character responds instantly, with smooth corrections from the server when needed, and other players move smoothly thanks to interpolation. The server only sends each player what is relevant to them.

Games can be hosted by a player or run on a dedicated server with no window, and a small rendezvous server helps players connect directly to each other when they cannot reach each other on their own.

Gameplay is now built from actor classes. Each class is a single asset holding a parent class, components, variables that each placed copy can override, an event graph and a construction script. Pawn, Character, GameMode and PlayerController are built in as base classes to build on.

Classes open in their own editor, with a 3D viewport, a component tree and a Compile button, and visual scripting gained a Delay node, custom events and functions with their own local variables.

Under the hood, code reloading was reworked to rebuild objects with their saved values after a reload, which is what makes a full object model possible alongside hot reload.

Every level now has its own World Settings for exposure, bloom, shadows and post-processing, and post-process volumes can change them in specific areas, such as a dark cave or a bright courtyard.

Several new effects arrived at the same time: ambient occlusion, depth of field, motion blur and colour grading with lookup tables. Automatic exposure is also available for levels that want it.

Levels can now bake their lighting ahead of time. A ray tracer works out how much of the sky each surface can see and how light bounces between surfaces, including colour bleeding from coloured walls, so interiors are lit realistically.

Reflection probes capture the lighting of a room, so shiny surfaces indoors reflect their surroundings instead of the sky. Baking runs across all CPU cores in the background, with its progress shown in the editor.

The renderer is now covered by screenshot tests. The runtime renders a frame on a fixed clock, saves it and compares it against a stored reference image, so visual regressions are caught automatically instead of by eye.

The reference images are taken from carefully chosen camera angles, so they cover the parts of the renderer that are most likely to break.

Every asset type now opens in its own editor tab, with its own panels, toolbar and saved layout, instead of sharing the level editor's panels.

Materials also became proper project assets with an editor of their own, including a preview sphere, a node graph and a details panel. Reimporting a model no longer overwrites changes made to its materials.

Blend spaces make it easy to blend between animations by speed and direction. Each clip is placed at the speed and direction it represents, and the engine blends the clips closest to how the character is moving.

The clips in a blend space are kept in sync, so a walk blends smoothly into a run without the feet falling out of step.

Alongside glTF, the engine can now import FBX and OBJ models, the formats most often used by asset stores and animation libraries.

All three formats go through a single import path, so everything downstream works the same way whichever format a model came from.

The scene hierarchy, the content browser, the skeleton view and the interface designer now share one tree view, so indentation, icons, selection and expanding rows look and behave the same everywhere in the editor.

Double-clicking an asset now opens it in the right editor: levels open in the level editor, and interface files open in the interface designer. Every way of opening an asset, from the content browser, from the right-click menu or when creating a new one, behaves the same way.

If you open another level while the current one has unsaved changes, the editor asks before discarding them.

Animated models now open in a preview window with a skeleton view, a 3D preview you can orbit, playback controls and a timeline you can scrub. The preview uses the same animation system as the game, so what you see is exactly what plays in a level.

The content browser also gained right-click menus, and the scene hierarchy gained rename and duplicate.

Animations now only advance while the game is running, just like physics. Characters stay exactly where you place them while you edit a level, but still show their pose, and changes to an animation appear immediately.

Assets can now be imported with a file picker or by dragging files straight onto the editor window, and imported files land in the folder that is open in the content browser.

Several files dropped together are imported as one batch, so a model and its textures are processed together, and the engine converts them automatically in the background.

Animation state machines arrived in the node graph editor. Characters can switch between states such as idle, walk and jump with smooth transitions, and only the active state's animation is evaluated, so even complex state machines stay cheap.

Each character keeps track of its own transitions, so the same state machine can drive any number of characters at once.

The engine now generates its reflection data automatically by reading the source code during the build. Saving, the properties panel and code reloading all rely on knowing which fields each type has, and exposing a value to the editor now takes a single annotation.

Game code is also checked against the engine it is loaded into, so a mismatch produces a clear error message instead of a crash.

The asset converter now tracks which source files each converted asset depends on. Change a texture, and every model that uses it is rebuilt automatically.

Changes are detected through the operating system's file notifications instead of by scanning the whole project, so large projects stay responsive and only what changed is rebuilt.

Projects are now standalone folders that can live anywhere on disk, each with its own assets, levels and optional game code.

The Hub is a new launcher for managing them. It lists your projects, creates new ones from templates and keeps track of installed engine versions, so different projects can use different versions of the engine.

The editor now has a Play mode. The game only runs when you press Play, and stopping puts everything back exactly where it was. Pause freezes the game, and Step advances it one frame at a time, which is ideal for inspecting collisions and triggers.

While the game is running, the editor is tinted and outlined in colour, so it is always clear that changes made during play will not be kept.

Shadows and animated characters now go through the same GPU culling and level of detail system as everything else, which greatly reduces how much the renderer has to draw.

Animated characters also gained proper motion vectors, so temporal anti-aliasing keeps moving limbs sharp instead of smearing them.

Lights, cameras, interfaces and input bindings are now saved in level files and edited in the editor, instead of being defined in code.

Play mode uses the same files: stopping the game reloads the saved level, so everything returns exactly to how it was before you pressed Play.

The first building blocks of Vilanel were a window, a Vulkan graphics device and the ability to reload gameplay code while the editor keeps running. Code reloading came early on purpose, because it shapes how the rest of the engine has to be written.

The renderer followed quickly, with physically based materials and lighting, shadows, HDR, GPU-driven culling and temporal anti-aliasing.