UNIGINE 2.22 - New Sequencer, DRS, Cesium Integration, Better Sensors

September 11

Key Changes

New Sequencer tool and a major Animation System update
Experimental Navigation & Pathfinding with automatic NavMesh generation
Dynamic Resolution Scaling and upscaling improvements
Enhanced shadow rendering
Surface ID buffers and custom shader parameters
Expanded sensor support, including LiDAR, radar, and Kannala–Brandt fisheye cameras
Cesium integration for planet-scale geospatial data streaming
Improved Gaussian Splatting support
New VR Multiplayer project template
ArduPilot SITL integration in the UAV template
Extended localization support, including Arabic, Hindi, Thai, and other complex writing systems
Physics engine improvements
Unified AI Toolkit for agent-powered world editing and code generation
Quality-of-life improvements across the Editor and Sandworm
Numerous performance optimizations

UNIGINE-Powered AA Game - Announced

Before diving into the SDK release notes, we'd like to highlight a new game developed by our team.

Developed by UNIGINE and published by Saber Interactive.
Powered by UNIGINE 2 Sim.
Coming soon to PC, PlayStation 5, and XBOX Series X|S.

From a technology perspective, the project is particularly important for us. The game runs on UNIGINE 2.22 Sim, together with our console branches, which are not yet available for external licensing.

Under the hood, however, it is the same UNIGINE technology stack our customers work with: the same C++ API, tools, Editor, rendering technology, and core engine architecture available in the UNIGINE SDK.

The game features large, living urban environments with dense traffic, pedestrians, dynamic weather, vehicle simulation, and numerous interconnected gameplay systems - all running within the performance constraints of mainstream hardware, including consoles originally released six years ago.

For us, the project has also served as a large-scale real-world proving ground for UNIGINE. Building and shipping a complete AA game on top of the engine allowed us to test its technology under production workloads, identify bottlenecks, improve workflows, and validate many of the features that are making their way into the SDK.

In this sense, it is not only a game built with UNIGINE - it is also a practical demonstration of what the same technology available to our customers can handle in a complex, content-heavy real-time application.

We'd greatly appreciate your support for our game development team — their work also helps make the SDK better. Please wishlist the game on your platform of choice:

Animation Updates

Sequencer Tool

Sequencer is a new long-awaited tool in UNIGINE (and the successor to Tracker), built to author cinematics and drive parameter animation from a single timeline. It covers the whole range from a single animated parameter to a finished cutscene, authored on one timeline and kept in one reusable asset.

Almost anything in your world can be animated this way: node transforms, lights, cameras, materials, sounds, physics, render settings, and the fields of your own C++/C# components.

With a reworked interface, auto-keying and clips you compose by dragging, a full animation comes together in a fraction of the time it used to take. And the Editor previews through the very player that ships in your build, so what you see while scrubbing is exactly what plays at runtime.

Channels, Keys and Curves

Every animated value in a sequence is a channel: one parameter, one curve and its own interpolation and tangents on every key. The Dope Sheet sets when things happen and the Curve Editor sets how the value moves between them, over one shared timeline.

The whole loop lives in the Editor. Animation previews on the real scene as it is built, and a player node plays the finished sequence in the world, so an artist can author, preview and ship a piece of animation without writing a line of code.

Targets - Binding by Rules

An animation welded to the objects it was authored on has to be rebuilt for the next set of them. In Sequencer a channel keeps the parameter and the object apart: point it at a single node, or give it a rule that describes a set of them by name, tag, component, or type.

A rule keeps looking while the sequence plays. Objects that appear later fall under it on their own, and objects that go away drop out of it. One curve can dim a whole street of lamps, including the lamps that were not there when the curve was drawn.

Cinematic Channels and the Animation System

Sequencer ships with ready-made channels for the pieces a cutscene is built from - camera cuts, sound, skeletal animation, event ranges - each carrying the settings its own job needs. They turn composition into laying blocks out on the timeline: clips can be trimmed, retimed, blended by weight, and repeated past the length of their content.

Dedicated channels bring animation graphs and animation clips straight onto the timeline. Build your characters with the full range of the animation graph, then bring that behaviour into a shot: a clip assigns an animation for the length of a take, and every named graph parameter becomes a channel - key a speed ramp or fire a trigger, and the graph works out the pose for it.

Under the hood, the two systems stand on one substrate: a sequence's skeletal clips land in the same pose layers of the same Skeleton Pose node the animation graph writes to, stream through the same animation streaming, and bend through the same IK solvers. The pose itself, though, has one owner at a time: while a skeletal clip plays, the sequence holds the character's pose for the length of the take, and hands it back afterwards, restoring what it found.

That keeps the division of labor clean. The Animation Graph is the per-frame brain of a single character - state machines, blend spaces, root motion, IK - logic that reacts to gameplay on every tick. The Sequencer is authored time across the whole scene - cameras, lights, materials, sounds, characters, and your own components on one deterministic timeline, with no conditions or branching by design. Where the two meet is exactly where you want them to: key the graph's parameters and fire its triggers from the timeline - the take decides when the character sprints, and the graph decides how the sprint looks.

Subsequences

A long cinematic built as one flat timeline is hard to edit and hard to share between shots. A Sub-Sequence channel plays whole sequences inside another one, so the door that opens in the middle of a cutscene is authored on its own and dropped in as a clip.

Each piece stays a file of its own and can be reused anywhere, and an edit to it reaches every sequence that plays it.

Faster Where It Counts, Open Where Tracker Was Closed

Tracker was a UnigineScript system: every animated parameter went through the script interpreter - a script call per parameter on every applied frame, a validity check on every object it touched, curves evaluated inside the VM, and tracks stored as XML that was re-parsed and re-assembled into script on every load. Sequencer is native C++ end to end: targets are resolved once and cached, values go through typed setters generated straight from the engine API, curves are evaluated in native code, sequence players tick inside the engine's parallel node-update pass - and the runtime is built to avoid per-frame allocations entirely. Sequences ship as compact binary *.seq assets.

The API story changed just as much. Tracker had no C++ or C# API at all - a *.track could be driven by the editor or by UnigineScript, and nothing else. The Sequencer's whole model is public API in both C++ and C#: build a sequence in code channel by channel - or procedurally, without an asset at all - then play it, scrub it, blend it by weight, and rebind it to different targets at runtime. A Sequence Player node covers the no-code path and plays a sequence right in the world. And where Tracker's parameter list was 532 hand-written entries, the Sequencer's is generated from the engine API itself: 3,794 animatable parameters, from lights and materials to physics, render settings, GUI and sound - a list that cannot drift out of date.

The Editor tool grew up along with the runtime - and a few things Tracker users never had are simply there now. Every edit goes through the Editor's regular undo stack; the Tracker window had none. Auto-key records the changes you make right in the viewport, gizmo drags included - with Tracker, keys were authored in its own window only. Dropping a node or an asset onto the timeline is all it takes to create a channel for it, and binding rules show a live count of the objects they currently match, so you always know what a curve is about to drive. The familiar comforts carried over, too: keys snap to frames, neighboring keys, clip edges and the playhead, every key keeps its own interpolation type - from stepped and linear to smooth, aligned, and broken tangents - and sound waveforms and camera thumbnails decode in the background, so the timeline never stalls.

Conversion of Tracks from Legacy Tracker

Old Tracker files can be easily converted into sequences. Point Sequencer at a *.track and the conversion runs on its own, carrying over every track, every key, and the objects those tracks were driving.

Asynchronous Animation Streaming

Skeletal animation now goes through the Engine resource streaming system, alongside geometry and textures. MeshSkinnedAnimation resources are loaded and unloaded as the project needs them, which cuts memory usage in projects carrying large numbers of skinned animations. It is especially effective in dynamic worlds with large numbers of unique characters, each with animations of their own. Simulate crowds, busy pedestrian crossings and packed stadiums, without the cast outgrowing the memory you have.

Streaming behaviour is configurable: forced loading is the default and has an animation ready the moment it is asked for, while asynchronous mode loads on a background thread instead. An animation's lifetime is set in frames, and left unset it stays in memory indefinitely.

What all of this costs stays visible while you work, and all of the animation metrics are now shown in the Profiler.

To learn more about animation streaming, please refer to the dedicated section of the documentation.

Animation Graph - More Advanced Features

The Animation Graph has been extended with new tools for procedural skeleton pose modification. This update adds support for IK, Look At behaviour and joint restrictions, making it easier to build advanced character rigs and runtime animation logic directly in the graph. The same solvers can be driven from application code, applied to the pose layers of a Skeleton Pose node and configured by the new parameter classes.

Procedural Skeletal Control

Added 14 new nodes for procedural pose modification, including:

Joint transform reading and writing
Two-bone IK and arbitrary-length IK chains
Single-joint and chain-based Look At
Hinge, cone, asymmetric cone, twist, and combined joint limits
A joint limit set node for IK and Look At chains

Values often have to cross a space boundary on the way in or out, so three more nodes convert positions, directions and rotations between spaces, and new Euler-to-Quaternion and Quaternion-to-Euler nodes let a rotation be driven in degrees.

New Modes for Blend Poses

Blend Poses now supports two additional mask modes: Joint List, an explicit list of joint names, and Joint Subtree, a root joint and all of its descendants:

Joint List - an explicit list of joint names;
Joint Subtree - a root joint and all of its children.

The graph preview workflow has also been improved. New Vec3 and Quat preview manipulators allow adjusting parameter values directly in the 3D preview with mouse dragging.

Preview Workflow

New Vec3 and Quat preview manipulators adjust parameter values directly in the 3D preview by dragging, and every solver and joint limit draws its own debug overlay on the skeleton.

Subgraphs now reach skeleton joints, run in a standalone preview when an *.asubgraph file is opened directly, and carry a new Preview Output Pose node that selects which pose the standalone preview shows. Graph preview compilation in the Editor has been optimized and is now significantly faster.

Other Animation Graph Improvements

Fixed several unstable Animation Graph crashes, including a crash in SkeletonRetargeter::findRetargeter.
Fixed FBX skinned mesh placement in the Editor so ObjectMeshSkinned is created by default, while ObjectMeshSkinnedLegacy is used only when explicitly selected by the user.

Navigation & Pathfinding Reworked (Experimental)

The navigation and pathfinding system has been rebuilt from the ground up, giving your AI-driven characters a modern foundation to move through the world intelligently. It now runs on Recast & Detour, the industry-standard navmesh core behind modern AI navigation, replacing the hand-authored, sector-based approach.

But the library is only the core. We converted it to double-precision world coordinates, so pathfinding stays exact even in very large worlds, aligned it with the engine's Z-up convention, and gave polygon handles a generation tag, so a reference that outlived a rebake or a streaming event is caught instead of silently pointing at the wrong polygon. Everything above that - baking, streaming, carving, queries, corridors, crowd avoidance - is our own engineering, built around UNIGINE's content pipeline and multithreading. Here is what that gets you.

Navigation Mesh Baked from Your Scene

You now bake a navigation mesh directly from scene geometry: static and dynamic meshes, clusters and clutters, spline-deformed meshes, and both terrain types. Every surface can be included, excluded, or assigned its own navigation area - and a Landscape Terrain is classified right by its detail masks: mark the road mask as one area and the rough ground as another, and the road costs less to cross.

Baking is multithreaded, runs in the Editor and at runtime - and serves both workflows: the same Recast-based baker builds the new experimental meshes and the classic Navigation Mesh nodes you have been using up to now. Even if you stay on the familiar system this release, the days of hand-modeling navigation meshes are over. The Experimental Navigation window bakes any number of meshes of both kinds in one background run while the Editor stays responsive - and the bake settings actively help: they warn when the baked data no longer matches the parameters, and even tell you, for example, the exact slope angle your current step height can climb.

For more information on baking navigation meshes in the Editor, please refer to this article.

New Navigation Nodes

Three new navigation nodes were added:

Experimental Navigation Mesh - defines the volume to bake and holds the result.
Experimental Navigation Mesh Area Volume - marks a part of the walkable surface as mud, as a road or as a place to keep out of, and cuts the surface away where a hole is needed.
Experimental Navigation Mesh Invoker - marks the place that has to stay loaded. Attach one to the player or to an active character and the tiles around it stay in memory while the rest are dropped, under a time budget and memory limit you set.

A single Experimental Navigation Mesh node covers three ways of living in your world: bake it into a reusable asset and tile-stream it across a large open world, keep the baked data carvable where things move through a fixed level, or generate the mesh entirely in memory for procedural worlds with nothing to bake beforehand. When only part of the world changes there's no need to rebake the map - invalidate a region via API and the affected tiles are rebuilt in the background, closest to your characters first.

Cost-Weighted Areas: Mud, Roads, and No-Go Zones

Walkable surfaces are classified into up to 64 cost-weighted areas with named flags, so agents prefer roads, avoid hazards, and stay out of restricted zones - with different rules per query. The new Experimental Navigation Mesh Area Volume node paints the walkable surface - or cuts a hole in it - with a box, sphere, or cylinder, at bake time or dynamically as it moves. And tuning is live: change a cost or a flag, and the very next query uses it. No rebake, ever.

Squads, Crowds, and Moving Targets

Paths are requested synchronously or on background threads with three priority levels - in batches, so a whole squad is planned in one call. Baked several navmeshes for different agent sizes? The query picks the right one automatically by matching the agent's radius, height, step, and slope. And a failed search tells you exactly why: out of cost budget, no mesh fits the agent, target unreachable.

A corridor keeps a moving agent on route as the target drifts - replanning incrementally, cutting corners where geometry allows, and revalidating itself when the mesh underneath is rebuilt or streamed. Crowd avoidance is our own multithreaded solver, not the stock Detour crowd: with agent priorities, per-agent interaction masks, and separation of overlapping agents, whole groups pass through the same doorway without pushing each other off the mesh. Dynamic obstacles are resolved at query time with no navmesh rebuild - they block the polygons they cover, reroute agents already en route, and pick up the standard Obstacle nodes already in your world. Spatial queries round it out: nearest point, random reachable point, everything within a cost budget.

The whole system is instrumented: the visualizer draws meshes, paths, and corridors with per-area colors, and a dedicated Performance Profiler panel shows the memory and per-frame cost of navigation - measured, not guessed.

Ready to Explore

A pack of navigation samples ship with the release: pathfinding around obstacles, a multi-target demo, a crowd with collision avoidance, a character driven by the root motion of its animation graph, the spatial-query toolkit, a classic-to-experimental converter, and a large-terrain scene navigating on two levels of detail - a coarse navmesh for the whole world plus a detailed one streamed and baked around the agents at runtime. All that alongside a fully refactored API (C++, C#, and UnigineScript) and documentation to get you moving quickly.

New navigation samples are available in the Navigation section of both C# Component Samples and C++ Component Samples suites (samples with the Experimental Navigation prefix.)

The new navigation system ships as an experimental feature in 2.22. This release covers the navmesh, path planning, corridors, avoidance and tile streaming; the API around them may still change as we finalize it, and more of the Recast & Detour surface follows in upcoming releases. The previous navigation system remains available.

For more information on the new experimental navigation system, please refer to this article.

Improved Gaussian Splatting Support

^{(Available in Sim and Academic editions only)}

Gaussian Splat Collider Generation

Added support for generating colliders from Gaussian splat data.

This makes Gaussian splat scenes more interactive by allowing collision geometry to be created from splats and used for navigation, physics, and walking over reconstructed surfaces.

Gaussian Splat Demo

Added a new Gaussian Splat demo showcasing splat rendering and automatic collider generation in UNIGINE. Demo content is processed by Splatica.

The demo demonstrates how generated colliders can be used to turn a Gaussian splat scene into a fully walkable and interactive environment, allowing physics, character controllers, and other collision-based systems to work seamlessly with splat-based content. It serves as a practical reference for integrating Gaussian Splats into real-time applications, illustrating how high-fidelity scanned environments can be transformed from static visual assets into interactive scenes suitable for games, simulations, digital twins, and VR experiences.

Global-Scale Geodata via Cesium Integration

^{(Available in Sim edition only)}

The new Cesium integration plugin brings global-scale geospatial data directly into UNIGINE, enabling applications that combine the engine's rendering and simulation capabilities with accurate, real-world Earth data. Whether you're visualizing a city, recreating an airfield, or building a planet-scale simulation, your content can now be placed on authentic terrain using real geographic coordinates.

This feature is a part of IG system available only in Sim edition.

Streaming the World with Cesium 3D Tiles

At the core of the integration is support for Cesium 3D Tiles, the open standard for massive geospatial datasets. Instead of loading an entire world at once, terrain, imagery, and 3D content are streamed and cached dynamically based on the camera position. As you move through the scene, higher levels of detail are loaded automatically while distant regions are unloaded, allowing datasets spanning the entire planet to remain responsive and memory efficient.

The plugin also exposes runtime statistics - including tile counts, loading progress, and memory usage - making it easy to integrate custom loading screens, diagnostics, and performance monitoring into your application.

Accurate Georeferencing at Any Scale

Building applications that span hundreds or thousands of kilometers presents unique precision challenges. The plugin addresses this by continuously rebasing the world around the camera while preserving precise geographic positioning. As a result, objects remain stable and accurately aligned with the Earth's surface regardless of travel distance.

Support for geodetic coordinates and geoid models allows developers to place content directly using latitude, longitude, and altitude, making it straightforward to integrate GIS data, GPS coordinates, or real-world assets into UNIGINE projects.

Blend Global Data with Local Content

Real-world applications often require much higher detail in specific locations than global datasets alone can provide. The plugin includes a terrain inset system that lets developers seamlessly overlay custom high-resolution terrain onto streamed Cesium data. This makes it possible to combine worldwide coverage with detailed representations of airports, industrial facilities, military bases, construction sites, or other surveyed environments while maintaining a continuous landscape.

Built for Geospatial Applications

The Cesium integration opens the door to a wide range of applications, including flight and vehicle simulators, digital twins, mission planning systems, geospatial visualization, inspection tools, and large-scale training environments. By combining real-world streamed datasets with UNIGINE's rendering, physics, and simulation systems, developers can build interactive experiences that remain accurately georeferenced anywhere on Earth - from a single building to the entire planet.

Surface ID Buffers

Simulation, computer-vision, and game development workflows as well constantly need to know not what a pixel looks like, but what it is: which object, which surface, which material, which class. Ground-truth maps for training perception systems, per-material response in sensor post-processing, isolating one object in the rendered output - all of it starts with identity, and identity is exactly what a color pipeline does not carry.

Until now, the usual route was the shared Auxiliary buffer: producing per-material, per-class, and per-instance segmentation maps required authoring each material in the material graph, packing integer IDs by hand into the limited channels of the buffer (trading off precision against the number of IDs), enabling auxiliary rendering, and writing a post-material to unpack those IDs into a color palette. Per-instance identity had to be assigned by a custom component that walked the node hierarchy, and every distinct tag effectively meant its own material instance.

UNIGINE 2.22 makes identity a first-class output of the renderer. Instead of a dedicated Material Mask texture every rendered pixel can now carry a 32-bit Surface ID, stored in FORMAT_R32U screen buffers per pipeline stage:

Opaque Surface ID - written together with the G-buffer, in the same pass as albedo and normals, so it costs no extra geometry rendering
Decal Surface ID
Transparent Surface ID
Water Surface ID
Scene Surface ID - the composite of all of the above

By default, all stages are stacked into the composite Scene buffer. Enable the multilayered mode (at the cost of one extra R32U buffer per stage), and each stage keeps its own layer - so a transparent surface such as glass and the object behind it can be segmented independently.

The ID is a key, not a color. A single lookup resolves it into the surface's parameters: node ID, surface number, instance index, Material ID - and any custom parameters you define. The Material ID resolves the same way into material parameters, including the Material Mask, which has moved from a dedicated G-buffer texture into the material parameters and grew from 24 usable bits to the full 32 (the bits previously reserved for effects such as SSAO or DoF now live in separate feature bits). And in mesh clusters, every instance writes its own Surface ID - individual trees or vehicles scattered by a cluster are distinguishable in the rendered output out of the box.

Custom parameters are declared globally in Settings -> Render -> Custom Parameters (float, int, or uint, with defaults and value ranges) and assigned per surface, per material, or per cluster instance. The values live in a dedicated parameter buffer rather than in the material - so tagging thousands of objects clones no materials, breaks no batching, adds no draw calls, and changing a value at runtime requires no shader recompilation.

Semantic labeling, out of the box. Ground-truth generation for classification and segmentation becomes a direct lookup: declare a class parameter - vehicle, pedestrian, road, vegetation - tag the surfaces, and a small post-material turns the Surface ID buffer into a labeled mask - per class, per material, per node, or per instance. No bit-packing, no palette juggling, no hierarchy-walking components.

Per-surface data for non-optical sensors. IR, radar, and LiDAR simulation needs physical surface properties that the color pipeline does not know - until now, that meant encoding an object's thermal signature as an auxiliary color on its own material instance, or deriving a LiDAR return purely from the G-buffer's roughness and metalness. With Surface ID buffers, a sensor gets a direct channel: attach a custom parameter - an emissivity class, a reflectivity index - to the surfaces themselves, and the sensor's post-material resolves it with one buffer read per pixel, at any stage of the pipeline, for any number of classes.

One material for a whole CAD model. An imported CAD assembly often arrives as thousands of surfaces sharing a single material - efficient to render, impossible to tell apart: the engineer still has to see where one part ends and the next begins. Surface IDs solve this without touching the content. Every pixel's parameter block already knows the node, the surface, and the instance it belongs to - drop a Surface Parameters node into a material graph, map any of those IDs to a color, and every part renders in a hue of its own. Nothing is configured per part, the material stays one, batching stays intact, and no extra draw calls appear. For a quick look before building anything, the Surface ID modes of the viewport's Rendering Debug panel color the scene the same way - a unique color per surface instance, shown for the opaque, decal, transparent, or water layer separately, or all of them combined.

Games, too. Compare a pixel's ID with its neighbors in a small post-material: crisp selection outlines, with none of the false edges of depth- or normal-based detection. Read the ID under the crosshair: red over an enemy, "Open" over a door - no raycast, and alpha-tested foliage just works. Give surfaces a heat parameter: the sensor workflow above turns into thermal goggles.

Reachable from everywhere. The data is available at every level you might want it: shader functions in custom materials, ready-made Surface Parameters and Material Parameters nodes in the Material Graph editor (with Node ID, Instance, Material ID, and Material Mask outputs), material texture sources, and viewport debug modes that color the scene by surface ID for a quick visual check. The API is exposed in C++, C#, and UnigineScript. The Auxiliary buffer, meanwhile, remains available - Surface IDs extend the toolbox rather than replacing it.

The Sim Samples suites show these use cases in practice: the new Segmentation sample (C++ and C#) builds seven segmentation masks of one scene straight from the Surface ID buffers, and the new LiDAR Sensor Emulation Advanced and RADAR Sensor Emulation samples (C++) derive the sensor response - LiDAR return intensity and radar echo strength - from the physical properties of the surfaces they scan.

For more information on custom parameters for surfaces and materials please refer to this article.

Sensors Updates

^{(Available in Sim and Academic editions only)}

LiDAR Sensor Advanced

For this release we've built a new LiDAR Sensor Emulation Advanced sample - an upgraded version of our LiDAR emulation with a much deeper simulation of how a real sensor perceives the world, aimed at simulating self-driving cars, robotics, and drones.

The sensor scans the scene sector by sector and measures distance and response intensity along every ray, with intensity derived from the physical properties of the surface. Both mechanical (rotating, full 360°) and solid-state sensors are supported, with configurable scan rate, detection range, and FOV, and channel angles that can be loaded from a file to reproduce a specific sensor model.

On top of that, the sample emulates the imperfections of real hardware such as motion distortion, noise effect and point drop-off, and also weather effects with fog, snow and rain models available.

Point clouds are colorized by intensity, distance, or height for easier analysis and debugging, and rendered through the new Primitive Renderer - the whole cloud goes to the GPU in a single operation with no per-element overhead, and sub-pixel mode inflates distant points below one pixel so they stay visible instead of dropping out.

The result can be exported to the LAS format.

The LiDAR Sensor Emulation Advanced sample is available in C++ Sim Samples Suite.

We've also updated our existing LiDAR Sensor Emulation sample - its point cloud now goes through the new Primitive Renderer instead of being submitted to the Visualizer point by point.

Introducing RADAR Sensor

Our new Frequency-Modulated Continuous-Wave (FMCW) radar emulation sample implements a sensor detecting moving targets by their radial velocity, position in range, azimuth and elevation in environments with varying background noise, such as a pedestrian stepping out between parked cars or a drone flying against a treeline. The strength of the echo is computed from the radar equation, so it depends on the parameters of a surface (e.g., its reflectivity per unit area), its aspect and range, rather than a target shape.

The sensor carries several independent measurement zones, each a grid of cells with its own resolution and limits, so a near zone can resolve finely while a far one reaches further with coarser cells. The field of view itself is rendered as several azimuth sectors, since one frustum wide enough for it would distort the projection, and a two-way antenna taper weakens the returns towards its edge, reproducing the beam pattern of a real antenna. The measurement can also be denied to the chosen parts of that view: blind volumes mask them out, so that the sensor does not report unwanted detections off the mounting structure, a nearby mast, or anything else placed in the way. Each zone measures velocity within a limited range, and a target moving faster is reported at a folded value, as an FMCW receiver reports it.

Detection uses Cell-Averaging Constant False Alarm Rate (CA-CFAR): each scanned cell is tested against the background around it rather than against a fixed noise level. With that the detection threshold continuously adapts to the surroundings, so a noisy area does not produce false detections and a weak target in a quiet one is not missed, with the false alarm rate set per scan. The cells that clear the threshold become detections either as individual local maxima or merged into one energy-weighted centroid per target. Built-in thermal noise and signal fluctuation make weak targets flicker between scans, and measurement jitter displaces a detection by the error the sensor would have at its SNR, so the sensor behaves the way a physical unit does under the same conditions. And by analyzing the raw cells alongside the detections, the sample also distinguishes a target that was rejected by CFAR from one that was never sampled at all, for more accurate detector tuning and sensor setup. The detections and the raw cells are rendered as point clouds through our new Primitive Renderer framework.

The RADAR Sensor Emulation sample is available in C++ Sim Samples suite.

Kannala-Brandt Fisheye Model

Your virtual cameras can get a lot more honest in 2.22. We have added support for the Kannala-Brandt generic fisheye camera model to panorama rendering, alongside the existing analytic projections. Unlike the analytic projections, Kannala-Brandt is a calibrated intrinsic mode - you can reproduce the exact lens geometry of a real physical camera. Just feed in the intrinsics from a calibration tool and the render matches the real optics (including tangential distortion and a decentered principal point) showing the true curvature, the edge falloff, the subtle imperfections and all.

In a simulator the camera is not a viewport, it is a sensor model. A perception stack fed a generic fisheye sees the wrong geometry: object sizes at the periphery, apparent motion near the image edge, and the pixel-to-bearing mapping all drift from what the hardware actually produces - and that drift resurfaces as detection failures at the frame edges once the model is deployed on the real rig. Driving the render from real calibration data closes the loop: the same intrinsics describe both the physical sensor and the synthetic one, so recorded simulator imagery is interchangeable with footage from the vehicle. On multi-camera rigs - surround-view, drone obstacle avoidance, indoor robotics - each simulated camera can carry its own measured intrinsics instead of a shared idealized lens.

Key benefits:

Sensor-accurate simulation - perfect for autonomous driving, robotics, drones, and any digital-twin workflow where the synthetic camera must match the hardware.
Bridge the sim-to-real gap - train and validate perception systems on imagery that behaves like the real sensor, not a stylized fisheye.
Full lens fidelity - real focal length, principal point, distortion, and image-circle behavior, driven straight from standard calibration data.

A Fisheye Pipeline That Goes Cinematic

The full cinematic post-processing stack comes to the panorama path - effects that simply weren't possible on our fisheye render before:

Chromatic Aberration - subtle per-channel color fringing with fine blue-noise jitter, the "real-glass" imperfection that sells authenticity.
Fisheye-Aware Vignette - a vignette that maps correctly inside the visible image circle, darkening the frame exactly the way a physical lens does.

See It in Action: the Fisheye Camera Emulation Sample

The new Fisheye Camera Emulation sample (C++ and C# Sim Samples) puts the whole stack at your fingertips. It is an interactive lens lab: switch between six distortion models on the fly - the classic analytic projections, a polynomial F-Theta, and the calibrated Kannala-Brandt - and tune every parameter live, from the principal point, focal length, skew, and image-circle radius to the distortion coefficients.

Its Physical mode works the way real projects do: describe a lens by its datasheet (sensor dimensions and focal length in millimeters, circular or full-frame image-circle fit) or plug in intrinsics straight from a calibration tool - the sample derives the pixel-space parameters for you and reports the resulting image circle. Lens imperfections are covered too: vignette presets including the natural illumination falloff of an ideal fisheye, and chromatic aberration set either directly or physically, via the glass's Abbe number. Use it as a playground - or as a ready-made reference for wiring a calibrated camera into your own simulation pipeline.

New Segmentation Samples

The C++ Sim Samples and C# Sim Samples suites now include a Segmentation sample demonstrating the new Surface ID buffers.

It produces seven segmentation masks of the same scene simultaneously - by node, by material, and by custom surface and material parameters - each one a postprocess material that retrieves a single value per pixel and resolves it to a color. The Scene, Opaque, Transparent, and Decal views show the same parameter retrieved from different layers, so you can see a transparent surface segmented independently of the geometry behind it.

Sliders in the sample rewrite the parameter values at runtime and the masks update in the same frame.

It is a working reference for what the buffers expose and how to read them - the kind of per-pixel labeling used as ground-truth data for training and validating perception systems.

Rendering Improvements

Dynamic Resolution Scaling

UNIGINE now supports Dynamic Resolution Scaling for DirectX 12 and VR.

DRS helps applications maintain smoother performance by automatically adjusting the internal rendering resolution based on GPU frame timings. When GPU load increases, the engine can temporarily lower the render resolution; when performance headroom returns, it can raise it back within the configured range.

This is especially useful for VR and other performance-sensitive applications, where stable frame timing is critical for a comfortable and responsive experience.

DRS is configured through the render_dynamic_resolution_* console commands, including target FPS, minimum resolution, and maximum resolution. For best stability, the target FPS can be set slightly above the desired frame rate.

The system is designed to avoid runtime reallocations: render buffers keep their allocated size, while only the actual rendering resolution changes.

DRS can also work together with upscalers. FSR is supported without additional limitations, while DLSS may restrict the available render resolution range depending on the selected DLSS mode.

Vulkan support is available, with further Vulkan-specific improvements planned.

Render Resolution API

You can now get actual render and output resolutions via API (not yet available for VR and advanced projection modes), when upscalers or Dynamic Resolution Scaling are used. The new API allows querying minimum render resolution, maximum render resolution, current render resolution, and output resolution, making it easier to correctly handle cases where internal render resolution differs from the final output resolution.

Reactive Mask Generation for Upscalers

Added engine-side reactive mask generation for upscalers.

The reactive mask is an R8 render buffer that controls upscaling strength per pixel, improving how upscalers handle areas that require special treatment, such as transparency, rapidly changing image regions, and fine geometry.

This also improves upscaling quality for small and thin objects, such as fences, grids, wires, and mesh-like details, reducing artifacts and helping preserve their visibility.

The engine now generates this data directly, providing consistent behavior across supported upscalers.

Enhanced Shadow System

New World Light Cascade Mode

Added a new optional mode for positioning World Light shadow cascades.

World Light cascades can now use one of two modes:

Uniform - the default mode, matching the previous behavior.
View-Fitted - a new mode that fits cascades to the camera frustum.

Uniform

View-Fitted

The maximum number of World Light cascades has also been increased to 16. The default cascade distribution starts from 0.015 for the first cascade and then doubles each next value until it reaches 1.0.

4 Cascades

8 Cascades

Cascade origin positioning has also been extended with two modes:

Auto - the default mode.
Manual - allows setting the cascade origin manually using three-axis coordinates. This can also be controlled from logic for custom positioning scenarios.

Performance may vary depending on the scene and cascade settings. With identical cascade boundaries, Uniform mode is generally expected to be faster, but the two modes are intended for different use cases and may require different settings. In some dynamic scenes, View-Fitted mode can provide comparable or slightly better performance.

This release also delivers a series of technical improvements to the shadow pipeline, refining PCSS implementation, penumbra calculations, and shadow filtering behavior for all supported light types:

Consolidated and refactored shadow and penumbra logic for World, Omni, and Proj lights, improving maintainability, consistency, and performance.
Improved PCSS (Percentage-Closer Soft Shadows) for World light shadows, providing more accurate and stable soft shadow transitions.
Enhanced penumbra rendering for World, Omni and Proj light sources, including improved contact shadows.
Penumbra size is now properly correlated with the Area Light size.
Penumbra behavior is more stable and consistent, both with Noise settings enabled and disabled.
Penumbra size now remains nearly consistent between cascades.
Setting Penumbra = 0 now correctly disables penumbra for the light.

Penumbra: OFF

Penumbra: ON

The shadow settings have been updated with the following additions and improvements:

Added Blocker Search Radius settings for World, Omni, and Proj lights under Settings -> Shadows.
Added Min Filter setting for World lights, affecting filtering on the farthest cascades.
Fixed Global Quality Settings affecting Penumbra and Filter modes.
Corrected swapped positions of Filter Noise and Penumbra in Settings -> Shadows.
Updated default penumbra values (0.5 for Omni, Proj, and World lights)

Custom Render Parameters

This release also introduces custom render parameters - project-global values that reshape the traditional way of adjusting the scene to a changing environment state or gameplay-driven effects.

In large projects where material hierarchies grow into deep trees, a single tweak to a parent material propagates updates to every dependent material across the project, not just the ones in your current scene. That cost adds up fast when thousands of materials are involved. A custom render parameter sidesteps that path entirely: no material assets are edited, no shader recompilation is triggered - the new value lands on the GPU and the result is immediate, without touching the materials themselves.

That makes it a natural fit for effects like wetness rolling in after rain, accumulating dust, dirt or snow, or a global tint, saturation, roughness or emission shift across the whole scene - you define the target parameter in the project Render Settings once and reference it wherever it's needed, selectively adjusting color, surface state, lighting, and so on. Parameters can be animated over time with the Tracker and the Sequencer tools, or set from code at runtime.

Water Rendering Improvements

The water's Reflection Roughness now actually drives the surface: planar reflections are blurred and attenuated according to it, and the Beaufort presets set it for you - glassy at Beaufort 0, progressively broken up as the wind picks up. Water also dropped its special-case "horizon" sky approximation and now goes through the standard environment-reflection path, including indirect specular normalization - sky color, scattering, and haze land in the water's reflections the way they land on every other surface.

Water tessellation used to misbehave with zoom optics and other narrow fields of view. This has been fixed in 2.22 with two new settings under Settings -> Render -> Water -> Geometry (also available as render_water_geometry_progression_fov_min and render_water_geometry_progression_fov_scale in the console) that control how the FOV redistributes tessellation. Shoreline wetness no longer depends on per-frame water visibility, fixing flickering with Landscape Terrain in the frame.

Also fixed: a crash with the viewport Depth render mode, a crash in the Global Water layers widget, raymarching probes rendered incorrectly over water, and a waterline height-solve inaccuracy.

Please note: the default Reflection Roughness changed to 0.075 (matching how water was actually shaded before). Worlds are migrated automatically; if you tuned the value, re-check your water after upgrading.

Local Contrast Improvements

Improved local contrast processing in the local tonemapper.

The order of à-trous blur iterations has been changed to run from smaller steps to larger steps. This makes it possible to reuse an intermediate blur result for enhancing mid-frequency image details without adding a separate blur pass.

This improves the flexibility of local contrast processing while keeping the implementation more efficient.

Light Roughness Offset

Added an optional roughness offset for light sources.

This setting makes it possible to simulate a light source that is not an infinitely small point, producing softer and more natural-looking specular highlights on surfaces.

The feature is available for all light types, including area lights. It can be enabled per light and controlled with a dedicated roughness offset value.

Other Rendering Improvements

Automatic white balance now produces a more accurate and stable neutral point. Instead of naïvely averaging the whole frame, the adaptation pass now weights pixels by how neutral they are and normalizes for brightness - so a few vivid or very bright objects no longer pull the balance off-color. The result is steadier, more reliable white balance across a wider range of scenes. Note, that the final rendered colors may shift in projects that use Auto White Balance correction, so make sure to review your white balance settings and re-check color-critical shots after upgrading.
Added Transparent Order for materials, replacing the previous Overlap option with three rendering modes (Before SSR, Before Post Effects, and After Post Effects) for finer control over how transparent materials are composited with screen-space reflections and post-processing effects.
Added a new blend mode for the Raymarching Environment Probe and Interleaved rendering mode for dynamic reflections.
Added cubemap reprojection for Environment Probes, improving reflections at grazing camera positions.
Added a new jitter mode for Depth of Field.
Improved indirect specular response with angle-dependent temporal clamping, reducing reflection ghosting.
Improved SSHGI stability, including a flicker fix.
Projected lights (LightProj) can now use the sky environment color, acting as sky portals for interiors.
Streaming budgets can now be set per resource type with individual cache limits.
Disabled rendering of Haze textures after Environment was disabled.
Fixed an issue where shadows from clouds were not rendered on transparent surfaces. The problem could also affect other transparent objects when refraction was enabled on one of the transparent materials, depending on the relative position of the objects in the scene.
Fixed rendering of transparent shadows from Omni and Proj lights.
Fixed Render On Water support for Raymarching Probe.
Fixed an FSR issue that caused incorrect color output when SKIP_POSTEFFECTS was used with render_upscale_order 0.
Fixed a Linux Vulkan startup issue where the engine could fail with can't find active GPU on systems with multiple GPUs or PRIME configurations. The engine now identifies the GPU by its device UUID rather than the enumeration index, so device selection is stable even when the driver reports GPUs in a different order. GPU selection is now more reliable and includes additional diagnostic logging.
Optimized Vulkan command-list management: capacity is preallocated at a much larger size and commands are appended without reallocation, removing a source of overhead in command-heavy frames.
Fixed Voxel Probe baking so it correctly takes Landscape decals into account, including all decal types.
Disabled Environment Probe lighting during Voxel Probe baking, as Voxel Probes should not include Environment Probe light in baked results.
Fixed shadow flickering in the Editor Viewport when working with nodes in the Material Editor with render_multithreaded 1 enabled.
Fixed a crash in Image::saveStream() / Image::loadStream() by using the correct data offset for cubemap arrays when loading image data from a stream.
Fixed an issue where nodes were not rendered correctly when shifting viewport Position in Stereo mode.
Fixed visual artifacts with Indirect Lighting Interleaved, where a ghost copy of a nearby object could appear under certain lighting conditions.

Physics Updates

Continuous Collision Detection Improvements

Continuous Collision Detection (CCD) has been improved for fast-moving objects, making collisions more stable and reducing tunneling issues.

CCD now works more reliably and supports an extended set of shape types (not just spheres and capsules), including shapes with local rotation. The update also fixes cases where contacts could be missed on the first physics tick or after changing an object's velocity.

UNIGINE 2.21 (Left) vs. UNIGINE 2.22 (Right)

Additional CCD fixes include:

more accurate contact correction for fast collisions;
fixed double-bounce behavior in CCD response;
improved contact generation for convex shapes, capsules, cylinders, and thin objects;
fixed unwanted bouncing and invisible-wall artifacts on Landscape Terrain;
fixed JointWheel bouncing on startup.

By default, CCD is still enabled only for spheres and capsules.

Improved Wheel Friction at Low Speed

Wheel friction has been improved to reduce sideways sliding on slopes at low speed or while standing still.

Previously, lateral friction could become too weak when the wheel velocity was close to zero, which allowed vehicles to slowly slide sideways. The new behavior applies static friction at low speed and switches to kinetic friction when the wheel starts moving.

As a result, vehicles should remain more stable on slopes and feel more predictable during low-speed movement.

Vehicles tuned around the previous behavior may feel slightly more grippy at very low speeds and may require minor tuning adjustments.

Other Physics Improvements

Fixed a crash when starting physics simulation with MeshDynamic and BodyCloth after changing Physics parameters; similar synchronization fixes were also applied to BodyRope and BodyWater.

Performance Optimizations

Faster Clutter Intersection Checks

Intersection requests against ObjectMeshClutter (the system behind large-scale vegetation and scattered objects) have been optimized significantly, with a special focus on intersections - the kinds of checks simulation and image-generator workloads rely on, such as LOS (line-of-sight) and HAT/HOT (height above/of terrain).

In scenes with large, dense vegetation clutters - especially impostor-based vegetation - running several intersection checks per frame with 2.21 could cause CPU cost spiraling, climbing frame after frame. For anyone relying on intensive sensor, visibility, or line-of-sight queries through vegetation, this was a tough issue.

After this optimization per-request intersection cost across our test scenes dropped by roughly 30x to 120x - for example, one case fell from 2.19 ms to 0.018 ms per frame. Running many simultaneous intersection requests (LOS, HAT/HOT, and similar) through dense, impostor-heavy vegetation is now fast and practical.

GPU Optimizations

Optimized Cloud Rendering

Cloud rendering performance has been improved by optimizing how cloud parameters are processed on the GPU.

The optimization is most noticeable in scenes with multiple sorted cloud layers, where rendering can be up to 1.5–2.0 times faster. Scenes with a single cloud layer also benefit from the change, with a typical 1.1–1.3x performance improvement.

The largest gains are observed on NVIDIA GPUs with DirectX 12 on Windows. Other tested configurations show no performance degradation.

Optimized MeshDynamic Memory Usage on Vulkan

Optimized GPU memory usage for MeshDynamic objects when using the Vulkan rendering backend.

The updated allocation path significantly reduces VRAM usage for dynamic meshes and brings Vulkan memory behavior closer to DirectX 12. In tested scenes, MeshDynamic VRAM usage was reduced by approximately 25–27%, while allocated VRAM decreased by about 34–36%.

This saves around 150–165 MB of video memory in the tested scenarios. System RAM usage remains nearly unchanged, with only a small increase in GPU staging memory.

Optimized Billboards and Particles

We've significantly optimized the GPU upload path for billboards and particle systems in the Vulkan renderer - bringing it in line with the Direct3D 12 implementation introduced previously. Instead of uploading per-frame geometry through intermediate staging buffers, dynamic vertex data is now written directly into GPU-visible memory when supported (via Resizable BAR), eliminating unnecessary copies and reducing CPU overhead. Billboards and particles also now share a single global index buffer, simplifying memory management and adding more detailed allocation statistics. The result is noticeably lower per-frame overhead and up to 2x better performance in particle-heavy scenes, with automatic fallback to the traditional upload path on hardware that does not support ReBAR.

Shader Cache Generation Improvements

Shader cache generation has been significantly accelerated with a new mode ( Materials::createShaderCacheForce), which force-compiles shaders by iterating through them and parallelizing parts of the compilation process. This makes cache generation much faster than the previous asynchronous workflow in large projects.

Two console commands (shaders_create_cache_force and shaders_create_cache_async) are now available.

In internal tests on a large-scale production project with tens of thousands of materials, shader cache generation time on PC was reduced from approximately 9–12 hours to just 2.5 hours.

VR/XR Improvements

VR Profiler and Debugging Improvements

Added a new profiler overlay for VR applications.

The VR Profiler is displayed only inside the VR headset and is designed to stay readable without blocking the user's view. It helps monitor performance and memory usage directly in VR, which is useful when profiling headset-specific rendering and runtime behavior.

The profiler uses a VR-friendly color scheme designed for modern headsets that receive the image through video streaming. The colors were selected to avoid combinations that are commonly degraded by video compression, such as bright red or dark and low-saturation blue.

Similar to the standard profiler, the VR Profiler supports two display modes:

Basic - a compact view with key performance metrics.
Advanced - a detailed view with extended profiling information.

VR Emulation has also been improved with a new mirror mode. It allows both VR viewports to be displayed on the screen, which makes debugging easier in cases where the Editor and VR output need to be used at the same time.

The mirror output can be controlled using the vr_emulation_mirror_mode setting. Additional mirror view settings have also been extended with crop factor support.

Device battery information can now be retrieved when supported by the OpenXR runtime. This is based on the XR_EXT_interaction_profile_battery_state_display extension, which provides battery state data for interaction profiles.

Extended Localization Support

The text pipeline now supports a much broader range of complex writing systems, including Arabic, Persian, Urdu, Hebrew, Hindi (Devanagari), Bengali, Tamil, Thai, and Khmer.

This includes (where required):

proper right-to-left handling
bidirectional text
contextual glyph shaping
combining marks
character reordering

Applications that previously needed custom text rendering solutions for these languages - or could not support them at all - can now localize their interfaces using the engine's native GUI system.

Missing glyphs no longer break a screen either. A new font fallback system fills gaps your main font doesn't cover, with fallback fonts included for the core GUI and a BootConfig API for registering your own - so a translation dropped in late doesn't come back as boxes in the UI. Shaped text is cached for widgets and the system console, so wider coverage costs nothing per frame.

The Editor gained the same coverage, which means multilingual content can be authored and reviewed in place instead of round-tripping through external tools to check whether it renders.

Fonts Sample

A live tour of the above: six languages with varied writing systems across GUI widgets, 3D ObjectText and world-space ObjectGui, with text direction, cursor behavior and font size adjustable on the fly. Available in both the C++ and C# Component Samples..

NoesisUI Integration

The NoesisUI Integration sample has been added to demonstrate how to integrate NoesisGUI, a high-performance, cross-platform UI framework based on Microsoft's XAML technology, into UNIGINE projects. NoesisGUI enables developers to build modern, data-driven user interfaces using familiar XAML workflows and supports advanced features such as animations, templates, styling, and MVVM architecture. The sample provides a practical reference for setting up the integration, connecting UI logic with the engine, and accelerating the development of polished in-game tools and interfaces while taking advantage of NoesisGUI's mature authoring ecosystem.

For more information see this article.

The source code (C++/C#) is available on GitHub:

Other Engine Improvements

Added SDL joystick support to SystemProxyQt.
Fixed a Material Graph issue where using the same subgraph with custom UUSL code in multiple material slots could cause generated shader code to fail compilation. The fix resolves possible name collisions during repeated subgraph instancing, including cases with default function arguments in custom UUSL code.
Fixed a crash and possible D3D12 shader cache corruption when shaders were compiled simultaneously by the Editor and a running project.
Reduced Microprofile memory usage on CPUs with a large number of logical processors.
Added skeleton import for USD assets.
Added frame filling for glTF animations with sparse keyframes.
Updated the engine splash screen.
Fixed DirectX 12 GPU cache handling on NVIDIA GPUs. Previously, unstable or incompatible PSO cache data could cause .gpu_cache to be invalidated on every startup or lead to crashes when switching between C++ and C# applications. Cache compatibility is now checked before use, and incompatible cache data is recreated automatically.
Optimized Particles::update() performance by reducing the overhead of temporary shape creation.
Fixed GPU matching for CUDA interop when UNIGINE GPU order differs from the system order, ensuring the correct CUDA device is selected for the active render adapter.
Fixed Vulkan validation errors and exit assert issues when running with video_debug 2, including cases during LightProj, LightWorld, LightOmni, and EnvProbe baking.
Improved math library compatibility between C++ and C#, simple math types are now handled as trivially copyable types.

Project Templates

ArduPilot SITL Integration

^{(Available in Sim edition only)}

We've added ArduPilot SITL (Software-in-the-Loop) support to the UAV Template, enabling real autopilot simulation without hardware. ArduPilot runs its full control stack natively on your PC, while the template acts as an external physics engine, providing the airframe, world, and sensor data over UDP. This means every MAVLink ground station (Mission Planner, QGroundControl, MAVProxy) works exactly as it would with a physical drone.

The integration is split into two layers: a reusable bridge module that handles UDP communication and coordinate conversion (ENU to NED), and a vehicle-specific integration layer that maps PWM inputs to drone physics. We currently support both multirotor and fixed-wing vehicles. If the SITL link drops, the drone seamlessly falls back to its internal flight model.

Launching SITL works through either Mission Planner (Windows, one-click binary download) or MAVProxy via WSL/Linux (built from source).

The result is a development environment where you test against the exact same autopilot stack your hardware will run, with behavior matching the physical drone.

VR Multiplayer Template

This release introduces a new VR Multiplayer project template that provides a practical foundation for developing networked VR and desktop multiplayer experiences with UNIGINE.

Built on Steam Networking, it demonstrates how to integrate it with the Engine and synchronize multiplayer state across connected peers, providing a clear reference implementation that you can use as the base for your own multiplayer architecture.

The template supports both VR and desktop players within the same session, enabling collaborative or competitive scenarios across different hardware setups. It includes a built-in Steam Lobby system, seamless late joining with automatic synchronization of the current session state, and a complete free-for-all multiplayer sample featuring synchronized player avatars, shared object interactions, networked physics, instant respawning, networked weapons with multiple firing modes, as well as scoreboards, text chat, and proximity voice chat powered by Steam Voice and FMOD.

The networking layer is built around a trust-based synchronization model in which each peer is authoritative for its own state and network events are propagated without server-side validation. It also illustrates an approach to handling different types of multiplayer traffic by separating reliable gameplay events, such as hits, ownership changes, chat messages, and session snapshots, from continuously streamed data including avatar poses, object transforms, and voice. This separation allows each type of data to use the synchronization strategy best suited to its requirements: critical events are delivered reliably and in order, while frequent updates prioritize low latency over perfect delivery - dropped packets are simply replaced by the next one. Together, these systems provide a clear and extensible reference architecture that you can build upon when implementing your own multiplayer solutions.

Designed as both a learning resource and a practical starting point, the template provides reusable building blocks that you can easily adapt for multiplayer training simulators, collaborative VR applications, and other interactive real-time experiences.

What it covers:

Steam integration - lobby creation, session, player identity, member list, and connection lifecycle.
Two transports - a reliable channel for control messages (lobby, commands, ownership, late-join) and an unreliable peer-to-peer path for frequent transform updates (avatar poses, held objects), sent directly between players rather than relayed through the host.
Protocol serialization - a single message codec and protocol layer.
State replication - avatars, weapons, and combat state synced across VR and desktop players in one session.
Late join - a new player receives a snapshot of the current match state.
Ownership transfer - held objects can pass between players (last-writer-wins, no arbitration).
Proximity voice - radius-based, push-to-talk, built on Steam Voice, positioned at the avatar.
Graceful degradation - if Steam or voice libraries aren't present, only that feature is disabled instead of the app failing.

C# (WPF) Empty Template

^{(Available in Sim and Academic editions only)}

We have added a new project template for those building desktop applications on Windows Presentation Foundation (WPF), for embedding the Engine into a product you already have.

The Engine renders into a viewport that sits among your panels, toolbars, and docked windows, and runs on a dedicated thread, so full frame rate and a responsive interface are never a trade-off. Input, window management, fullscreen, multi-monitor and DPI, clipboard, and system message dialogs all come working out of the box, with mouse capture confined to the viewport so WPF controls keep behaving like WPF controls.

AI Workflow Improvements

In 2.21 we introduced AI Docs: a version of the engine documentation optimized for AI agents, plus a set of system prompts covering engine fundamentals and coding conventions. It fixed what agents got wrong about the engine, so the code they wrote matched the API that actually exists.

Earlier you had to download the MCPBridge editor plugin from the Add-On Store and add it to your project manually. AI Toolkit in 2.22 replaces the AI Docs option and brings the documentation, prompts, and Editor integration together into your projects in a single click on creation or configuration. The agent inspects the live scene, edits it through the Editor's own API, and sees the result.

Editor Integration

MCPBridge has grown from 27 tools to 58. What an agent can do with them:

Build and edit the scene: create nodes from primitives, templates or project assets, then clone, rename, reparent, transform, enable, delete and select them; attach and configure component properties; edit surfaces and their material bindings; set up physics bodies and shapes
Build material and property hierarchies: create, clone, re-inherit, inspect, update and remove, instead of only assigning what already exists
Look before it acts: spatial queries report what occupies a region, what a ray hits, and the real surface height at a given point, which is what keeps a crate from ending up halfway inside the terrain
Check its own work: viewport screenshots come back as images, and every node, material and setting can be read back in full
Handle the project around the scene: assets with per-format import settings, dependencies, landscape maps, engine and environment settings, presets
Bake and profile: lighting and probe bakes with progress reporting, profiler counters, streaming and VRAM statistics, per-surface draw and memory cost

The engine console is fully supported too, for anything that has no dedicated tool!

Connecting an Agent

1. Enable AI Toolkit for the project, at creation or later in Project Configuration.

2. Open the project in an AI-powered IDE, or point a CLI agent at the project folder.

3. In the Editor, open the MCP Bridge panel. The server runs inside the Editor over HTTP+SSE on localhost, with no external scripts or proxies to keep alive, and comes up with the Editor on the port you choose.

4. Press "Write config files to project" to generate the client configuration: .mcp.json for Claude Code and Cursor, .vscode/mcp.json for VS Code, .gemini/settings.json for Gemini CLI and Qwen. The panel also has ready-made snippets for Codex, Windsurf, Cline, Zed and others. Most agents pick up the tools on their own; reconnect the agent if yours does not.

5. Ask for something, and watch the scene change.

To learn more, please refer to this article.

Machine Learning Agents Demo

Introducing a new demo - a practical starting point for reinforcement learning inside the Engine - autonomous systems, robotics, crowd and traffic simulation, adaptive gameplay.

Four worlds cover the core patterns. Agents learn from vector observations, ray-cast sensors, or raw camera images, across tasks from single-agent continuous control to adversarial pairs and competing teams. Up to 128 agents train in parallel, feeding one shared policy network. Each world ships with a pre-trained ONNX model, so agents perform from the first launch, plus a full trainer: PPO and SAC with configurable hyperparameters, TensorBoard curves, checkpoints, headless mode, and an open gRPC protocol - swap in Stable-Baselines3 or your own. Environments randomize every episode so agents learn the skill rather than the layout; seeded runs still reproduce exactly, and curriculum learning raises difficulty as agents improve.

It's all built from reusable logic components: train on your scenario, export the policy, drop it into your application. To learn more about the demo, and how you can use it for your own ML agents please refer to the dedicated article.

Plugins

RTSPStreamer Plugin

^{(Available in Sim edition only)}

Added the new RTSPStreamer plugin for publishing rendered UNIGINE camera views as live H.264 RTSP (Real-Time Streaming Protocol) streams.

The plugin renders a selected Player camera into a GPU texture, converts the image from RGBA to NV12 on the GPU, encodes it using NVIDIA NVENC, and streams the result through the built-in RTSP server.

The plugin is intended for simulation, monitoring, remote operation, video analytics, recording pipelines, and other workflows where UNIGINE-rendered imagery needs to be consumed by external RTSP-compatible tools such as VLC, mpv, ffmpeg, GStreamer, or custom video processing systems.

Multiple streams can run simultaneously. Each stream can use its own camera, resolution, target FPS, bitrate, render-target slot count, and encoder settings.

The plugin also supports:

stream setup directly on Player nodes via Editor components;
TCP and UDP RTSP transport modes;
optional encoded-frame callbacks for custom network or storage backends;
runtime debug overlays and custom user widgets;
low-latency H.264 streaming settings.

The rendered image stays on the GPU throughout the pipeline, including color conversion and encoding, which avoids CPU readback and reduces system memory traffic.

The plugin requires an NVIDIA GPU with NVENC support and a compatible NVIDIA driver. Vulkan and Direct3D 12 rendering backends are supported.

WebStream Plugin

^{(Available in Sim edition only)}

We continue developing the plugin and for this release made a number of improvements:

Fixed bitrate calculation in the WebStream plugin. The bitrate limit now depends on stream resolution and frame rate, and the signaling server provides a recommended value that can still be overridden when needed.
Fixed excessive RAM usage when streaming started before a world was loaded. Frame grabbing now correctly respects the configured streaming max FPS, preventing uncontrolled frame capture on empty worlds.
Improved browser disconnect handling and thread safety to reduce crashes and Device Removed errors when refreshing the browser page during streaming.

ScenarioManager Plugin

^{(Available in Sim and Academic editions only)}

Introducing a new ScenarioManager plugin, providing a lightweight visual scripting system for UNIGINE. Instead of implementing scenario logic in compiled code, developers can create behavior graphs in a web-browser-based visual editor, while a high-performance C++ interpreter executes the graph every frame without requiring recompilation. This enables rapid iteration by allowing scenario logic to be edited and reloaded on the fly from JSON graph files.

The plugin includes around 150 built-in nodes covering math, flow control, vectors, events, variables, arrays, debugging, and subgraphs, along with a breakpoint debugger, graph hot reloading, and an HTTP API for external integration. It also integrates with DataBridge, enabling real-time publication of script state as well as remote graph loading, unloading, and control.

ScenarioManager is designed for data-driven workflow development, reducing the traditional edit–compile–run cycle and making it possible for designers, technical artists, and domain experts - not just programmers - to build and modify interactive logic. It is particularly well suited for applications such as VR training, simulation, inspection, and digital twin scenarios, where complex workflows need to be iterated quickly without rebuilding the application.

The plugin is currently integrated into the MRO Project Template, but it can be used to implement various scenarios in any project - just click Advanced Settings -> Plugins and choose Scenario Manager in the list when creating a new project or configuring an existing one.

Other Plugin-Related Changes

DataBridge plugin was extended with new types and UI.
Outdated plugins for Maya and 3DS Max were removed.
Extended FMOD plugin API coverage
FMOD can now play sounds directly from memory, not only from files. This makes it possible to play audio stored in Blob data, including sounds loaded from *.ung packages.
Added Event support for plugins.
Added the possibility to configure the logging scope in the MediaPlayer plugin.

UnigineEditor

Multiselection for Curve Editing

The Curve Editor now supports multiselection.

When several objects of the same type are selected, a single Curve Editor window can edit the same parameter across all selected objects at once. This is supported for particle object nodes, materials, and property nodes.

Curve changes are applied to all edited objects immediately, including key editing, tangents, infinity modes, scale changes, reset, and paste operations. Undo and redo also work across all affected curves.

The Curve Editor now reuses existing windows for the same selection and parameter, correctly handles selection changes, and updates or closes automatically when edited objects are removed.

This makes it much easier to adjust shared curve parameters across multiple objects without editing them one by one.

Flexible .NET Runtime Version

UNIGINE is no longer tied to a fixed .NET runtime version, giving developers more freedom when configuring C# projects.

Projects can now be built and run with the .NET version that best fits their requirements, making it easier to update runtime environments, align with existing infrastructure, and adopt newer .NET features when needed.

The selected .NET version must still be supported by the project code and its dependencies. The minimum supported .NET version is 6.0.

Editor Console Improvements

Improved the Editor Console with several quality-of-life updates.

Repeated errors can now be collapsed, making logs easier to read during debugging. Console commands can be found by partial match, and console output can now be searched directly.

The console also supports filtering messages by type, allowing users to show or hide messages, warnings, and errors separately.

For C# workflows, console output can now be cleared automatically when starting logic playback.

System Information Window

Added a new System Information window to the Editor.

The window provides quick access to engine, application, plugin, and hardware details, making it easier to check the environment where the Editor is running.

System information includes engine version, binary configuration, enabled features, application paths, loaded plugins, graphics API, OS, CPU, RAM, and GPU details.

The window is available from Help -> System Information.

Asset Browser Search Optimization

Optimized Asset Browser search performance in large projects.

Search input, cancellation, and full-name filtering are now significantly faster on both Windows and Linux. In tested large projects, common search operations became several times faster, with the most noticeable improvement when clearing or canceling search queries.

Average speedup across tested Windows and Ubuntu configurations. The following queries were tested:

Expanded Editor API

Editor API is now extended with asset dependency search methods. Users can create custom tools for collecting and exporting all content required by a scene, object, or selection. The API can be used for project content transfer, client delivery workflows, DLC creation, and runtime content packaging without relying on the Editor export pipeline.

A new Dependency plugin is now available among other Template Editor Plugins in the Project Creation/Configuration window of the SDK Browser.

Other Editor Improvements

Fixed FBX export for skinned meshes, which can now be exported correctly with skeletons, joints, skin weights, morph targets, and animations instead of being converted to static meshes. A new Export Skinned Animations option has also been added to include animations only when needed.
Hash calculation for text assets now ignores line-ending style, so checking out the same project with different CRLF/LF settings no longer regenerates hashes and rewrites .meta files.
Added mouse settings for viewport navigation (Editor Settings -> Controls -> Mouseрџ�ћ a Sensitivity slider for camera look speed, and an Adapt to Field of View option that scales mouse-look speed with the current camera FOV - a zoomed-in camera turns proportionally slower, giving you precise aiming instead of overshooting. The settings also apply to asset preview viewports and are available via the Editor API.
Added a Bake Base Into Layer action for Landscape Layer Maps: it bakes the composite of the layers below it (by their order) into the selected layer, so the layer inherits the base terrain - height, albedo, and masks - as its own data and can then be edited with the ordinary terrain brushes. Re-run the bake at any time to pick up changes in the base layers; baking shows progress, can be canceled, and offers to decompress compressed layers on the spot.
FBX, GLTF, and USD import now strips characters that are invalid in file names when generating output files from node and material names.
Added the possibility to control SSGI (Screen-Space Global Illumination) parameters via Tracker.
Added UV preview to the parameters window for geometry assets.
Added the dialog for enabling dynamic reflections when adding a dynamic probe or planar probe to the scene where dynamic reflections are disabled.
The + button in the Materials window can now create a new Material Graph even when no material is selected.
Fixed incorrect rotation baking for spherical impostors generated from MeshClutter. Previously, when baking a spherical impostor from MeshClutter with non-zero rotation, the impostor atlas could be generated as if the rotation was zero. As a result, the impostor could look different from the original clutter object. Spherical impostors now correctly bake the full mean rotation of the source MeshClutter. Octahedral impostors and impostors for non-clutter objects are not affected.
Fixed an issue on some Linux systems where regular mouse clicks could be incorrectly detected as double-clicks.
Fixed an Asset Browser issue where selection could shift and include extra assets after deleting items in folders with many assets.
Optimized creation of mount points to prevent progressive slowdown when creating many mount points in large projects.
Fixed an issue where the license error dialog could become inactive if it appeared while placing a node in the Editor.
Fixed camera controls, MMB input, keyboard input, and hotkeys after opening dropdown lists or clicking system windows.

Sandworm Tool

^{(Available in Sim and Academic editions only)}

We continue developing the Sandworm tool (procedural scene generation from the real geodata) to make it as helpful as possible. Here's the list of additions, improvements and fixes that are coming with this release:

Added NoData support:
- Source layers, including TMS, now have a NoData Value parameter that overrides the NoData value specified in the source metadata.
- The new NoData section in Generation Settings provides the Replace NoData option defining the value that NoData pixels found in the source data are replaced with.
- The new Fill NoData Areas option (Off, Height Min Value, NoData Value) defines how the elevation areas left uncovered by the sources are filled.
Added new River object settings: Split Line Length, Adjust Terrain Masks, and Area Width.
Added a console message indicating terrain generation completion.
Added animation when clicking the plus button in the Sources tab.
Added height correction support for EGM96 and EGM08 models.
Added the Ctrl+S shortcut for saving changes in the Sandworm window.
Vegetation object now accepts a *.node file holding a group of vegetation objects (ObjectGrass / ObjectMeshClutter / WorldClutter) - each of them covers the same area.
Root objects can now be enabled/disabled in the Sandworm scene tree, and the enabled state of a parent object no longer overrides the state of its layers.
When changing the Object node for Vegetation, Road, or Point objects, a message is now displayed, prompting users to save changes before closing the Sandworm configuration window.
Files in supported GDAL formats are now displayed in the Asset Browser.
The area size in Generation Settings is now displayed in a user-friendly format.
The generation progress bar now displays more informative messages.
Reduced excessive console output during generation.
Visualization of landcover masks and vector data has been improved: only the selected data is now displayed in the preview.
The boundaries of the selected layer are now highlighted, while boundaries of all other layers are hidden.
Preview of all layer sources is now shown on top of the map when selecting a layer.
Increased the download speed of preview generation.
Sandworm built-in assets (road/river/building materials and textures) have been moved into the plugin data folder; preset materials are now resolved by name.
Fixed roof generation for buildings.
Fixed an issue causing sources, object states, layer settings, and generation parameters to reset. They are now saved properly and remain unchanged after reloading a project.
Fixed Z-fighting when generating a River layer on a Landscape Terrain without a heightmap.
Fixed road generation when the Adjust Terrain Heights and Masks and Smooth Threshold options are enabled for Landscape Terrain.
Fixed main resources being blended into landcover masks.
Fixed a crash when using mask layers.
Fixed memory leaks when regenerating a Sandworm project.
Fixed camera positioning when ObjectLandscapeTerrain is generated based only on Vector Objects.
Fixed a crash when generating roads in Tiling mode.
Fixed broken road textures.
Fixed an issue where a ghost source layer appeared after creating a new River object.
Fixed occasional disappearance of filters selected via a combo box.
Fixed filtered vector objects not being displayed at the first attempt.
Fixed removal of previously added TMS sources when changing the coordinate system.
Fixed generation of an empty Vegetation object when only Vector data type objects are generated.
Fixed a corner case in layer selection on the map preview by left-clicking within layer boundaries.
Fixed the layer preview order: the selected source is now always displayed on top.
Fixed Global Terrain generation to properly take the Curved/Flat option into account.
Fixed visualization of adjustments in the Export Quality setting.
Fixed undo/redo behavior for the Export Quality settings of Landscape Terrain.
Fixed generation of additional objects for Building and River objects when they are partially outside the generated area boundaries.
Fixed incorrect generation of manually set Global Terrain LODs.
Fixed recalculation of the Disk Space Required value when changing boundaries.
Fixed artifacts on preview regeneration when changing boundaries in the map view.
Fixed a crash when closing the Loading Layer progress bar.
Fixed a crash when generating terrain with an elevation layer containing GeoTIFF data with color indices.
Other bugfixes.

IG Updates

^{(Available in Sim and Academic editions only)}

IG Control Panel

We developed IG Control Panel, a deployment and control tool for multi-node runtime setups.

The tool allows an operator to synchronize projects to runtime nodes, launch and stop engine processes, monitor node status, and manage distributed IG setups from a single machine. Project synchronization is currently available through SVN.

The system consists of the IG Control Panel running on the operator machine and IG Control Panel Agent running on each runtime node.

Wireshark Plugin for Syncker

The Wireshark dissector plugin has been added for UNIGINE Syncker, making it easier to inspect and debug multi-display synchronization traffic.

The plugin decodes Syncker UDP packets directly in Wireshark, including connection setup, time synchronization, MTU checks, reliable transport data, and internal synchronization messages. It also supports fragment reassembly, LZ4 decompression, dynamic slave port detection, protocol version selection, and double-precision builds.

CAVE Generator

The SpiderVision plugin was extended with a CAVE setup generator for multi-monitor and multi-projection configurations.

This simplifies the initial configuration of multi-projector CAVE environments and reduces the amount of manual setup required: you can quickly create a CAVE projection layout by specifying the setup dimensions, display name prefix, and mirroring options for side, top, and bottom displays.

Other IG Plugin Improvements

Added an option to disable interpolation for all DIS entities. DIS entities can now be placed directly at the last received position and orientation without interpolation or extrapolation. This behavior is similar to IG::CIGI::Connector::setIgnoreInterpolation(bool ignore) for CIGI.
Fixed a crash in the IG Plugin and subsequent Editor crash that could occur after saving property changes on a node inside a Node Reference.
Fixed an issue where a Syncker slave could lose connection with the 500 sequences queued, slow receiver? error after about an hour of operation.
Fixed an initialization order issue where plugins depending on Syncker could start before Syncker was ready, causing startup errors when using the sync_master 1 console command.
Fixed image stretching in IG caused by aspect correction being applied twice; SpiderVision keeps its own projection behavior and continues handling virtual resolution through its own warp/projection pipeline.
Improved warnings to make them more informative.
Fixed incorrect DIS entity rotation at certain Pitch and Roll angles when DIS and CIGI are used together.

Samples

To help you get the most out of UNIGINE, we've significantly expanded the sample library - new content has been added, and existing samples have been revised to reflect the latest features and tools. Whether you're learning the Engine or solving real-world tasks, you'll find relevant examples that are ready to use out of the box in our sample suites.

D3D11 Interop Samples

Added new D3D11 interop samples for DirectX 12.

The samples demonstrate texture and buffer sharing between external DirectX 11 resources and UNIGINE running with the DirectX 12 backend.

Currently, the samples are supported only with DirectX 12. Vulkan support is planned for future updates.

C++ / C# Component Sample Suites

New Navigation Samples

The C++ Samples suite now includes seven samples built on the new Experimental Navigation System.

Experimental Navigation Mesh queries a route between two points around obstacles for an agent of a given size, so a path is only resolved where the agent physically fits: the walkable surface leaves out the slopes it cannot climb and the steps it cannot get over. An unreachable target gives a partial route up to the last reachable point together with the failure reason.

Experimental Navigation Mesh Demo runs several autonomous agents simultaneously: each one plans its own route to a moving target and replans dynamically when the target shifts, when the corridor is invalidated by a navigation mesh change, or when no complete route is available yet.

Experimental Navigation Mesh Queries covers spatial queries about the walkable area, without building a full route. The sample allows you to get the agent's nearest walkable position, the area reachable within a travel cost limit, the boundaries of the walkable surface, and the polygons inside a given volume by switching between various query modes.

Experimental Navigation Mesh Crowd moves a crowd of up to three hundred agents that plan their own routes and are steered around each other to avoid collision. The sample provides three navigation scenarios: two teams swapping sides through the gates, agents crossing a circle, and a free wander between random points. The avoidance parameters are adjustable at runtime, agents can be given priorities and split into groups that ignore each other, and a density heatmap shows where the crowd jams.

Experimental Navigation Mesh Character drives an animated character over an Experimental Navigation Mesh, where the movement comes from the root motion of the locomotion animations. The animations are played at the rate matching the requested walking speed, with direction changes limited by the rotation speed of the character.

Experimental Navigation Mesh Terrain showcases building a complex hierarchical navigation model with two Experimental Navigation Mesh nodes of different resolution: a coarse mesh covering the whole world, and a detailed one whose tiles are continuously baked and streamed following the agents at runtime. Each route is planned on the global mesh and split into legs, each constructed on the detailed mesh, as the agent works its way around the obstacles. Obstacles can be spawned to cut the walkable area out of both meshes, and the affected tiles are rebaked as the layout changes. That is a full-scale open world setup that supports large yet detailed terrain without sacrificing quality for performance.

Experimental Navigation Mesh Conversion exchanges navigation data between the classic Navigation Mesh and the Experimental Navigation Mesh. Both meshes are baked with the new baking pipeline from the same settings, over the same geometry, so the two walkable surfaces can be compared side by side. The classic polygon mesh can be converted into the experimental tiled format, and back to the classic node in memory or saved to a file.

All of them expose their parameters at runtime and let you move things around to watch the routes resolve against the changes. This new set of Experimental Navigation Mesh samples shows what the system is capable of and makes the switch to the new navigation smooth.

Porting Samples To Animation Graph

We've also ported a number of existing animation samples to Animation Graph - our visual node-based animation system that we introduced in the last release. You can easily identify them by the [Animation Graph] tag in the sample name.

Five animation samples from the C++ Samples Suite are now built around the AnimationSequence API:

Global Engine Parameters Animation
Node Parameters Animation
Property Animation
Animation Layers Playback
Widget Animation

And starting from 2.22 the following samples are also available in the C# Component Samples Suite:

Global Engine Parameters Animation
Node Parameters Animation
Property Animation
Physics-Based Animation
Widget Animation

C++ / C# Sim Sample Suites

^{(Available in Sim and Academic editions only)}

Cross Section Visualization, Airfield Ground Lighting and Thermal Sensor Emulation samples have been moved from the Art Samples to C++ Sim Samples Suite.

Primitive Renderer

For this release we've added a new reusable, Primitive Renderer framework for drawing all sorts of visual helpers, such as debug overlays, sensor point clouds, trajectory trails, flow fields, in-world gizmos, etc.

A new sample demonstrating the capabilities of the Primitive Renderer framework has been added to the C++ Sim Samples Suite. The sample showcases several primitive types and their usage modes, each functioning independently on its own layer, from animated point swarms and dense clouds of up to a million points uploaded to the GPU in a single operation every frame, to wireframe curves and line grids visualizing vector fields, world-space ribbon trails, and a screen-space HUD. Together they cover the whole range of visualization needs, with support for both Immediate and Retained modes.

The Primitive Renderer is a powerful tool for drawing large numbers of primitives in your projects, whether you're creating a LiDAR point cloud visualization, aircraft and vehicle trajectory trails, waypoint and route markers, telemetry graphs and screen-space HUD overlays, or general-purpose debug drawing and diagnostics.

The framework is already in use across the C++ Sim Samples suite: both the updated LiDAR Sensor Emulation and the new LiDAR Sensor Emulation Advanced samples render their point clouds through it.

CCTV

The new CCTV Simulation sample demonstrates rendering multiple camera feeds into individual textures and arranging them as a live monitor wall using GUI widgets - perfect for simulating security camera systems or any multi-feed monitoring setup. Camera outputs can be displayed on screen or any scene geometry, with runtime grid/fullscreen switching.

Sensor Zone Visualizer

The new Sensor Zone Visualizer sample procedurally generates four configurable sensor fields of view on a single object, with a wide-angle fisheye option for side frustums. This functionality is useful for simulating camera coverage, radar sweeps, or any directional detection system.

Measurements

The new Measurements sample demonstrates real-time distance measurement between a movable node and objects in the scene, with each ruler color-coded for quick visual reference. Useful for spatial analysis, level design, or any application requiring precise distance feedback.

High-Level Car Physics System Sample

The sample now drives a modern off-road vehicle, suited to rough terrain and changing road surfaces, where a transfer case with a low range and locking differentials come into their own.

SDK Browser

Cross-OS Project Support

Added support for Cross-OS projects, allowing the same project to be used safely on both Windows and Linux.

A project can now be created on one operating system, transferred to another, and upgraded to Cross-OS mode in SDK Browser. SDK Browser adds the required binaries for the current platform, marks the project as Cross-OS, and tracks platform-specific files in the .project file.

When upgrading or reconfiguring a Cross-OS project, SDK Browser updates only the files for the current operating system and notifies the user if the project also needs to be upgraded on the other platform.

This keeps the standard single-OS workflow unchanged while making shared Windows/Linux project development more reliable.

Renaming Projects via SDK Browser

Finally, we have a possibility to rename projects in SDK Browser.

Projects now have a separate display name field that can be edited without changing the actual project name, code structure, or project identity. By default, the display name matches the original project name.

The display name can be changed by double-clicking the project title or from the project card menu. The change is stored only in the *.project file and does not affect building or migration.

Proactive Disk Space Checks

Improved disk space handling in SDK Browser by adding proactive disk space checks for SDK installation and project creation workflows. Available storage is continuously monitored throughout download, extraction, installation, and project creation tasks - if space runs low, instead of a silent failure the user gets a notification, and the current task is preserved whenever possible so it can be resumed. Disk space requirements are now tracked individually for SDKs, demos, templates, documentation, and projects, making installation workflows more reliable and predictable.

SDK Component Cleanup

When upgrading or deleting the last installed SDK edition of a specific version, SDK Browser now offers to remove related demo projects, samples, and documentation for that version, helping reclaim disk space and prevent obsolete content from being left behind.

Improved Template Information Window

Redesigned the template information window in SDK Browser.

The updated window provides a larger and more flexible layout, improved version descriptions, clearer action buttons, and better handling of long content. Version details can now be expanded directly in the version table, with Download and Create Project actions available in the expanded view.

Download and delete actions now better reflect the template state, including separately downloaded templates, empty templates, and templates provided through an installed dependency SDK.

Documentation

Added a new documentation section on the Sequencer tool - from the editor basics and the channel reference to runtime playback and legacy track conversion.
Added a new Animation System overview article, and an Animation Streaming section to the Asynchronous Data Streaming article.
Updated the Animation Graph Editor articles, including the new procedural skeletal control nodes (IK, Look At, joint limits).
Added a new article on Surface ID and Custom Parameters, along with the corresponding settings reference.
Added a new documentation section on the Experimental Navigation system, and updated the Navigation and Pathfinding programming guide.
Added a full documentation set for the Scenario Manager Plugin.
Added new articles on the WebStream and RTSPStreamer plugins.
Updated the Sandworm articles - sources, generation, and workflow.
Updated the Physical Bodies and Terrain articles.
Updated the IG documentation, including the multi-monitor output and SpiderVision display configuration articles.
Updated the VR & XR Development articles, the AI-Assisted Development articles, and the aviation project template guides (fixed-wing, rotary-wing, UAV).
The complete list of API changes is available in the API Migration Guide.
The complete list of Console command changes is available in the Console Commands Migration Guide.

September 11

2.22.0.1 Hotfix

Thank you all for your valuable feedback and bug reports helping us get better. This hotfix resolves a number of issues introduced in 2.22.

Upgrading to 2.22.0.1 does not require any code or content migration.

The updated version of the documentation is available as 2.22.

Engine

Added slope fade parameters for Environment Probes (Slope Fade Angle / Angle Softness / Distance / Distance Softness) - beyond a trusted distance from the probe center, its contribution now fades out on steep surfaces, preventing wrong reflections and ambient lighting leaking onto walls outside the probe's reliable radius. Available via API and in the Editor.
Reworked SSR thresholds: render_ssr_threshold and render_ssr_threshold_occlusion are now absolute values independent of the raymarching step size, so tuning them no longer shifts as step settings change. The infinite last ray behavior can now be toggled via render_ssr_infinite_ray (enabled by default). SSR quality preset defaults were retuned accordingly (full-resolution SSR with increased accuracy and a finer, shorter ray march). Note: SSR in existing projects may look different after upgrading and may require re-tuning.
Improved handling of disoccluded areas for upscalers: newly revealed regions are now added to the reactive mask (controlled via render_upscale_fix_disocclusion_depth_threshold), and a dedicated flicker fix was added, reducing ghosting and flickering where geometry disoccludes. The obsolete render_upscale_fsr_use_old_frame_reactivity console variable was removed.
The reactive mask is now also generated when plain TAA is used (previously for upscalers only), improving anti-aliasing of transparent and fast-changing content under TAA; a Reactive Mask debug view was added to the viewport rendering debug menu. The reactive input is no longer fed to DLSS, matching its current model requirements.
Improved Landscape Layer Map brush performance in large and heavily loaded worlds.
Fixed a thin light outline (contour artifact) along object silhouettes produced by the indirect lighting denoiser: temporal accumulation is now reduced on geometry edges detected in the normal buffer (render_denoise_antialiasing_fix_by_edge_detection_enabled, on by default, with a configurable threshold).
Fixed SSSSS rendering artifacts that caused visible boundaries on meshes depending on the camera position or rotation.
Fixed subsurface scattering sampling its per-surface bit at wrong coordinates when rendering at non-full resolution, which could apply scattering to wrong pixels and cause edge artifacts.
The lightmap surface feature bit is no longer set when lightmaps are disabled, preventing incorrect shading paths and unnecessary surface state splits.
Asynchronous GPU-to-CPU transfers (asyncTransferTextureToImage(), asyncTransferStructuredBuffer()) now run at a higher priority, reducing readback latency under load.
Fixed local tonemapper artifacts: a half-block offset in luminance downsampling and darkening near screen borders in the blur pass.
Fixed incorrect Surface ID output for mesh_base materials with tessellation enabled, which broke Surface-ID-based features and debug views on tessellated meshes; obsolete vertex-stage Surface ID checks were also removed from the abstract mesh material accordingly.
Animation scripts: the C++ reference library is now rebuilt when .cppscript files change (previously only when the engine was updated), resolves against the actually loaded engine module, refuses to load a library built for a different engine version, and logs a clear warning in shipped builds where rebuilding is not possible.
Auto exposure: the ramp curve range was narrowed to realistic frame-average luminance values, and the default ramp curve was updated accordingly (existing worlds keep their saved curves).
Soft shadows: the screen-space penumbra cap is now exposed as render_shadows_penumbra_max_radius_screen (API, settings, presets), bounding penumbra spread in screen space so close-up penumbras no longer dissolve into blobs. The per-light-type caps became built-in constants; the render_shadows_penumbra_max_radius_world / _omni / _proj console variables were removed (handled automatically by the migration).
Fixed 2.22 content migration: the render settings section of upgraded projects is now processed correctly — obsolete settings are removed and settings introduced in 2.22 are added with their proper default values (previously the section was left untouched). Also fixed bundled plugin components (Gaussian Splatting, MediaPlayer video source, RTSPStreamer, ScenarioManager) not being recognized as component classes by the Sequencer and Sequence Player.
Fixed migration of Material Mask values: masks authored before 2.22 could carry the upper 8 bits implicitly set (these bits were reserved and ignored in mask comparisons back then) — with the switch to full 32-bit masks in 2.22 they started affecting the comparison results. Migration now clears such stale bits, preserving the pre-upgrade masking behavior.
Fixed a deadlock in SoundManager that could occur when loading a world if sound sources were assigned to NodeReferences loaded in multithreaded mode, which is enabled by default.
Fixed a NUM_OBSTACLES enum typo in C++ / C# API.

Editor

Fixed the Cleaner deleting cluster files (.cluster) that were still in use on Refresh, which could cause loss of ObjectMeshCluster data; the Cleaner now also honors the ignore list and correctly resolves cluster data locations for worlds saved in the current session.
NodeSkeletonPose panel: edits to the controlled objects list are now undoable and mark the world as modified; the panel refreshes when the list is changed elsewhere (undo/redo, node deletion); assigning an object already used in another slot is handled correctly.
The Editor no longer re-imports all material and animation graph runtimes on every start when the project contains read-only graphs (e.g., graphs inside read-only packages); an outdated read-only graph now produces a single warning instead.
Fixed a crash after reloading a world while spline edit mode was enabled.
Fixed key dragging on logarithmic axes in the curve editor: keys near zero no longer become ungrabbable, and tangents are correctly preserved when moving keys.
The Tracker tool is now marked as deprecated in the Tools menu — use the Sequencer instead.

Sandworm

Fixed silent failures when saving mask data: empty masks are now saved and loaded back correctly instead of producing no file, and save errors are reported in the log.
Fixed several crashes, including on loading broken or incompatible project files and on processing sources with empty or invalid tile data.

September 13

С какой версии движка ScenarioManager доступен? SIM?

September 14

SaviorRUS

Это Sim / Academic, да. Скоро подправим описание.

October 5

Еще, после загрузки Toolkit Add-On в проект, на версии движка 2.22, редактор UI, 3D моделинг больше не появляются. Сами примеры работают без проблем, но отредактировать или создать свои экраны не представляется возможным. Это баг или от этого инструмента решили отказаться?

October 5

SaviorRUS

Автор не обновил свой плагин до 2.22, поэтому он и не работает. Работа рантайма наоборот является здесь аномалией 🙂

October 6

On 10/5/2026 at 10:42 AM, silent said:

SaviorRUS

Автор не обновил свой плагин до 2.22, поэтому он и не работает. Работа рантайма наоборот является здесь аномалией 🙂

Так это же вроде разработанный Unigine плагин 🤔

Edited October 6 by SaviorRUS

October 7

На стор может кто угодно свои ассеты заливать. Там и правда есть официальные аддоны от UNIGINE, но не этот, к сожалению.

UNIGINE 2.22 - New Sequencer, DRS, Cesium Integration, Better Sensors

Recommended Posts

fox

Key Changes

UNIGINE-Powered AA Game - Announced

Animation Updates

Sequencer Tool

Channels, Keys and Curves

Targets - Binding by Rules

Cinematic Channels and the Animation System

Subsequences

Faster Where It Counts, Open Where Tracker Was Closed

Conversion of Tracks from Legacy Tracker

Asynchronous Animation Streaming

Animation Graph - More Advanced Features

Procedural Skeletal Control

New Modes for Blend Poses

Preview Workflow

Other Animation Graph Improvements

Navigation & Pathfinding Reworked (Experimental)

Navigation Mesh Baked from Your Scene

New Navigation Nodes

Cost-Weighted Areas: Mud, Roads, and No-Go Zones

Squads, Crowds, and Moving Targets

Ready to Explore

Improved Gaussian Splatting Support

Gaussian Splat Collider Generation

Gaussian Splat Demo

Global-Scale Geodata via Cesium Integration

Streaming the World with Cesium 3D Tiles

Accurate Georeferencing at Any Scale

Blend Global Data with Local Content

Built for Geospatial Applications

Surface ID Buffers

Sensors Updates

LiDAR Sensor Advanced

Introducing RADAR Sensor

Kannala-Brandt Fisheye Model

A Fisheye Pipeline That Goes Cinematic

See It in Action: the Fisheye Camera Emulation Sample

New Segmentation Samples

Rendering Improvements

Dynamic Resolution Scaling

Render Resolution API

Reactive Mask Generation for Upscalers

Enhanced Shadow System

New World Light Cascade Mode

Custom Render Parameters

Water Rendering Improvements

Local Contrast Improvements

Light Roughness Offset

Other Rendering Improvements

Physics Updates

Continuous Collision Detection Improvements

Improved Wheel Friction at Low Speed

Other Physics Improvements

Performance Optimizations

Faster Clutter Intersection Checks

GPU Optimizations

Optimized Cloud Rendering

Optimized MeshDynamic Memory Usage on Vulkan

Optimized Billboards and Particles

Shader Cache Generation Improvements

VR/XR Improvements

VR Profiler and Debugging Improvements

Extended Localization Support

NoesisUI Integration

Other Engine Improvements

Project Templates

ArduPilot SITL Integration

VR Multiplayer Template

C# (WPF) Empty Template

AI Workflow Improvements

Editor Integration

Connecting an Agent

Machine Learning Agents Demo

Plugins

RTSPStreamer Plugin

WebStream Plugin

ScenarioManager Plugin