This page has been translated automatically.
Recent news:
Table of contents:

UNIGINE 2.0: Fully Deferred Rendering, TAA, Data Streaming Improvements, Performance Optimizations

The UNIGINE 2 stable release is finally available, incorporating more than 1.5 years of major technology improvements. Please see the details on its features on the renewed

Key Changes from 2.0 RC

  • Fully deferred renderer by default.
  • Performance optimizations.
  • Added high-quality temporal anti-aliasing (TAA), enabled by default.
  • Added high-quality environment probes for dynamic reflections.
  • Improved quality of effects: SSAO, motion blur, bloom.
  • Unified and improved decals.
  • Improved workflow for transparent materials.
  • Introduced simulation of optical sensors in the EO or IR passband.
  • More artist-friendly materials with easier setup.
  • Faster data streaming greatly increasing FPS stability and improving synchronization between IG channels.
  • Improved CAVE support.
  • Added support for DIS/HLA/C2 standard protocols.
  • Improved native support for Oculus DK2.
  • Improved Quad Buffered Stereo support.
  • Better performance profiling tools.
  • Easier graphical debugging.
  • Added support for Perception Neuron wireless motion capture system.
  • Added support for ARTTRACK motion capture API.
  • Extended C++ and C# APIs.
  • More consistent console commands.
  • UnigineEditor has been migrated to Qt widgets (native look and feel, faster).
  • Experimental asset browser.
  • Improved FBX format support.
  • Introduced Video Grabber tool.
  • Countless bugfixes.


There are now three different editions of UNIGINE 2 available:

  • Starter - the affordable option for games and small-scale projects.
  • Professional - the edition for architecture visualization, film and TV production, and larger game development.
  • Sim - the ultimate suite for complex high-fidelity simulators and professional VR systems.

Old UNIGINE Game licenses will be upgraded to UNIGINE 2 Professional.

New Rendering Pipeline

Fully Deferred Rendering

UNIGINE 2 has been switched to a fully deferred renderer, so all opaque geometry is now rendered in the deferred pass. Therefore, the rasterization process happens only once, which highly increases performance. After the rasterization process, all lights are applied to the necessary buffers to create the final image of the scene.

Transparent Objects

Transparent objects rendered in the deferred pass are grouped to be rendered in one DIP, which is much faster than in forward rendering, but there is a limitation: they overlap other transparent objects rendered in the deferred pass. However, they provide realistic reflections and cover most cases.

If it is critical to see another transparent object behind the front one, forward rendering is available for transparent objects. In comparison with the deferred pass, transparent objects aren't grouped in this way, which increases the number of DIPs.

Performance Optimizations

It is important to understand some facts about performance of the new renderer as it has several new features in comparison with the older one. Maximal FPS on empty/simple scenes with the new render is lower (about 200-250 FPS) than the old one (up to 1000 FPS), but anything above 120 FPS (60 Hz in stereo) has no practical difference. The interesting part is when we start adding content into the scene, the new renderer's FPS value is almost constant, very slowly decreasing in comparison with the old version.

A simple test with a lot of small static meshes:

As for the raw polygon rendering performance, UNIGINE 2.0 demonstrates even better results:

Here is another test on a static scene with 7.3 million polygons and multiple LightWorlds without shadows (deferred rendering is better for handling lots of dynamic light sources by design):

So UNIGINE 2.0 performance scales much better and can perfectly do the heavy lifting with CAD data, unoptimized 3D scans or any other extremely complex and detailed scenes. Many customers chose UNIGINE 1 because it outperformed competitors, and now we pushed the performance of the engine even further.

Temporal Anti-Aliasing

UNIGINE 2 uses a high-quality temporal anti-aliasing (TAA) algorithm by default. The obsolete multisample anti-aliasing (MSAA) and all corresponding functions have been removed.

In case of fully deferred rendering (when the final image is composed of different texture buffers: depth, normal, etc.), TAA applies smoothing to the whole scene, which is much faster comparing to MSAA that is applied to each texture buffer. Besides, TAA improves the whole image (not only the edges of the geometry, like MSAA) including geometry, shadows, etc., thus delivering overall better visual quality.

TAA disabled:

TAA enabled:

To enable/disable TAA, use the render_taa console command (or Rendering panel -> Features -> TAA in UnigineEditor). When TAA is disabled, the fast approximate anti-aliasing (FXAA) can be used. However, TAA implementation is very performance-optimized, so it is recommended to always keep it on.

Environment Probes

Added high-quality environment probes (LightEnvironmentProbe) for creating dynamic reflections instead of creating reflection materials. They highly increase performance because they require less materials (i.e. reducing DIPs). Environment probes can use pre-baked static cubemaps or dynamically grab the surrounding environment (thus creating dynamic reflections). This cubemap influences reflections and lighting of all objects that have entered into the environment probe's radius.

Unlike other engines, UNIGINE 2 has unique environment probes: they can also work with transparent objects, rendered in the deferred pass.

To add the environment probe to the scene via UnigineEditor, do the following:

  1. On the Menu bar, click Create -> Light -> Environment Probe.
  2. Place the object somewhere in the world.
  3. Grab a new cubemap texture for the environment probe (Light -> Grab texture button in the Nodes window) or load the pre-baked one.
  4. Adjust the environment probe settings.


Improved SSAO (Screen-Space Ambient Occlusion) quality: now it works sub-pixel and supports far objects.

Improved the bloom effect quality: now it works per-pixel, its radius changes dynamically depending on the pixel brightness, and it can be modulated by the dirt texture. The old glow effect has been removed (it can be simulated with the new bloom).

  • Improved motion blur quality: now it works per-object and supports objects without physical bodies assigned.
  • All HDR effects can now be adjusted independently.
  • Added the sharpen post-effect.


Transparent Materials

Simplified setup of transparent materials, added the Common -> Transparency option with simple presets:

Option Pass Description Blending to set
Opaque Deferred for opaque objects Used for opaque materials No blending
Alpha blend Forward for transparent objects Standard alpha blending Src = src alpha
Dest = one minus src alpha
Additive Forward for transparent objects Color addition Src = one
Dest = one
Multiply Forward for transparent objects Color multiplication Src = dest color
Dest = zero
Deferred alpha blend Deferred for transparent objects Rendered over opaque materials to the G-buffer, alpha blending is used No blending
Custom Forward for transparent objects Used for custom configurations Custom

Materials Set

The set of UNIGINE built-in materials has been changed in order to simplify a 3D artist's work (less base materials, more features, easier setup).

billboard_base Merged into billboards_base. See details below.
Merged into decal_base. See details below.
Merged into mesh_base.
Obsolete, removed.
Removed, will be reworked in 2.1 release.
- Added billboards_impostor_base allowing you to place impostors manually in the scene (similar to clusters).
Added post_sensor for real-time sensor effects simulation.

Other materials settings were also revised:

  • Simplified material options, removed redundant ones (Render group, Post refraction, Glow mask, Parallax mask, Receive shadow and Receive world shadow).
  • Removed light prob and light spot passes.
  • Removed light passes for opaque materials.
  • Added a Decal mask parameter specifying to which objects a decal will be applied.
  • Removed all emission settings.
  • Removed all ambient light settings.
  • Added the Translucent parameter to the mesh_base, billboards_base and grass_base materials modifying the value of translucency. The old Cast translucence and Receive translucence options have been removed.
  • mesh_base:
    • Metalness workflow is now set as default.
    • Simplified choosing of the UV map to use (States -> UV settings field). The old Overlay second and Multiply second detail options have been removed.
    • Added the Cutout parallax mapping effect providing hard edges between the opaque and transparent areas.
    • Added new detail textures blending options (the Detail toggle):
      • Lerp by mask - enable a detail blend mask and additional textures and parameters to blend with. (Merged mesh_layer_base functionality.)
      • Overlap (object transform) - overlap the base material by using the object transformation. Detail textures will be rotated with the mesh. (Merged mesh_overlap_base functionality.)
      • Overlap (world transform) - overlap the base textures by using the world transformation. No matter if you rotate the object, the detail textures will always be projected atop. (Merged mesh_overlap_base functionality.)
    • Added the Geometry inflation option for creating an additional visual effect without real geometry changing:
      • Wire - bloats the geometry normals to provide more realistic wires depending on the distance to the mesh.
      • Balloon - bloats the geometry by specified constant creating an effect of a balloon.
      The corresponding parameter is Balloon value.
    • Added the Opacity map option specifying the alpha channel of which texture to use:
      • Main - use the alpha channel of the main (albedo or diffuse) texture.
      • Normal - use the alpha channel of the normal map.
    • Removed the Shadow distortion parameter.
    • Removed the Reflection parameters. Environment probes should be used instead.
  • grass_base:
    • Added the Shadow shafts option, simulating visible volumetric shadows, arising when a bright world light source is partially obscured by grass.
    • Added the Occlusion parameter enabling occlusion that sets shading starting from the ground to the top of the grass blade (the corresponding scale slider is Occlusion scale).
    • Added the microfiber effect (the Fibers texture and parameter) set by default.
    • Added the Diffuse multiplier parameter.
    • Removed the base Shadow parameter.
    • Removed all light passes.
  • billboards_base:
    • Added support for alpha testing.
    • Added the microfiber effect (the Fibers texture and parameter) set by default.
    • Added the Diffuse multiplier parameter.
    • Removed the base Shadow parameter.
  • mesh_leaf_base:
    • Added the spherization (generation of the normals relatively to the center of the sphere) option.
    • Added the microfiber effect (the Fibers texture and parameter) set by default.
    • Removed the Phong shading parameter.


Now it is possible to adjust engine tessellation for ObjectWater via the following console commands:

  • render_water_resolution_low - sets the size of the cell of the water grid that is used when there are no water waves (the amplitude of waves is set to 0) and post refraction is enabled.
  • render_water_resolution_high - sets the size of the cell of the water grid that is used when water waves are simulated (the amplitude of waves is nonzero).

Further improvements are scheduled for the 2.1 release.

Sensor Effects

Introduced real-time sensor effects simulation of optical sensors in the EO or IR passband. The corresponding material is post_sensor. It comes with 4 built-in synthetic configurations:

  • post_sensor_green - enhanced night vision maps.
  • post_sensor_white, post_sensor_red, post_sensor_heat - infrared maps.


All decals are simplified and merged into three objects:

  • DecalProj is a decal projected onto a surface by means of perspective projection.
  • DecalOrtho is a decal projected onto a surface by means of orthographic projection.
  • DecalMesh is a decal based on the arbitrary MESH file and projected onto a surface by means of the orthographic projection.

Decals are rendered in the deferred pass and can be applied only to objects that were rendered in the deferred pass.

The decal_base material has also been updated:

  • Deferred rendering for decals: they are rasterized only once, no matter how many light sources are in the scene.
  • Fixed work with post-processes.
  • Added a Decal mask parameter allowing to set a bit mask for a decal thus specifying the objects only to which a decal will be applied.
  • Added blending options (States -> Blend):
    • Jitter - overwriting of all materials under the decal with gradient.
    • Alpha blend - alpha blending mode.
    • Overlay - overlay blending.
    • Multiply - multiply blending.
  • Added the Opacity map option indicating the alpha channel of which texture to use:
    • Main - use the alpha channel of the main (diffuse) texture.
    • Normal - use the alpha channel of the normal map.
  • Added the microfiber effect (the Fibers texture and the Fibers visibility parameter) set by default.
  • Added the Translucent visibility parameter modifying the value of translucency.
  • Added a Normal substitute parameter specifying a rendering mode for normals. By default, normal maps of a base and overlapping material are combined together. With this option enabled, only normals of the overlapping material are used.
  • Added the set of fading parameters:
  • The Distance power and Distance threshold parameters modify the distance starting from which the projected overlapping decals start to fade (to enable parameters, click the Distance fade option).
  • The Angle threshold and Angle power parameters modify the fading angle for projected overlapping decals.
  • Renamed shading parameters: Glossiness -> Gloss, Normal -> Normal intensity.
  • Removed all light passes.
  • Removed parallax effect.
  • Removed all ambient light settings.
  • Removed all emission settings.
  • Removed the Fresnel bias and the Fresnel power parameters.
  • Introduced "Visibility" parameters, which controls the effect from the specific decal aspect to the final image.


The AppQuadBuffer plugin has been merged into the engine. In order to enable Quad Buffered Stereo mode (works only for Windows and Linux), perform the following:

  1. Make sure that you use the graphics card with support for Quad Buffered Stereo (NVIDIA Quadro),
  2. Make sure that Quad Buffered Stereo is enabled in your video driver settings,
  3. Set -video_quad_buffer 1 command line option (alternatively, you can run video_quad_buffer 1 && video_restart console command in the running engine instance).

Oculus Integration

AppOculus has been migrated to Oculus SDK 0.6, featuring native support for Oculus Rift DK2. Since Oculus VR has stopped supporting Linux and Mac, the plugin is available only for Windows only at the moment.

Multi-Channel Rendering

  • Added the Unigine::Syncker::Master::syncCAVE() method for synchronizing head position in CAVE systems.
  • Added the return value to the Unigine::Syncker::Master::createNode() method. 1 - the node will be created on every slave, 0 - the node won't be created.
  • Added ability to create NodeDummy, PlayerDummy, PlayerSpectator and PlayerActor on the slaves via the Unigine::Syncker::Master::createNode() method.
  • Added ability to set the maximum size of the sent/received UDP packet, the default size has been increased to 4Kb.

Graphics Debugging

Added ability to create debug context for graphics. It allows you to debug HLSL/GLSL shaders step-by-step, inspect each DIP, see the result of each DIP on the final image, etc. Graphics debugging can be enabled via:

  • Setting the -video_debug 1 command line option (alternatively, you can run video_debug 1 && video_restart console command in the running engine instance). Works for both OpenGL and DirectX 11.
  • Specifying the USE_OPENGL_DEBUG_OUTPUT macro for extended debug OpenGL output (requires recompilation).

Other Renderer Improvements

  • Added the per-object velocity buffer.
  • Added ability to render all objects into the auxiliary buffer.
  • Improved sRGB, it is always enabled now.
  • Fixed impostors without image masks.
  • Simplified nodes options, removed redundant ones (Receive shadow, Receive world shadow, Decal, Decal mask).
  • Simplified light source options, removed redundant ones (Force deferred, Diffuse scale, Normal scale, Specular scale, Specular power, Deferred distance, Transparent, Transparent size).
  • Removed the render_restart console command,
  • Removed redundant console commands, added new ones, most of the rendering options are controlled by consistent render_* commands now. The full list of console commands changes is available in the Console Migration article.
  • Removed the LightSpot object.
  • Removed the ObjectBillboard object. Separate billboards can now be created inside ObjectBillboards via the Billboards tab -> Add. Billboards are now rendered sub-pixel, so they can be visible from far away.
  • Added materials reparenting (Materials window -> Change material parent button).
  • The default materials library is now created on the new world creation.
  • Countless bugfixes.

Data Streaming

  • Added asynchronous loading of all material textures and meshes for ObjectMeshStatic, ObjectMeshClutter and ObjectMeshCluster objects into memory.
  • Added support for streaming of all textures.
  • Removed getSpawnRate()/setSpawnRate() methods of ObjectGrass and ObjectMeshClutter.
  • Removed memory limitations on loading query of meshes, images, files and blobs in the file system.
  • world_log_async and filesystem_log_async console commands have been replaced with async_log_mode and async_log_priority.
  • Procedural content of ObjectGrass and ObjectMeshClutter is now generated in a separate thread.

As a result, the majority of annoying micro-freezes were eliminated, greatly increasing FPS stability and improving synchronization between IG channels in multi-channel setups.

Performance Profiling

Integration with Microprofile

Added support for microprofile, an external embeddable CPU/GPU profiler with support for per-frame inspection. The profiler serves output as a local web server (works in the Google Chrome web-browser only), the default TCP port is 1337.

To build the engine with support for microprofile, use the USE_MICROPROFILE preprocessor macro. It is enabled by default for Mac and Linux operating systems, Visual Studio 2012+ is required for building on Windows (because of some C++11 features).

Default Profiler

  • Fixed profiling for more than one frame.
  • Added profiling covering for all engine segments.
  • Added integration with microprofile: you can use engine.profiler functions to profile a certain piece of your code via counters.
  • Added the extended FPS counter mode (enabled via the show_fps 2 console command): display of minimal/average/maximal FPS values over the last 600 frames.

Support for DIS, HLA and C2 Protocols

Introducing integration of the Calytrix LVC Game library, which enables communication between components of distributed simulation systems via the standard protocols: DIS, HLA and C2 (mostly used for military projects). Thanks to that now it is possible to connect UNIGINE 2 seamlessly into your training environment.

Integration works by means of the LVC Game add-on, available only in the UNIGINE 2 Sim edition.

Motion Capture

Introducing integration of the following popular motion tracking systems:

  • ARTTRACK is a tracking software controlling functions of the tracking system. An ARTTracker add-on is used for integration with this technology.
  • Perception Neuron is a motion capture technology that includes 9-axis sensor units and allows you to record data received from these sensors in real-time. A Perception Neuron add-on is used for integration with this technology.

C++ and C# API

Our goal is to match all 3 APIs soon, so we focused on exposing new classes and unification.

  • The following nodes were exposed to the API:
    • Decal
    • DecalOrtho
    • DecalProj
    • DecalMesh
    • Field
    • FieldAnimation
    • FieldSpacer
    • LightEnvironmentProbe
    • ObjectMeshClutter
    • ObjectSky
    • Physical
    • PhysicalForce
    • PhysicalNoise
    • PhysicalTrigger
    • PhysicalWater
    • PhysicalWind
    • WorldClutter
    • WorldCluster
    • WorldOccluder
    • WorldOccluderMesh
    • WorldOccluderTerrain
    • WorldTransformPath
    • WorldTransformBone
    • WorldExpression
  • Exposed Mesh::Weight structure.
  • Added the App::getVideoModeName method to the C# API interface.
  • All functions containing "childs" in their names have been renamed "children" and marked deprecated.
  • Fixed the String::itoa method: its return value now fully match the similar system function.
  • Added the radix argument to the setIntArg(), setIntArrayArg(), setIntData() and setIntArrayData() methods of the Xml class. It allows to specify the scale of notation to save the value. By default is 10 (decimal notation).
  • Added the renderSolidObject() and renderSolidObjectSurface() methods to Unigine::Visualizer API. It renders a solid-colored object or a surface of the object.


  • Added the core/scripts/underscore.h library providing useful functional programming helpers without extending any built-in objects (inspired by Underscore.js).
  • All functions containing "childs" in their names have been renamed "children".
  • Fixed crash in setTextureWidth() and setTextureHeight() methods of the WidgetSpriteViewport class when setting the image size.
  • Added the radix argument to the setIntArg(), setIntArrayArg(), setIntData() and setIntArrayData() methods of the Xml class. It allows to specify the scale of notation to save the value. By default is 10 (decimal notation).
  • Added the renderSolidObject() and renderSolidObjectSurface() methods to engine.visualizer API. It renders a solid-colored object or a surface of the object.
  • Renamed engine.render() functions: getShaders() to getShadersQuality(), getTextures() to getTexturesQuality(), set/getOcclusionAmbientRadius() to set/getSSAORadius(), set/getOcclusionAmbientScale() to set/getSSAOScale(), set/getHDRThreshold() to set/getCameraEffectsThreshold(), set/getHDRLensTextureName() to set/getDirtTextureName(), set/getHDRFilmicShoulderScale() to set/getFilmicShoulderScale(), set/getHDRFilmicLinearScale() to set/getFilmicLinearScale(), set/getHDRFilmicLinearAngle() to set/getFilmicLinearAngle(), set/getHDRFilmicToeScale() to set/getFilmicToeScale(), set/getHDRFilmicToeNumerator() to set/getFilmicToeNumerator(), set/getHDRFilmicToeDenominator() to set/getFilmicToeDenominator(), set/getHDRFilmicWhiteLevel() to set/getFilmicWhiteLevel(), set/isHDRCrossEnabled() to set/isCrossEnabled(), set/getHDRCrossColor() to set/getCrossColor(), set/getHDRCrossScale() to set/getCrossScale(), set/getHDRCrossShafts() to set/getCrossShafts(), set/getHDRCrossLengts() to set/getCrossLengts(), set/getHDRCrossAngle() to set/getCrossAngle(), set/getHDRCrossThreshold() to set/getCrossThreshold(), set/isHDRBokehEnabled() to set/getBokehEnabled(), set/getHDRBokehColor() to set/getBokehColor(), set/getHDRBokehScale() to set/getBokehScale(), set/getHDRBokehFarSize() to set/getBokehFarSize(), set/getHDRBokehFarPower() to set/getBokehFarPower(), set/getHDRBokehNearSize() to set/getBokehNearSize(), set/getHDRBokehNearPower() to set/getBokehNearPower(), set/getHDRBokehTextureName() to set/getBokehTextureName(), set/isHDRShaftEnabled() to set/isSunShaftsEnabled(), set/getHDRShaftColor() to set/getSunShaftsColor(), set/getHDRShaftScale() to set/getSunShaftsScale(), set/getHDRShaftLength() to set/getSunShaftsLength(), set/getHDRShaftAttenuation() to set/getSunShaftsAttenuation(), set/getHDRShaftThreshold() to set/getSunShaftsThreshold(), set/isHDRLensEnabled() to set/isLensEnabled(), set/getHDRLensColor() to set/getLensColor(), set/getHDRLensScale() to set/getLensScale(), set/getHDRLensLength() to set/getLensLength(), set/getHDRLensRadius() to set/getLensRadius(), set/getHDRLensThreshold() to set/getLensThreshold(), set/getHDRLensDispersion() to set/getLensDispersion(), set/getVolumetricExposure() to set/getShadowShaftsExposure(), set/getVolumetricLength() to set/getShadowShaftsLength(), set/getVolumetricAttenuation() to set/getShadowShaftsAttenuation().
  • Added the getExposureMode() method to the engine.render() interface allowing choosing the exposure mode: small, medium, large, bright.
  • Added set/isBloomEnabled methods to the engine.render() interface controlling a bloom effect.
  • Removed the getHDR(), set/getHDRSmallExposure(), set/getHDRMediumExposure(), set/getHDRLargeExposure(), setHDRBrightExposure() engine.render() functions.

See the full list of UnigineScript changes.


UnigineEditor has been integrated into a Qt application, providing better usability of Qt widgets (native look and feel, faster) and speed up for the development process (so users will get more polished features faster).

  • Pivot is a default pivot point option, the settings of the pivot point toggle will be saved after editor reloading.
  • The ViewCube flag will be saved after editor reloading.
  • Fixed key stuck in the File Dialog while shifting catalogs.
  • The Speed field of the ObjectMeshStatic -> MeshSkinned tab has been renamed Playback Speed.
  • The default preview model in the Materials window is material ball now.
  • Camera lock is no longer required on the track playback.
  • Camera effects (adaptive exposure, filmic tone mapping, bloom, lens, etc.) are now globally enabled in the Rendering panel -> Camera Effects. Their parameters are modified in the Rendering settings -> Camera Effects. The old HDR tab has been removed.
  • Improved undo/redo system.

Launching UnigineEditor

From now, UnigineEditor is a standalone application.

  • To launch the editor, run the editor executable file with specified command-line options (they can be the same as for the main application).
  • To launch the editor for your project, press the Edit Content button.

Since UnigineEditor is the standalone application, editor_load/editor_quit console commands are not supported from the main application.

Improved FBX Assets Workflow

  • Updated Merge static meshes option: only one merged mesh is created.
  • Added correct import of the FBX model with several layers.
  • Fixed incorrect nodes order after loading the same FBX model.
  • Added ability to choose a workflow (Specular or Metalness) on the FBX assets import.
  • The FPS option in the FBX import window has been renamed Animation FPS.
  • Added correct handling of the FBX models components with the duplicated names.
  • Fixed incorrect import of FBX files from 3ds Max (while bones hierarchy is changed).

Asset Browser (Experimental)

Initial version of the asset browser provides the following functionality:

  • Navigation through the assets and directories.
  • Ability to drag and drop assets (textures, meshes, nodes, FBX files, material libraries) into the window from the system file browser.
  • Customization of import settings.
  • Ability to drag and drop assets (meshes, nodes, FBX files) from the asset browser directly to the scene.

The feature is in the active development and is not recommended for production use.

Video Grabber

Introducing Video Grabber, a UnigineEditor tool for high-quality capturing of screenshots and frame sequences. Video sequences are captured in a special non-real-time mode, allowing to get any fixed FPS even on a low-end hardware. In comparison with traditional CPU-based offline rendering, this tool allows much faster rendering thanks to GPU acceleration.


  • Support for super high resolution (offscreen rendering) - you can take 4K/8K images even on a regular 1080p monitor.
  • Capturing sequences of frames according to the TRACK file.
  • Background alpha masking.
  • Support for increased color precision (16-bit per channel).
  • Scene warmup before capturing.
  • Support for professional EXR format, in addition to TGA, JPG, PNG, PSD.

The tool is available only for the Professional and Sim editions.

SDK Browser

License Management

SDK Browser is now managing licenses for the current machine: in order to use UnigineEditor or debug builds of the engine, it is required to keep the SDK Browser launched. Release builds of the engine does not require connection to the SDK Browser.

If you do not have a stable internet connection, SDK Browser can work in offline mode. In this case you will need to perform offline license activation (required only once per machine): go to Options -> Manage licenses and follow on-screen instructions.

Projects Upgrade

Now it is easy to upgrade your project content to the newest version right in the SDK Browser by pressing the Upgrade available button. A backup copy of your project will be created before the upgrade process and, a migration report will be opened in your browser at the end of the process.

Automatic upgrade is available for:

  • Materials and material libraries
  • Objects: decals, terrains, light sources
  • Meshes and animation

Migration of your code should be done manually.

Other Changes

  • More robust work with unstable internet connections.
  • Added ability to choose CDN locations (Netherlands or China) at login.
  • Added access to offline documentation (Knowledge -> Offline Docs). It is a snapshot of online documentation in CHM format.
  • Added ability to run samples with UnigineEditor (the Edit Content button).
  • Removed creating of x86 version projects on Mac and Linux.
  • Added ability to install SDK to folders with the non-Latin names.
  • Faster installation of downloaded components.
  • Fixed import of relocated to another folder projects.
  • A lot of minor bugfixes.

Known issue: El Capitan (Mac OS X 10.11) is not supported at the moment (update will be available shortly).

Improved VFX Library

A new VFX add-on (instead of the older SFX one) contains several ready-to-use effects (based on particle systems):

  • Fire
  • Explosions
  • Gun shots
  • Smoke
  • Jet engine
  • Dust
  • Rocket launch

Other Changes

  • 32-bit Mac OS X is no longer supported (all of the recent releases are 64-bit already).
  • Upgraded GLAppSDL embedding sample, now it works with the SDL version 2.0.1 and higher.
  • Fixed setting of PlayerPersecutor targets.
  • Improved error messages display on Windows.
  • Upgraded AMD Display Library (ADL) SDK to the 8.0 version.
  • Fixed sound gain reduction for repeating sounds.
  • Fixed engine build on Linux with the x86 binaries for AMD Catalyst 15.5.
  • Fixed particles each frame re-rendering after setting the setEnabled() parameter in Tracker.
  • Fixed Tracker crash after adding the Animation parameter of ObjectMeshSkinned.
  • Added the libarchive into the set of "extern" libraries.
  • The zlib compression library upgraded to the 1.2.8 version.
  • Added the _f, _met and _alb postfixes for the fiber (microfiber), metalness and albedo textures. They should be used both in projects when creating textures and in the ImageDDS tool.
  • Improved error messages on loading incompatible engine plugins.
  • Added the _nrgb postfix for the RGB normal maps to the ImageDDS tool.
  • Added camera_get and camera_set console commands for quick positioning of the game camera. Editor camera is not supported.
  • The Max temperature parameter of the GPUMonitor plugin now shows the maximum temperature value counted from the start of application.
  • Added ability to save textures to the OpenEXR format.


Introduced tags system for quick navigating among engine entities.

Starting from this release, further updates will have 2.x versioning format.

Build: ()