Fully featured editor

All-in-one toolset

Handles everything from asset management, level building, testing to publishing your game.

Easy and intuitive to use

Has a simple drag and drop interface and comes with intuitive level building and editing tools.

Play in editor

Play within the editor, allowing you to test and debug your game. Pause, frame-step, analyze and modify scene while game is running.

Asset hot-reload

Modify external files like meshes, textures and shaders in your favorite tool and the result will be visible in the editor immediately.

Automatic GUI for custom script objects

As programmers create custom script objects automatic GUI for such objects will be created so artists/desigers can easily modify and tweak various properties. This behaviour can be fully customized using the scripting API.

One click build process

Choose a platform, optionally modify a few settings and receive a game executable as output.

Extension API

Editor is completely extensible via a fully featured extension scripting API. Create custom editor windows, inspectors, gizmos, 2D/3D tools or automate common tasks easily.

Modern C++14 core

High quality design

Built from the ground up using modern C++14 code and design principles, with clean API and architecture.

High performance

Built with modern CPUs in mind with multi-threaded rendering, physics, audio and animation. Optimized with built-in CPU, GPU and memory profiling.

Designed to be extensibile

Layered, modular and plugin-based design ensures the core is easy to understand and simple to extend and modify. This ensures you may easily tweak it for the needs of your game, and that the core provides a powerful foundation to build new features on.

Low-level framework API

A complete low level API is provided for those that do not wish to use the high level editor/scripting runtime, allowing developers to write software directly on top of the C++ core.

Complete source code access

Entirety of engine source code is available to use and modify so you can truly customize it for your exact needs.

Fully documented

Every non-trivial class and method from lowest to highest layer is documented, and this includes even low level engine internals. Core systems and low level operations are also accompanied by manuals ensuring developers can learn how to modify even the deepest parts of the engine.



Set up colliders to define physical object boundaries. Support for box, sphere, capsule, convex mesh and triangle mesh colliders.


Set up triggers that report events when other physical objects interact with them to create complex gameplay funcionality.


Define volumes, set up mass, inertia tensors, drag resistance and other properties to create a dynamic object governed by custom physical forces or gravity.


Set up a variety of joints that constrain object motion relative to each other or to a fixed point. Supported for fixed, distance, hinge, spherical, slider and D6 joints for complete control. Create door hinges, springs, drives and similar.

Physics materials

Set up physics materials and attach them to surfaces to control properties like drag and restitution (bounciness).

Scene queries

Scripting and low-level interfaces for performing scene queries are provided. Test for ray/sphere/box casts, sweeps and perform overlap tests.

Collision filtering

Use simple to set up layers to control which physics objects can interact with each other. Use the same layers to control query and trigger events.

Discrete and continuous collision detection

Choose on a per-object level whether to use the more traditional discrete collision detection, or the more precise continuous collision detection that's particularily useful for fast moving objects.

High performance

Proven high performance PhysX code running on multiple threads along with gameplay and rendering.


Plugin based interface allow the physics system to support other middle-ware solutions without requiring changes to higher engine layers.


Skeletal animation

Skeletal animation with skinning, supporting 1D/2D and user-defined blending and additive animations.

Morph shapes

Use morph (blend) shape animation for high quality per-vertex animation. Create custom curves to control blending and import existing curves.

Animate anything

Use the built-in animation curve editor to animate any generic script field. Use this to create cinematic camera paths, curves for character movement and more.

Root motion

Extract animation of the root bone and use it for character movement in order to ensure it is perfectly synchronized with animation.

IK post-processing

Skeleton bones can be manipulated using the C++ or scripting APIs, allowing you to manually control them for inverse kinematics, physics simulation or similar purposes.

Animation events

Set up and trigger events at certain points in the animation. Events automatically trigger relevant script code allowing you to react to animation in various ways.


Attach scene objects to skeleton bones in order to animate them together with the bone.

High performance

Animation runs on separate threads in order to minimize impact on gameplay and rendering threads. It is GPU accelerated, supports curve evaluation cache, culling and keyframe reduction in order to ensure best performance.


Entity-component system

Modern system for assembling game objects using components and scene objects (entities).


Reusable pieces of game levels that make building complex game worlds easy, allow easy loading of pieces of the game world, and reduce conflicts when multiple people are working on the same level.


Instantiate prefabs in levels and they will automatically be updated when the source prefab changes. Instance specific customization is also supported, without breaking the link to the source prefab. Use this functionality to easily maintain complex levels.

Level hierarchy

Nest prefabs within each other to create complex level hierarchies. Use this to break up large levels into smaller pieces, which themselves can be made out of even smaller pieces.

Asset pipeline

Popular file format support
Built-in support for the following formats:
Mesh/animation: .FBX, .OBJ, .DAE
Texture: .PNG, .PSD, .BMP, .JPG, .GIF, .TIFF, .DDS
Audio: .OGG, .WAV, .FLAC, .MP3
Fonts: .OTF, .TTF
Shaders: HLSL, GLSL
Asynchronous resource loading

Load resources in the background without disturbing the gameplay in order to create large open worlds with no loading screens.


Easily create your own asset importers for other file formats using the plugin based importer interface.

C# scripting

C# 6.0

Modern, proven language that can handle complex software. Full access to the .NET framework and a variety of existing third party managed libraries.

High-level API

Complete high level API allows you to build a game without touching the C++ core. Unlike many other engines it is not just a translation layer for existing low level C++ API, but is instead a separate higher level API that focuses on being intuitive, easy to use and fast to code with.

Low overhead

Scripting runtime has been integrated directly into the engine to avoid any unnecessary data-marshalling costs and to minimize cross language call costs.

Fast in-editor compilation

Simply modify a script and the editor will automatically detect your changes and refresh the runtime transparently. This allows you to test your changes literally seconds after making them.

Visual Studio integration

The editor integrates with Visual Studio allowing you to easily move back and forth between the two while coding and testing.

Automatic serialization

No need to write serialization code for custom scripts objects. Create custom components or even custom resources and have them automatically be serialized/deserialized with no additional effort. Even complex types like arrays, lists, dictionaries and game-object and resource references are handled.

Extensive documentation

Both the normal and extension scripting API come with a complete API documentation, and are accompanied with manuals explaining the most common use cases.


Many built-in controls

Text, button, toggle, input box, drop down, slider, scroll area and dozens more built-in GUI controls ready for use.

Layout based system

Use the easy to use layouts to automatically position GUI elements so they look good at any aspect ratio, or position them manually for precise control.


Fully control and change the look of every GUI component.


Easily create fully custom GUI controls. Create custom GUI materials, have full control over rendering and input handling.

High performance

Automatic GUI element batching with support for texture atlases ensures minimal performance impact.

3D transformable

Apply arbitrary 3D transformations to GUI elements in order to present GUI on off-screen surfaces.

Localization ready

Unicode text rendering and input, with localization support via string tables.


Physically based rendering (Coming soon)

Tiled deferred/forward+ renderer hybrid using physically based shaders with support for reflection probes ensure modern high fidelity graphics.

HDR and gamma correct

Scenes are rendered in high dynamic range with support for filmic tonemapping, automatic exposure and white balancing. Entire workflow is gamma correct to ensure high quality results.

DirectX 11, OpenGL 4.5 and Vulkan support

Multiple render API support with implementations for DirectX 11, OpenGL 4.4 and Vulkan. Extensible to others via a fully transparent plugin interface.

Multi-threaded rendering

Performing rendering on a completely separate thread yields a massive performance increase compared to single-threaded rendering by leaving a lot more room to run the gameplay code on.


Support for various post-processing effects like SSAO, depth of field, FXAA, color grading and more. Customizable system that allows new post-processing effects to be added easily.


Supports point, spot and directional lights. Practically unlimited number of lights per scene with little performance impact.

Soft shadows (Coming soon)

Support for soft shadows using cascading shadow maps or per-object shadows.

Expressive shading language

Custom shading language that allows fixed pipeline definitions be provided along with programmable pipeline code. Intuitively handles shader permutations, supports shader inheritance and allows for multiple techniques per material.


Designed as a completely isolated system accessible through a plugin-based interface allows developers to easily customize or completely replace the renderer. A variety of utilities and tools needed for such a process are also provided.


2D and 3D

Traditional 2D audio playback and positionable 3D sounds with support for panning, attenuation and Doppler effect.


Multi-channel support for up to 7.1 sound.


Stream audio files as they are played back for minimal memory impact. Or load them in their entirety for minimal IO performance impact.


Compress audio data into Vorbis format, or store them as raw PCM. Decompress data on load, or on-the-fly as the sound is played back for full control over memory vs. perfomance cost paid.

Multiple listeners

Support for multiple listeners for purposes of local multiplayer.

Two backends

Two separate backend implementations are provided: Use the fully open-source OpenAL or industry battle-tested FMOD.


Implemented using a plugin interface that can be used for adding support for other audio middleware.


Mouse/keyboard/gamepad support

Input support for mouse, keyboard and many popular gamepads.

Raw input

Input values are reported directly from the device with no OS interference like smoothing, for best precision and responsivenes. Optionally OS input is provided separately.

Virtual input

Use the virtual input system to bind key-presses to virtual keys in order to ensure key-binding can be easily changed. Comes with a built-in input configurator for setting up key-bindings.

Virtual axes

Bind analog input devices to virtual axes. Use the virtual axes to support multiple input device types like both mouse and gamepad analog sticks. Customize dead zones and sensitivity.

Multiple device support

Supports reporting of input from multiple devices at once for situations like local multiplayer.