UNIGINE 2.21: New Animation System, AI-Friendly Workflow, Project Templates, Performance Optimizations

[fox]

Key Changes

• Introduced a new animation system with a visual logic editor
• Improved AI-friendly workflows for better integration with AI tools
• Added new aviation-focused project templates (fixed-wing and rotary simulators, VR MRO, UAV simulation)
• Delivered broad performance optimizations across CPU, GPU, RAM, VRAM, and loading times
• Implemented clustered rendering for advanced lighting scenarios
• Enhanced renderer with multiple visual improvements
• Python/C++/C# DataBridge system
• Updated ROS 2 integration (Jazzy Jalisco support, expanded sensor coverage)
• Improved Editor usability with multiple quality-of-life updates
• Added new plugins (video-to-texture playback, PDF viewer, SQL database connector)
• Introduced new SDK editions: Entertainment and Academic Research

 

New Animation System With Visual Editor

UNIGINE 2.21 introduces a fully redesigned animation system centered around a new visual, node-based workflow. It replaces code-driven animation logic with a unified toolset for building, previewing, and executing complex character behaviors.

 

Visual Animation Logic Editor

A new Animation Graph Editor enables artists and developers to build animation logic visually. Instead of scripting transitions and blends, you connect nodes in a graph to define behavior - from simple clip playback to multi-layered locomotion systems.

• Real-time 3D preview with camera controls, skeleton visualization, and scrubbing
• Typed node connections with immediate visual feedback
• Automatic compilation into optimized native C++ code with hot reload

 

State Machines

A character has distinct behavioral states - Idle, Walk, Run, Jump - and needs clean transitions between them. State machines let you define these states and the conditions to switch between them. Each state contains its own nested animation graph. Transitions blend smoothly and support interruption: if a Jump command arrives mid-transition from Walk to Run, the current pose is captured as a snapshot and a new blend begins - no snapping, no pops.

 

Blend Spaces

Locomotion rarely maps to a single clip - a character's movement depends on speed, direction, and their combination. Blend Spaces let you place animation samples on a 2D grid (e.g. speed x direction) and interpolate between them continuously. The Sync variant keeps cyclic animations like walk and run in phase across all blend weights, so footsteps don't drift.

 

Subgraphs - Modularity and Reuse

When multiple characters share the same animation logic - an upper-body layer, a weapon swing setup - duplicating it across graphs becomes a maintenance problem. Subgraphs let you extract common logic into a reusable asset (*.asubgraph) with defined inputs and outputs. Reference it from any number of graphs; changes propagate to all of them automatically.

 

Blend Masks - Per-Joint Blending

Sometimes you need different animations on different parts of the body at the same time - shooting with the upper body while the legs keep running. Blend Masks give you per-joint control over which joints participate in a blend, with influence values from 0.0 to 1.0 for smooth falloff between zones.

 

Animation Synchronization

Blending animations of different durations causes cyclic events - like foot contacts - to drift out of phase. The result is visible foot sliding. Sync Groups solve this: nodes assigned to the same group share a single timeline. Normalized Time works when animations have matching phases; Marker Sync aligns specific key events even when they don't.

 

 

 

Root Motion

When character movement is driven purely by code (as it was before 2.21), animators lose control over the exact distance and timing of steps, attacks, and dodges. Root Motion gives that control back: the system extracts the root bone's displacement and rotation each frame, removes them from the skeleton pose, and exposes the result as a per-frame delta via API. When multiple animations are blended, root motion is interpolated with the same weights as the poses.

 

Retargeting

Creating separate animations for every character doesn't scale. Retargeting lets you author one animation set and apply it across characters of different builds - a tall soldier and a short scout share the same walk cycle, and the system adjusts bone movement to match each skeleton's proportions. Root motion scales accordingly: a shorter character covers less ground per step without any manual tweaking.

 

Native Compilation and Hot Reload

A visual graph is convenient to edit, but interpretation at runtime means a performance cost. Animation Graph avoids this entirely: on save, the graph is translated into C++ source code, compiled into a native dynamic library, and loaded via hot reload. You see changes instantly without restarting the project, and every frame runs compiled machine code - no interpretation overhead.

 

QoL Features

Everything you are used to in Material Graphs is available in Animation Graphs as well - and there is even more.

Interactive node activity visualization - shows which nodes are being executed directly in the graph view.
Portals - the equivalent of variables in code, helping reduce visual spaghetti and keep graphs cleaner.
Collapsible nodes - some nodes can be minimized when you only need a compact representation, saving space in the graph.
Expressions and swizzles - a convenient way to work with vectors and simple math operations.
Inline node widgets - let you view node values at a glance and edit them directly on the node.
Interactive tooltips - essentially a fully interactive mini graph area that shows the subgraph built inside the node.

 

Summary

Animation Graph provides a complete animation control pipeline: from asset preparation and visual logic authoring to native-code runtime execution. State machines, blend spaces, synchronization, root motion, retargeting, per-joint blending - all in a single tool, with no need to write animation code by hand.

An updated set of animation samples demonstrating animation graphs is available in the C++ Samples pack (some of the samples were added to the C# Component Samples pack as well).

More updates are on the way as we keep refining and extending the system, the following things are to be expected:

• Procedural constraints (Look At, IK, etc.) to enable more dynamic character behavior
• An improved retargeting interface for a smoother workflow
• Support for animation curves and events
• The ability to transform bones directly inside the node graph
• A wide range of quality-of-life improvements across the tool

To learn more about animation graphs and the new system please refer to the dedicated section of the documentation.

 

Revised File Formats

We've overhauled the animation system to improve clarity, flexibility, and reuse. Key changes include a clear distinction between joints and bones, new decomposed transform structures, and updated mesh formats: .mesh no longer contains bone or morph-target data, which is now handled in the new MeshSkinned and .mesh_skinned file format.

Animations are now stored in MeshSkinnedAnimation with FPS and duration info, supporting shared skeletons for easy animation reuse across meshes. The new Skeleton object manages joints, hierarchy, bind poses, mixing masks, and retargeting by hierarchy, joint names, or bone proportions.

 

Backward Compatibility

Legacy support is maintained via ObjectMeshSkinnedLegacy, which keeps old behavior completely, while new objects ObjectMeshSkinned and NodeSkeletonPose enable advanced animation playback and vertex skinning. Additional pose objects allow flexible pose blending, visualization, and space conversions. Overall, the system simplifies workflow, supports robust retargeting, and separates animation logic from mesh data for better modularity.

 

AI-Friendly Workflow

AI agents become an increasingly common part of 3D development workflows, and many developers are integrating AI-assisted tools directly into their work. To help AI agents better understand UNIGINE and prevent confusion with its API - such as inventing non-existent methods or carrying over assumptions from other tools - we have introduced solutions to bridge the gap.

 

Reference Documentation For AI Agents

A version of UNIGINE documentation optimized for AI agents (AI Docs). Full C++ and C# API reference, working code samples by topic, and a set of guidelines that encourage agents to rely on documentation instead of making assumptions. Just drop it into your project and the agent picks it up automatically.

Also available on GitHub.

 

AI-Assisted Coding

Here is a quick step-by-step guide to help you get up and running with AI-assisted development in UNIGINE:

1. Add AI Docs to Your Project
Add AI Docs when creating a project, or later via the Project Configuration window.

 

 

2. Set Up Your AI Environment
You can use an AI-powered IDE such as VS Code.

Using VS Code + Claude:

• Open Extensions in VS Code
• Search for Claude Code extension from Anthropic. (or a compatible Claude extension)
• Install the extension
• Sign in to your Anthropic account or provide an API key

You can also use alternatives like Cursor, Codex, or GitHub Copilot or a CLI agent, if you prefer.

3. Open the Project in an AI-powered IDE or connect a CLI agent to the project folder.
Once the project is opened, your AI assistant (Claude, Cursor, Copilot, etc.) will automatically detect the AI Docs and use them as context.

 

4. Generate Your First Component
Ask your assistant, for example: "Write a C# component that rotates an object around the Y axis at a configurable speed."

5. Apply and Test
Wait for the assistant to generate the code, then follow its instructions to add and test the component in your project.

To learn more, please refer to this article.

 

MCPBridge Editor Plugin (Experimental)

An experimental editor plugin that allows AI agents to interact with the UNIGINE Editor in real-time via MCP. The plugin runs a built-in server directly inside the Editor - no external scripts or proxies required.

It comes with 27 tools covering essential workflows: create primitives and nodes from templates or project assets, transform, clone, rename, or reparent nodes, manage materials and surface masks, attach and configure components, inspect and modify nodes, and execute console commands. Batch operations are supported with full undo/redo.

MCPBridge is especially useful for learning the engine and rapid prototyping. For production projects, use with caution.

Available on the Add-On Store.

You can use MCPBridge together with AI Docs - the agent gains Engine knowledge from AI Docs and hands-on Editor control through MCPBridge.

 

Project Templates

Refined Workflow

In this release we have added new project templates that serve as ready-made foundations for creating new projects across different application areas. These templates are not just empty starting points - they include preconfigured content, logic components, plugins, and, in some cases, their own dedicated APIs. This approach allows teams to move much faster from idea to a working prototype, while still keeping full control over customization. The project creation workflow now requires selecting a base template.

Each template comes with a set of modular components that implement common domain-specific systems such as weather simulation, traffic simulation, radars and sensors, displays and projections, multi-node rendering synchronization, etc. These systems are designed to work together out of the box, reducing integration effort and helping teams focus on their actual application logic rather than low-level setup.

Looking ahead, we plan to significantly extend the set of available templates in future releases. Upcoming templates will target a broader range of applications, including ground transport, marine operations, space missions, and more, further reinforcing the engine's role as a flexible platform for simulation, training, and visualization projects.

 

Aviation Pack

As a first step, we have released a pack of aviation-focused project templates, including:

• Fixed-Wing Flight Simulator - configurable flight scene with a fixed-wing aircraft. Supports full flight cycle (takeoff to landing), multiple control devices, camera modes, HUD, avionics, environmental interactions, audio, sensor simulation, and airfield infrastructure. Demonstrates IG capabilities, aircraft customization, and optional VR/XR rendering.
• Rotary-Wing Flight Simulator - configurable helicopter simulation supporting full operation cycle, control devices, camera modes, HUD, rotor and engine behavior, environmental interaction, collision handling, equipped helipads, configurable weather/time, IG capabilities, aircraft customization, optional VR/XR rendering, and guided operations.
• UAV Flight Simulator - drone simulator supporting multiple types (FPV quadcopters, VTOL, fixed-wing). Features simplified flight dynamics, wind interaction, multiple control options, flexible camera modes, instruments, sensor simulation, environmental interaction, configurable weather/time, engine sounds, and desktop/VR/XR support.
• MRO Simulator - hands-on maintenance, repair, and operations (MRO) training simulator. Provides first-person interaction with technical procedures, failure simulation, performance recording, built-in training logic, and tooltip guidance. Optimized for VR, with PC controls for development/debugging.

These templates cover a wide range of aviation use cases, from flight simulation to training and maintenance scenarios, and can be used both as learning examples and as production-ready starting points. The MRO Simulator template is not limited to aviation and can be adapted for various VR maintenance training applications.

Available only in Sim and Academic Research (partially) SDK editions.

 

Generic Templates

Both C++ and C# VR Templates have been significantly improved. Their internal structure has been cleaned up and reorganized, making it easier to understand, use, and extend. We also expanded its functionality and usability by adding an extended library of VR interactions, including pistols, ropes and wires, rotating valves, and many other commonly used interaction patterns. This makes it much easier to build rich and believable VR experiences without having to implement every interaction from scratch.

 

Engine Plugin Template

The Engine's plugin system allows you to extend core functionality with your own modules, and now you can create them directly from a ready-to-use template in the SDK Browser in just a couple of clicks.

 

A blank plugin project and a basic implementation will be added to your workspace automatically, providing a solid starting point for your custom plugin development.

To start with plugin creation, check out the updated article: Creating a C++ Plugin.

 

Rendering Improvements

Enhanced Upscalers

Custom Resolution Scaling

FSR now supports a separate Custom mode that allows you to set your own scaling value relative to the target resolution. For example, a scale value of 0.5 for 3840x2160 output will render at 1920x1080.

The Custom mode can be enabled via Settings -> Render -> Upscalers -> FSR, or via console: render_upscale_fsr_mode 5
render_upscale_fsr_custom_resolution_scale (range 0 - 1)

DLSS scaling values are now also configurable for all quality modes via Settings -> Render -> Upscalers -> DLSS, or via console:
render_upscale_dlss_resolution_scale_enabled 0/1
render_upscale_dlss_resolution_scale_value (range 0 - 1)

 

Native AA Preset for FSR3

FSR now also includes the Native AA quality mode. Unlike other FSR presets, Native AA applies anti-aliasing without any upscaling - your scene renders at full native resolution.

Upscaling Information in Performance Profiler

Previously, when using DLSS or FSR, there was no easy way to check what resolution your scene is actually rendering at. Now, upscaling information is displayed in the Generic Profiler:

• Resolution - display resolution used for presenting the final rendered image
• Render Resolution - internal resolution at which the scene is rendered before upscaling is applied
• Upscaler - current upscaling method in use (FSR or DLSS), including the active mode, preset, and custom scale if specified.

Additionally, the VRAM Usage Upscaler metric shows memory consumption by the active upscaler, helping you keep VRAM usage under control.

General Upscaling Improvements

• Fixed residual trailing artifacts when objects quickly disappeared (FSR).
• Eliminated noise issues occurring with FSR.
• Resolved bright edge artifacts when using Bloom combined with FSR (Performance) / DLSS (Max Performance) + Denoiser during camera movement.
• Fixed issues related to post-processing upscaling and color management when using FSR with Upscale Sequence Order set to After Post Effects:
  • Correct exposure handling and proper sRGB conversion are now enforced.
  • Resolved image degradation issues, including banding and precision loss.

 

Tonemapping Improvements

The ACES tonemapper now applies its curve transformation directly within its native color space. This improves color accuracy and consistency, particularly in HDR scenarios, resulting in more predictable and physically plausible output that better aligns with modern rendering workflows.

ACES Tonemapper

Filmic Tonemapper

 

Improved Gaussian Splatting Support

This update brings several enhancements to Gaussian Splatting, focused on rendering flexibility, visual quality, better integration into the pipeline, and giving artists and developers more control over splat behavior and look.

Key updates include:

• Render Sequence Order - control when splats are rendered, including the option to render them after post-processing effects for better compositing.
• Filtering Enhancements - experimental 2D mip-filtering blurs splats more naturally based on screen size, with adjustable scale, while adaptive 3D smoothing scales splats based on camera parameters to preserve detail for small objects like grass or wires.
• Low-Pass Filter Strength - basic Gaussian smoothing control for cases when 2D mip filtering is disabled.
• Splat Adjustment Controls - fine-tune color, tint, temperature, saturation, brightness, and black/white points to match artistic intent and achieve consistent visual results across different scenes.

These improvements based on client feedback and recent research provide more precise control over how splats appear in the scene, helping to match reference pipelines, reduce visual discrepancies, and enhance overall rendering quality.

 

Clustered Rendering

We've implemented clustered rendering for World, Omni, and Projected light sources to improve lighting performance in complex scenes. Lights are organized into screen-space clusters, allowing the renderer to efficiently process large numbers of dynamic lights.

This approach significantly reduces lighting costs in scenes with high light density and helps maintain stable performance across a wide range of use cases, including large environments and VR applications (VR performance optimizations are to be expected in upcoming releases). A number of issues with lighting on transparent objects were resolved as well. This improvement is especially beneficial for night scenes with a large number of light sources and transparent objects.

Clustered rendering has also been implemented for Environment, Voxel, and Planar Reflection Probes. This update improves performance when using the Multiple Environment Probes option for the material and adds support for blending modes across all probe types. Additionally, Planar Reflection Probes now blend correctly on transparent materials.

The test scene includes 204 light sources in total (112 Omni, 50 Proj, and 12 Voxel Probes). Forward Per Object Limits were set to 6 Omni and 6 Proj lights, with a rendering resolution of 1920 x 1080.

Rendering Cost Reduction:

• Total GPU time: ~21% reduction
• Total frame time: ~21% reduction

 

Bindless Textures

We've added support for bindless textures, removing the traditional limitation of 16 textures per material. Shaders can now access a much larger number of textures dynamically, which simplifies material setups and enables more complex surface definitions without relying on texture atlases or additional draw calls.

This improves scalability in texture-heavy scenes, reduces material complexity, and provides a more flexible foundation for future optimizations and advanced rendering techniques, for example, Clustered Rendering.

 

Async Shader Compilation for Clouds

We've added asynchronous shader compilation for cloud materials, significantly reducing frame spikes and freezes when different cloud layer combinations appear in a scene (dynamic weather scenarios), especially when there are no pre-generated shader cache files.

This update eliminates the initial performance spike when clouds are first introduced, fixes an issue with the ObjectCloud::preRender step that could take up to 50 ms after adding a cloud layer, and resolves interleaved rendering artifacts caused by synchronous shader compilation.

Async mode is enabled by default, but you can control this option via the render_clouds_shaders_compile_mode console command.

 

Temporal Anti-Aliasing (TAA) Improvements

• Fixed Information lost issue that caused artifacts around object edges and bright spots trailing behind moving objects (Information Lost refers to rendering of the surfaces that weren't rendered in the previous frame).
• Improved velocity handling algorithm, reducing sharp banding artifacts during fast camera movement.
• Optimized performance by reducing the number of texture samples.

 

Water Improvements

This update delivers a broad set of enhancements to water rendering, improving visual quality, physical consistency, and stability across a wide range of conditions.

 

Screen Space Reflections (SSR)
SSR has been refined to produce more natural results, reducing artifacts and eliminating reflections that should not appear at certain viewing angles.

 

Wake Wave Simulation
Wake behavior has been improved for high Beaufort scale conditions. The wake decal now remains stable in rough seas and no longer disappears due to vessel tilt, ensuring consistent rendering across large waves.

 

Foam Rendering (TAA)
Foam appearance has been enhanced when using TAA. It now looks sharper and more detailed at high wave intensities, avoiding the excessive blur seen previously.

UNIGINE 2.20

 

UNIGINE 2.21

 

Stability for Different Camera Setups
Fixed issues with water geometry disappearing or flickering under extreme camera setups (e.g., very narrow FOV and long view distances), ensuring stable rendering in such scenarios.

 

Environment Haze Interaction
Environment Haze now correctly affects water in all rendering modes, not just Physically Based Scattering.

UNIGINE 2.20

UNIGINE 2.21

 

Waterline Artifacts
Resolved distortion artifacts at the waterline when using Field Spacer, resulting in cleaner transitions between water and geometry.

Other Rendering Improvements

• Fixed an issue where a changed material state was incorrectly reset in the next frame when the change occurred at the end of the frame.

 

Performance Optimizations

The engine has undergone a series of optimizations aimed at enhancing overall performance and visual quality.

 

CPU Optimizations

Optimized D3D12 Frame Memory Pool

Allocations now use a thread-local chunk allocation scheme, reducing the number of atomic increments and improving throughput. Average per-frame CPU processing time is reduced by 0.1 - 0.2 ms.

More Multithreaded Renderer (CPU part)

Implemented Multithreaded Rendering for the following passes: Decals, Transparent Blur, Transparent G-Buffer.

Physics

Physics Flush Optimizations boosting flush execution due to improved multithreading.

 

GPU Optimizations

Sharpen Post-Effect Optimization

The Sharpen post-effect has been optimized for better performance. Processing time reduced from 0.5 ms to 0.35 ms, providing approximately 30% improvement. This contributes to lower per-frame overhead in scenes with post-processing enabled.

 

Half/Quarter Resolution for Environment Haze

Environment Haze now supports configurable rendering resolution for improved performance control. Three modes are available:

• Quarter (1/16 screen)
• Half (1/8 screen)
• Full (1/4 screen)

Quarter mode delivers nearly 4 times faster haze rendering compared to Full, with minimal visual quality loss in most scenarios. The new setting is available via Settings - Environment - Haze - Resolution or the render_environment_haze_resolution console command.

 

Mip Map Batching for Common Data

Mip map generation for common data buffers is now limited to 3 mip levels instead of the full chain. This reduces computational overhead, resulting in 1.3x faster average performance and up to 1.8x improvement in peak cases.

 

Material Graph Post-Effects Optimization

Eliminated redundant texture copying that previously occurred after each custom post-process material created in Material Graph. This removes unnecessary memory bandwidth usage and reduces overall post-processing cost.

Improved PSO compilation significantly reducing spikes.

 

Memory Usage Optimizations

This release includes multiple improvements focused on reducing RAM usage and eliminating memory leaks, resulting in more stable performance and lower memory consumption across projects.

 

Reusing Object Surfaces

Data for objects surfaces with similar parameters is now reused, significantly reducing memory consumption when many objects share the same material, properties, shadow masks, viewport masks, etc. In our large-scale internal project under development, this optimization reduced memory consumption by ~200 MB without any negative impact on performance.

Modifying surface parameters after loading will disable reuse.

 

More Efficient Cleanup

Previously, many resources were not cleared within the same frame, which could cause issues during low-memory situations or when changing graphics settings. Now, VRAM cleanup has become more aggressive, and all unused resources are deleted immediately, resulting in more stable performance, lower peak memory usage, and less chances to get into shared memory.

 

Vulkan Optimizations

We have improved Vulkan CPU-side performance by optimizing shader data binding, as well as shader and parameter handling. Additionally, we reduced the size of GPU command buffers on Vulkan, lowering command processing overhead and further improving overall CPU efficiency.

Performance measurements were conducted using the Fox Hole test scene with a standard camera setup, High preset, and render_supersampling set to 0.3 on a system equipped with an i5-4690K CPU and an RTX 2070 SUPER (8 GB) indicating noticeable performance gains on medium to low-end hardware, while higher-end configurations (such as an i9-14900K paired with an AMD RX 9070 XT) did not show a significant uplift.

 

Faster Engine Initialization

We have optimized Engine initialization, resulting in faster startup times. The following improvements were measured on a real production large-scale project with huge scenes containing thousands of objects:

• Runtime initialization (without UNG archives): up to 62% faster on cold start, and 11% faster on hot start
• Runtime initialization (with data packed into a UNG archive): up to 26.7% faster on cold start, with no change on hot start
• Editor startup: up to 24.8% faster on cold start, and 9% faster on hot start

These improvements reduce iteration times during development and make working with large and complex projects noticeably more responsive, both in the Editor and at runtime.

 

Faster World Loading

Optimized Collision Shapes Loading

We've optimized the loading of collision shapes for physics bodies, significantly reducing world load times when many shapes are present. On average, this results in around 40% faster loading in both the Editor and at runtime on PC, improving workflow and runtime performance for complex scenes.

 

Improved Loading of Complex Meshes

We've improved mesh initialization, resulting in faster loading of worlds that contain complex meshes with a large number of surfaces. In some cases, this optimization provides up to 20% faster loading in the Editor and up to 3.5% faster loading at runtime, improving iteration speed and overall performance for large scenes.

 

Thread System Update

The Engine's multithreading has been updated with a pool-based architecture, priority-driven scheduling, and a public API for running custom parallel jobs.

These Thread System improvements reduced typical CPU frame time by 12.5%, cut peak spikes by 29%, and improved the slowest frames by 28% - freeing up roughly 10 - 15% of total CPU headroom.

Measured on i5-4670, GTX 1660, 16 GB RAM in a large-scale production project.

 

Dedicated Thread Pools

Previously, all parallel work shared the same resources. A heavy asset loading burst could choke physics, or a procedural generation task could stall rendering mid-frame. The new system eliminates this by splitting work across 8 specialized pools, each with its own threads, priority, and purpose. Frame-critical calculations, background operations, disk I/O, and GPU transfers now run in complete isolation - no pool can starve another.

 

Smart Job Scheduling

Every pool knows the difference between work that must finish this frame and work that can take its time. Combined with priority levels, the Engine always picks up the most important jobs first, no manual tuning required.

 

Custom Jobs API

Developers can submit their own work to Engine thread pools using two job types: CPUShader distributes work across multiple threads in parallel, CPUTask runs a single task on a chosen pool. Both support pool selection, priority, and frame synchronization.

• Template helpers let you spin up a parallel job with a single function call.
• Subclassing gives full control: completion callbacks, lifecycle management, and cooperative scheduling.

C# and UnigineScript developers get access to the same system through the AsyncQueue class.

All Engine threads are visible in the built-in Microprofiler with clear names, so no job goes unnoticed during performance analysis.

For a full reference, see the Thread System documentation.

 

Enhanced Performance Profiling

Profiler Dump Tool

We've added support for the Profiler Dump workflow, a new tool that lets you capture and export detailed profiling data from your application. The profiler dump records performance statistics and engine configuration from a profiling session, which can then be converted into a readable text format using the Profiler Reader tool for deeper analysis.

This enhancement makes it easier to analyze performance bottlenecks offline, share profiling results with team members, and integrate profiling data into external workflows or tools. The profiler dump complements existing runtime profiling (e.g., Performance Profiler and Microprofile) by providing a persistent snapshot that can be examined outside of the live application.

 

Other Profiling Improvements

• We've fixed a number of issues with Microprofile, and all metrics and timers are now displayed correctly without the need to manually increase counter limits. Previously, some metrics could be lost or only appear after adjusting limits, which was not intended. Now, all functions and timing data are reliably captured and visualized.
• Material and pass names are now displayed in the Microprofile tool.

 

UI Improvements

We've improved the UI system with better word-wrap logic for Chinese, Japanese, and Korean text, ensuring proper line breaks in CJK languages. Additionally, fallback font support has been added, allowing the UI to display characters that are missing from the main font without issues.

 

Other Engine Improvements

• A new material replacement mechanism has been added to the rendering pipeline, allowing you to dynamically replace materials per object surface at render time. This provides greater flexibility for advanced workflows such as custom rendering passes, debugging, or visual effects - all without modifying original scene materials.
• Added persistent hardware universal unique identifier (UUID) for each GPU (available via the new argument -video_adapter_uuid), providing a unique identifier that remains consistent across reboots and hardware configuration changes; this allows reliable GPU selection for rendering (overriding -video_adapter), ensures stable multi-GPU setups, and enables accurate mapping of outputs in external tools using DXGI or Vulkan device enumeration.
• Fixed an issue where light baking in Voxel Probes did not work with materials using the Transparency Preset: Alpha Blend.
• Fixed an issue where collision shape visualization was only visible when objects were near the edges of the screen.
• Fixed an issue where shapes stopped rendering if the object they were added to was outside the camera view, even when the shapes themselves were visible in the viewport.
• Fixed arrow size to use relative units again instead of absolute values, restoring proper Visualizer arrow scaling.
• Fixed a crash on application exit when an input device (e.g. a steering wheel) with Force Feedback support was connected.
• Fixed an issue where material states reset in the next frame if changed at the end of the current frame.
• Fixed multiple issues with reloading the File System (filesystem_reload), making it stable in both the Editor and runtime, preventing state corruption and related crashes.

 

UnigineEditor

QT6 Support

The Editor and tools have been upgraded to support Qt 6.5.3 ensuring compatibility with more advanced and up-to-date Qt features and improving overall stability and performance. This update also resolves several issues, including HiDPI-related problems, ensuring a smoother and more reliable experience across high-resolution displays.

 

Better Search in Parameters

Improved search algorithms in the Parameters window to cut out irrelevant results.

 

Vertex Snapping

We've added vertex snapping to make precise object placement easier. This tool lets you align objects so specific vertices meet exactly, eliminating gaps or overlaps - ideal for assembling modular assets like pipes, building segments, walls, interiors, and power lines.

Snapping can be constrained along one or two axes, and X-Ray Snapping allows alignment with hidden vertices. The Distance parameter limits which vertices can be snapped to, preventing accidental alignment with distant geometry.

 

Converting Landscape Terrain to Geometry

For certain cases, converting a landscape to geometry can be more practical than using ObjectLandscapeTerrain. Exporting a simplified mesh can sometimes improve performance, enable shadows, support caves or tunnels, etc.

The Landscape Exporter captures terrain height and albedo, producing .mesh or .fbx files. Keep exports small (ideally <=1 km²) to avoid precision errors and high memory usage. Large or high-poly terrains can become heavy and inaccurate.

While ObjectLandscapeTerrain remains more efficient for simulation thanks to adaptive tessellation and streaming, static geometry is ideal for static backgrounds, offline rendering, or features unsupported by the terrain system, such as tunnels, overhangs, and shadow casting.

 

New Asset Dependency Analyzer

Asset dependencies are very hard to track manually in large projects with huge scenes, and a lot of dependency types might become necessary when populating 3D scenes. You can now find assets that are used only in a particular world. This feature can be useful, when you need, for example, to split content between scenes, or in other cases. To find such unique assets simply right-click the desired world file in the Asset Browser and choose Show Assets Used Only In This World from the context menu. You can also select worlds to be included in dependency search.

 

Paint Tool Improvements

We've improved the robustness of the Paint Tool to prevent GPU hangs that could previously occur during texture baking when working with complex UV layouts.

Surfaces with excessive UV overlaps are now automatically detected, and painting is safely disabled with a clear error message.

For best results, use clean UV layouts with minimal overlaps. You can either prepare them manually or generate a secondary UV channel during import and use it for painting.

 

Support for Archives

The Editor now supports working with archives (currently .ung and .zip). Assets and files inside these archives can be browsed and used in your projects but remain read-only, preventing accidental modification. Archives must contain both assets and runtimes for correct operation.

This feature enables easy reuse of content packs between projects. Archives are displayed in the Asset Browser and can be imported via drag & drop or the Editor's import menu.

 

Package Import Improvements

We've enhanced package import to better handle duplicate asset and file GUIDs. When conflicts occur, the importer now highlights duplicates, shows their paths, and provides options to resolve them:

• Asset duplicates: Keep Existing | Import New (Preserve Path) | Import New (Use New Path)
• File duplicates: Keep Existing | Replace With New

If replacement is chosen, the old asset (including runtimes and metadata) is fully removed and replaced with the new one.

This system provides more control and safety when importing packages, avoiding accidental overwrites and import failures while allowing smooth updates of assets and projects.

 

Better Helpers

Visualizer can now be enabled for invisible surfaces (the ones hidden in the viewport when the camera and surface use different viewport masks) - simply check Show Visualizer On Invisible Surfaces on the Helpers panel.

A pack of new visualizers has been added for this release.

 

Quad Overdraw Visualizer

Excessive overdraw occurs when the same screen pixels are shaded multiple times due to transparency, small triangles, or multi-pass materials, leading to wasted GPU cycles and reduced performance.

The new Quad Overdraw visualizer highlights these shading hotspots directly in the viewport, helping identify problematic assets, materials, and scene elements. Different visualization modes make it easier to analyze overdraw caused by transparency, overshading, or multi-pass rendering and optimize scenes more effectively.

 

Vertex Density Visualizer

High vertex counts don't automatically improve visual quality and often hurt performance by increasing GPU load and memory usage. To help identify these issues, we added a Vertex Density visualizer that displays a heatmap of vertex concentration directly in the viewport.

This tool makes it easy to spot over-tessellated areas, inefficient LODs, and unnecessary geometry, helping teams optimize meshes and maintain balanced topology for better performance.

 

The list of other new visualizers includes:

• Proj and Omni Shadow Casters
• Transparent GBuffer
• Transparent Lighting
• All wireframe modes are now available in the Helpers menu
• Title for current rendering mode

 

Other UnigineEditor Improvements

• Clicking an asset, node (in World Nodes), property (in Properties), material (in Materials), or the "Go to Asset" button with Alt+LMB now opens a new Parameters window with the lock enabled.
• [Windows] Fixed an issue where the cursor jumped to X=0 when rotating the camera with RMB on a non-primary monitor with DPI scale >= 150%, which blocked camera rotation and the Create menu. The Orientation Cube now works correctly on high-DPI non-primary monitors as well.
• Cloning (Ctrl + D) and renaming (F2) items in the Asset Browser hierarchy now works as expected.
• Fixed an issue where saving a Node Layer while editing a Node Reference caused the unpacked Node Reference contents to be saved to the layer instead of being packed and saved as expected.
• Fixed an issue where Node References were rendered at the origin (0,0,0) when selected in the Asset Browser.
• Fixed crash and loss of unsaved Texture Paint changes when dragging materials over objects, which also caused Undo to skip the most recent state.
• Fixed crash when selecting scene objects created from non-native assets (e.g. FBX, USD) after reloading the File System.
• Fixed an issue where previews continued to load even after closing the Asset Widget. The "Thumbnail Generation" message is no longer displayed on loading existing previews.
• Fixed crash and UI state corruption when closing a fullscreen Viewport via Alt+F4, which left incorrect viewport states, broke window layout behavior, and caused errors when using Hide/Focus actions.

 

WebStream Plugin Improvements

The WebStream plugin has been optimized and restructured by separating the plugin from the web server, providing greater control over streaming configuration. Users are now responsible for deploying the server themselves.

The plugin connects to a signaling server via WebSocket, while the browser connects to the same server. Using a custom signaling protocol, the plugin and browser establish a peer-to-peer (P2P) connection, after which video is streamed directly to the browser.

This update adds the following options to the plugin:

• Selection of a preferred codec from the available options
• Selection of the preferred transport protocol (TCP or UDP)
• Streaming from specific cameras with configurable capture resolution
• Configuration of streaming bitrate and frame rate

 

Integrations

ROS Support Upgrade

We've upgraded ROS (Robot Operating System) support from Galactic to Jazzy Jalisco, aligning the engine with a newer ROS 2 distribution and its long-term support cycle (May 2029). This brings access to updated ROS 2 APIs, improved rclcpp/rclpy behavior, and better compatibility with modern middleware and tooling resulting in better stability, easier integration with modern robotics workflows, and improved maintainability for robotics and simulation projects.

ROS Vehicle Demo Updates

We've also extended the functionality of our ROS Vehicle Demo by adding new sensor models designed to generate richer sensor data from simulation environments. Without a single line of code, you can configure these sensors to emulate real-world devices, simplifying creation of accurate digital twins - whether for vacuum cleaners, autonomous combine harvesters, drones, or any other robotic platform.

The following sensors were added:

• ROSSensorAirPressure - Measures atmospheric pressure
• ROSSensorAirspeed - Measures the speed of air relative to the sensor
• ROSSensorAltimeter - Measures altitude above a reference point
• ROSSensorIMU - Measures linear acceleration and angular velocity
• ROSSensorLiDAR - Produces LiDAR point cloud data
• ROSSensorNavSat - GPS, Simulates GPS-like positioning sensor
• ROSSensorCamera - Captures standard RGB images
• ROSSensorBBCamera - Captures images with bounding box annotations
• ROSSensorDepthCamera - Captures depth information
• ROSSensorLogicalCamera - Detects models within a specified volume
• ROSSensorThermalCamera - Detects heat signature
• ROSSensorWideAngleCamera - Captures wide field of view

 

Python/C++/C# DataBridge Plugin (Sim Edition Only)

The new DataBridge Plugin opens the door to fully data-driven UNIGINE applications. It enables live communication between the 3D scene and external systems - such as sensors, robotics controllers, scientific tools, web interfaces, or Python scripts - making simulations more realistic, interactive, and easier to develop.

Highlights:

• Real-time data exchange between UNIGINE and external applications using a simple, universal API
• Variable-based data model for sharing and synchronizing named values across multiple instances
• Reliable networking powered by RUDP for ordered, loss-free delivery
• Flexible architecture supporting Python, C++, C#, and multiple simultaneous clients
• Lightweight REST API for runtime access to DataBridge Variables via HTTP
• Control UNIGINE scenes externally - adjust parameters, run logic, or drive scenarios without rebuilding the application
• Monitor and inspect live data through the DataBridge UI

The DataBridge Plugin streamlines integration with enterprise systems, ML pipelines, robotics frameworks, digital twins, and scientific simulations - helping you build smarter, more connected 3D applications. The corresponding sample has been added to both C++ SIM and C# SIM sample packs.

Available only in Academic Research and Sim SDK editions.

To learn more about the plugin please refer to this article.

 

Video Playback to Textures

We've added a new MediaPlayer plugin that enables playing video content - both streamed and loaded from files - directly to textures using VLC Media Player functionality. The plugin is based on the libVLC library, which decodes video streams and renders frames in real time to textures that can be used in UNIGINE materials.

This allows video playback to be integrated naturally into 3D scenes, enabling use cases such as TV screens, surveillance camera monitors, in-vehicle dashboards, and multimedia displays, all rendered as part of the engine's standard material and lighting pipeline.

Available only in Academic Research and Sim SDK editions.

To learn more about the plugin please refer to this article.

 

PDF Documents in UNIGINE Scenes

A new PDFRender plugin allows you to import and display PDF files directly within your UNIGINE scenes. The loaded PDF is rendered into an Image object with specified parameters, which can then be used in various scenarios - e.g., on shared boards during VR meetings or presentations.

For your convenience we have added the following new samples to both C++ SIM and C# SIM sample packs:

• PDFRender: Viewer Widget
• PDFRender: Single Page Rendering

Available only in Academic Research and Sim SDK editions.

To learn more about the plugin please refer to this article.

 

SQL Database Plugin

The new Sql Plugin adds native support for working with SQL databases directly from UNIGINE applications. It enables seamless integration with external data sources and backend systems through a straightforward, query-based API.

Key Features:

• SQL database connectivity: Execute SQL queries and interact with relational databases directly from UNIGINE.
• Standard request - response workflow: Supports typical SQL operations for reading, writing, and updating structured data.
• Built-in data types: Integrates with UNIGINE's internal data types for convenient handling of query parameters and results.
• Asynchronous execution: Queries can be dispatched to a dedicated thread, preventing blocking and maintaining stable application performance.
• Thread-safe operation: Asynchronous requests allow simulation logic and database operations to run independently without impacting frame time.

For your convenience we have added the following new samples to both C++ SIM and C# SIM sample packs:

• Table View UI (SQLite v3)
• Nodes Streaming (SQLite v3)

Available only in Academic Research and Sim SDK editions.

To learn more about the plugin please refer to this article.

 

Programming and API Improvements

C# Coroutines

 

If you've ever worked on game development, you've probably encountered the concept of coroutines. Coroutines are lightweight execution flows that let you run delayed or time-dependent tasks without relying on asynchronous operations or multithreading.

They are perfect for scenarios like waiting for animations, handling cooldowns or sequencing events, while keeping your code clean, readable and free from callback chaos.

Coroutines are now available for all projects using C# API, so you can write smooth, time-controlled gameplay logic without worrying about callbacks or state management.

To learn more and see coroutines in action, see the Coroutines article.

 

API Cleanup

As part of ongoing efforts to improve API clarity and maintainability, we have performed a targeted cleanup of several elements that were either unused or frequently caused confusion.

The following methods and components have been removed:

• save() / restore() from the WorldLogic class - These methods were unused and did not play a role in typical engine workflows, which often led to questions about their intended purpose.
• saveState() / restoreState() from the Plugin class - Similar to the WorldLogic methods, these APIs were not actively used and added unnecessary complexity without providing clear benefits.
• AppEditorLogic from C++ and C# project templates - This component was unnecessary for the majority of projects and has been removed to simplify template structure and reduce boilerplate code.

By removing these elements, we aim to reduce ambiguity, make the API easier to understand, and help developers focus on the systems that are actually relevant for building applications.

 

No Property GUIDs in C# Components

We've reworked how C# components are linked to nodes by removing property GUIDs from the source code of C# components. This makes C# components copy-paste friendly, avoids broken links when using code from examples, and eliminates a common source of confusion during development. From version 2.21 onward, only one component class is allowed per C# file, and it must be declared as partial:

Source code (C++)

public partial class GameController : Component
{
    public GameState state;
    ...

 

Tracker Updates

Alongside the major overhaul of the Animation System introduced in this release, we have continued improving the current Tracker by fixing several issues and enhancing its stability, ensuring it remains reliable and comfortable to use while the new Sequencer tool is on the way for the next release.

• Extended the set of Water Global parameters accessible via Tracker.
• Fixed displaying of Color and Mode parameter types.
• Fixed an issue where node names were missing after world reload.
• Fixed parameter linking by name being reset when switching between worlds.
• Fixed an issue where the color picker moved behind the editor window when the latter gained focus.
• Fixed DPI scaling issues, including unresponsive buttons and distorted, hard-to-use Add Parameter and Track Settings windows.
• Fixed an issue where changing time via the Time field did not work for parameters without the track graph toggle (T).

 

Sandworm

The Sandworm tool keeps maturing with numerous optimizations and bug fixes. The list of the most noticeable improvements includes:

• Added initial support for river generation based on either vector or polygon data available. While still an early implementation and there's a lot to be done, it already helps reduce manual terrain authoring work.
• Added support for the EPSG:3395 (World Mercator) projection for TMS, improving compatibility with non-Web Mercator tile sources and ensuring more accurate geographic representation.
• Improved triangulation for buildings ensures that geometry of buildings of a more complex form (e.g. with holes inside) are now generated correctly.
• Object placement along splines (such as fences, power lines, billboards imitating lights, etc.) has moved into a dedicated UI item named Spline Objects with the output baked into a Mesh Cluster.
• Fixed occasional road tiling artifacts on slopes.
• Resolved an issue where Mask states were reset to Enabled after reopening a Sandworm project.
• Fixed incorrect height and mask adjustments during road generation.
• Made road spline tangent smoothing optional, allowing 90-degree turns.
• Improved console warnings with more detailed information.

 

File System Improvements

Wildcards make it easy to define flexible filtering rules that match multiple files or directories based on patterns rather than exact names (e.g., "*.jpg", "some_folder_*/", "dir*/*1*.world", "editor_[1-9]*.log" etc.), enabling you to describe complex inclusion/exclusion logic concisely and readably, especially when managing large data sets. Full-featured wildcards are now available in Cleaner and Create Build tools, mount points (.umount files), and some other subsystems. You can use them to selectively add files of certain types or contents of folders with certain names, or on the contrary, to ignore the ones specified. You can also manage wildcards via API using the PathWildcards class.

 

SpiderVision

We continue improving SpiderVision to make it a more convenient and reliable tool with every release. In this update, we introduced several quality-of-life improvements and fixed multiple inconsistencies.

 

CAVE Support (WIP)
One of the focuses of the current SpiderVision development is adding support for CAVE setups (expected in the next SDK release). At the same time, we are streamlining the configuration process for CAVE environments, making them easier to set up and manage while maintaining flexibility for complex visualization scenarios.

• Wall generation settings: added the Viewport Type setting, also available when configuring the viewport.
• Wall viewports ungrouping: it is now possible to ungroup Wall viewports and edit them individually. To do this, select the root wall node (or nodes) and press U. You can revert to the grouped Wall arrangement with Ctrl + Z.
• Window Modes: added support for Exclusive Fullscreen (with a fully functional projections configurator in this mode) and standardized the naming of other modes to align with common industry terminology.
• Projection Setup: improved multi-point selection behavior, including more consistent value display and more intuitive editing of selected points.
• General: various fixes as well as visual and UX improvements, including more accurate FOV calculations and display (with both vertical and horizontal values shown), fixes for occasional missing parameter values, logging for viewport data changes, and more.

 

IG Updates

We continue extending Image Generator support to cover a broader set of CIGI features. This update introduces several architectural improvements as well as stability and functionality updates for CIGI and DIS integration.

 

Plugin Architecture Changes

Geodetics System Refactoring

The geodetics system has been refactored and moved to a standalone Geodetics plugin.

The former IG::Converter class has been split into two separate classes:

• Geodetics::Converter, which provides most coordinate conversion functionality.
• IG::NEDConverter, which contains axis conversion functions (NED => ENU).

This change simplifies coordinate conversions and allows the system to automatically detect the world geodetic configuration. The APIs remain largely compatible, so most projects should not require migration changes.

Key improvements:

• Automatic initialization based on the world projection.
• Unified coordinate conversions between world, geodetic, and geocentric (ECEF) coordinate spaces.
• Transparent support for both Sandworm-generated terrain and Geodetic Pivot setups.
• Access to the projection offset via Transformer::getOriginProjectionSpace().

For more details please refer to API Migration Guide.

 

Weather System Separation

Weather functionality has been moved from IG into a dedicated Weather plugin. The configuration file has been split into ig_config.xml and weather_config.xml. IG and Weather plugin assets are also stored separately.

 

Content Rearrangement

IG Template content storage format has been changed: previously the ig_data/ig.umount file, now it is stored as *.ung (data/modules/ig.ung and data/modules/weather.ung). Storing content in this format allows viewing and using the files in the Editor without modifying them.

 

CIGI / DIS Improvements

This update also includes several improvements to CIGI and DIS functionality:

• Added the ability to define Collision Detection Segments for an entity in the Editor.
• Implemented full support for trajectory definition packets.
• Fixed the processing of rate control packets.
• Added API support for retrieving and assigning the owner ID of a given Entity, indicating which system component created and manages it (user, CIGI connector, or DIS connector).
• Fixed filtering of DIS protocol data units (PDU) - now Site ID is taken into account when IG Entity ID is created based on DIS Entity ID (Site, App, Entity). Filtering logic has also been updated.
• Added callbacks executed before processing incoming CIGI and DIS packets, along with methods for reading and modifying the contents of incoming and outgoing packets.
• Fixed various issues in DIS Connector.

Various rendering issues have also been addressed, including:

• Emission state switching
• Projection of wake decals onto a wavy water surface
• Synchronization of light sources and stars

 

VR/XR Improvements

• Added a console warning when running the engine with Steam OpenXR and the ViveVR OpenXR Hand Tracking layer enabled on unsupported headsets (in such cases controllers may not be tracked).
• Fixed an issue where controller velocity was calculated incorrectly after player rotation.
• Fixed an issue with incorrect visualizer arrow size.
• Corrected an issue where controller coordinate systems were inverted (facing negative direction) in the default hand pose. The issue may still occur on Quest 3 with Quest Touch controllers, likely due to a driver-related problem.
• Fixed incorrect Z position after zero pose reset in OpenXR (VarjoOpenXR / PicoStreamingXR), where the position was aligned to the Player regardless of the active tracking space.

 

Mixed Reality Notice

From version 2.21 onward, Mixed Reality mode is not available in the Free Community SDK edition.

 

Add-On Store Updates

To simplify AI-assisted development we have added a new experimental MCPBridge add-on.

The following new content add-ons are available for SDK versions 2.20 and 2.21:

Advertising Pack Building Facade Pack Café and Retail Zone Pack Fence Pack Garden & Park Greenery Pack Modular Buildings Pack Park Detailing Pack

Poles, Streetlights, and Traffic Lights Pack Ready-Made Buildings Pack Road Pack Street Props Pack Traffic Car Pack Traffic Accidents Pack Trash Pack

 

 

 

 

Toolkit Plugin: New 3D Modeling Module and Updates

Contributors from our community continue to expand the Toolkit plugin. This release introduces a new 3D Modeling module for fast in-editor geometry prototyping. It enables interactive primitive creation, flexible mesh editing, boolean operations, object distribution, and LOD generation — allowing you to build and iterate on scene geometry directly without external tools.

Other updates:

• Added support for SDF and MSDF (Multi-channel Signed Distance Field) — a raster alternative to SVG images for high-quality scalable graphics
• Added a diegetic UI sample, demonstrating an interface embedded directly into the world and interactable in real time
• Added the MouseHandleSetter component to UI Designer, helping resolve common cursor and input handling issues

The updated add-on is available on the Add-On Store.

 

New Entertainment SDK Edition

For commercial studios working in creative, visualization, entertainment, and XR industries, we have introduced the Entertainment edition of the SDK. It removes the revenue limitations of the Community edition and includes professional support for production use.

You can compare SDK editions here.

 

New Academic Research SDK Edition

Designed for universities and research labs, the Academic Research edition of the SDK enables advanced experimentation and development across a wide range of scientific and technical domains. It includes many of the most advanced features from the flagship Sim edition, along with extended technical support to assist with complex research workflows and long-term projects.

You can compare SDK editions here.

 

Demos and Samples

We've continued expanding the sample collection to make it easier to move from concepts to working implementations. These ready-to-use examples demonstrate common workflows and help both new and experienced developers get projects up and running faster, whether they explore the Engine for the first time or build a professional-grade simulation.

The following new samples were added to both C++ Samples and C# Component Samples suites:

1. Real-Time Mesh Editing with Marching Cubes - simulation of ground digging, modification of a terrain fragment represented by a mesh via API.
2. Mesh To Mask Texture - mesh rendered into a texture using a custom material, producing an image to be used as a mask.
3. Polygon-based Tools for Procedural Modifications - procedural generation of polygon objects from world points, enabling runtime landscape editing and object placement.
4. Procedural Spline Mesh Generation - procedural generation of spline-based meshes using world points as control nodes.
5. Nodes And Widgets Lifetime Control - node and widget lifetime settings affecting object persistence during world transitions.
6. Object Text - text objects created and controlled via API, using the ObjectText class.

We've also spent some time to add some samples that were missing in the C++ pack from the C# pack and vice versa, ensuring that both developer groups benefit from a more complete set of examples.

The C++ Sim Samples suite now includes the following new samples:

1. Ship Buoyancy (Physical) - physically accurate buoyancy for dynamic objects floating on Global Water.
2. DataBridge - a simple car controller demonstrating server - client interaction with Python and HTTP REST API.
3. Nodes Streaming (SQLite v3) - spatial streaming of scene data from an SQLite database using ObjectMeshCluster and the UnigineSql plugin.
4. Table View UI (SQLite v3) - local SQLite database as a structured data backend inside UNIGINE via the UnigineSql plugin.
5. HTTP Set Player Position (Rest API) - asynchronous HTTP server that handles GET requests to control player position through external applications.
6. PDFRender: Single Page Rendering - rendering PDF files with extended control over output parameters using the PDFRender plugin.
7. PDFRender: Viewer Widget - PDF rendering inside a custom widget using the PDFRender plugin.
8. MediaPlayer: Video to Texture - simple no-code approach of integrating video playback directly into a 3D scene using the UnigineMediaPlayer plugin via the VideoSourceComponent.
9. MediaPlayer: Video to Widget - video playback integrated into a 3D application using the UnigineMediaPlayer plugin.

This release has also made the pack of C# Sim Samples available for C# developers.

CUDA Samples have become available in all SDK editions.

 

Sample Navigation

Beyond expanding the sample library, we've reworked the browsing experience. The new category-based menu system lets you quickly navigate between samples within a category, which lets you seamlessly flip through scenes or pick the right one from a list - this makes finding relevant examples faster and more intuitive. And the updated UI puts everything at your fingertips: you can open any sample in the Editor or access its source code directory straight from the runtime. Art Samples now live alongside the rest in the Samples tab - everything in one place.

 

Documentation

Added a set of new ultrashort HowTo quick tip videos in English, Chinese, and Russian:

• Updated the Getting Started with VR article.
• Added a new article on AI-Assisted Development in UNIGINE.
• Added a new article on Integrating with 3rd-Party Software.
• Added a new section on Animation Graph.
• Added a new section on Project Templates.
• Added a new article on the DataBridge Plugin.
• Added a new article on the MediaPlayer Plugin.
• Added a new article on the PdfRender Plugin.
• Added a new article on the SQL Plugin.
• Updated the Editor API reference.
• Updated the article on the Profiler.
• Added a new article on Coroutines.
• Extended info on all samples included in the SDK.
• Updated information on the procedural workflow for ObjectMeshStatic.
• 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.

 

[fox]

2.21.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.21.

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

The updated version of the documentation is available as 2.21.

Engine

• Added SKIP_UPSCALE flag to selectively disable upscaling for specific viewports while keeping the post-effects, preventing random artifacts when rendering many viewports with DLSS/DLAA enabled. Additionally, we have introduced the dlss_max_context console command to adjust the maximum number of DLSS/FSR contexts (up to 16) at engine startup. This enables better performance management, especially for hardware capable of handling multiple viewports without significant performance loss.
• Fixed a crash on engine startup when running in Debug mode with video_debug set to 2.
• Fixed an issue where loading a world without a camera triggered the ”Render::endFrame(): frame was not rendering” error.
• Fixed an assertion failure when resizing the window with video_debug 2 enabled.
• Fixed migration of mask parameters of Landscape Layer Maps (.lmap) causing corruption of Landscape Terrain data after migration.
• Fixed an issue that caused excessive overhead during water rendering.
• Fixed an issue with migration of the .csproj file that caused file corruption in case the project contains many (100+) C# components.
• Fixed an issue where incorrect surface contact detection caused the character to bounce off 'air' during repeated jumps.
• Improved HTML logging for the content and code upgrade process.
• Fixed artifacts (spotting) when baking lighting from OmniLight and Emission sources.
• Removed unnecessary internal material inheritance logic for ObjectWaterMesh and ObjectWaterGlobal, preventing material GUID changes on reloading the world.
• Fixed an issue that caused extended flickering in static scenes when Peripheral Rendering VR mode was enabled.
• Fixed inconsistent reflection sharpness in stereo viewports when using Indirect Specular Denoiser with Environment and Planar Reflection Probes, ensuring consistent reflection quality in both baked and realtime update modes.
• Fixed an issue with render_stereo_hidden_area not accounting for Foveated Rendering, causing focus viewport to render over the mask on Varjo HMDs. The Foveated viewport is now cropped correctly, and only the area defined by render_stereo_hidden_area is rendered.
• Fixed the issue with the seamless transition between the foveal and peripheral display areas, ensuring it works correctly regardless of the Render Border settings.
• Fixed an issue causing the Water Global object to disappear under certain camera transformations and angles. The water now displays correctly regardless of camera position.
• Fixed an issue with the Sun Light Intensity having a stronger effect on volume_cloud_base in 2.21 compared to 2.20, causing the volumetric clouds to appear significantly brighter with the same settings.

Editor

• Fixed multiple crashes, asserts, and material duplication issues during package import and asset handling, including proper cleanup of runtimes, file lock releases, and error logging for duplicate GUIDs and null mounts.
• Fixed a crash on changing meshes via quick asset change with Selected Node Info and TBN enabled.
• Restored the Morph Target Preview window for ObjectMeshSkinned (non-Legacy) and fixed a bug where duplicate names caused some morph targets to be missing on import due to duplicate names.
• USD Import/Export:
  • Fixed an issue where animations were not automatically assigned to the Preview Animation slot on import — animated USD assets now display correct previews (instead of T-pose) and have their animations properly linked when added to the scene.
  • Fixed an issue where importing animations from USD assets could cause mesh geometry distortion.
  • Fixed issues with importing textures and materials from USD assets, ensuring proper assignment and rendering.
  • Fixed a crash when importing or reimporting USD assets with a skeleton using the Shared Skeleton Import Mode.
  • Fixed exporting skinned objects to USD and FBX formats.
• Fixed generation of Octahedral impostors for rotated source objects, that caused incorrect impostor orientation.
• Disabled Edit buttons for an ObjectMeshCluster in case it is a child of ObjectParticles to prevent unwanted mesh duplication; a corresponding warning will now be displayed with a link to the documentation and improved undo to restore mesh positions when the parent-child relationship is reverted.
• Fixed an issue where surfaces were created with the default mesh_base material assigned when regenerating buildings in Manual mode after using Auto mode with custom materials.
• Fixed an issue causing the Editor to reset component parameter values to defaults in case of a C# compilation error.
• Improved handling of source vector data to avoid broken geometry when generating buildings.
• Fixed the natvis file for Qt version 6.5.

Sandworm

• Added support for manually entering coordinates in the Preview window, allowing users to specify an exact location (e.g., using latitude/longitude from map services) and start generation from TMS without any preloaded data.
• Fixed a crash when generating a Global Terrain on Linux.
• Fixed generation of a curved Global Terrain that caused incorrect placement of DecalMesh-based roads and Spline Objects.
• Fixed a crash when generating roads with Forward Axis set to -X or -Y in vector data.
• Fixed an issue where a generated Landscape Terrain with data compression enabled would not display immediately after generation, requiring a world reload or toggling the Landscape node.

 

Samples and Templates

• VR Template:
  • Unified player controls across C++ and C# APIs — jumping, sprinting, and other controls are now supported consistently in both implementations.
  • Fixed and unified sounds playback across C++ and C# APIs.
  • UI for Hand Tracking control is now the same for both C++ and C# APIs.
• Fixed incorrect rendering of the glass_thin_with_ssr material in case Materials Quality is set to 0.
• Fixed issues with non-optimal rendering settings in samples, restoring performance to expected levels.
• Fixed an issue with the CPP Sim Samples pack where exiting the Main Windows sample (run in fullscreen) caused closing the application when returning to the main menu.