Fully featured editor
Handles everything from asset management, level building, testing to publishing your game.
Has a simple drag and drop interface and comes with intuitive level building and editing tools.
Play within the editor, allowing you to test and debug your game. Pause, frame-step, analyze and modify scene while game is running.
Modify external files like meshes, textures and shaders in your favorite tool and the result will be visible in the editor immediately.
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.
Choose a platform, optionally modify a few settings and receive a game executable as output.
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
Built from the ground up using modern C++14 code and design principles, with clean API and architecture.
Built with modern CPUs in mind with multi-threaded rendering, physics, audio and animation. Optimized with built-in CPU, GPU and memory profiling.
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.
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.
Entirety of engine source code is available to use and modify so you can truly customize it for your exact needs.
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.
Set up physics materials and attach them to surfaces to control properties like drag and restitution (bounciness).
Scripting and low-level interfaces for performing scene queries are provided. Test for ray/sphere/box casts, sweeps and perform overlap tests.
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.
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.
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 with skinning, supporting 1D/2D and user-defined blending and additive animations.
Use morph (blend) shape animation for high quality per-vertex animation. Create custom curves to control blending and import existing curves.
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.
Extract animation of the root bone and use it for character movement in order to ensure it is perfectly synchronized with animation.
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.
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.
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.
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.
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.
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.
Modern, proven language that can handle complex software. Full access to the .NET framework and a variety of existing third party managed libraries.
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.
Scripting runtime has been integrated directly into the engine to avoid any unnecessary data-marshalling costs and to minimize cross language call costs.
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.
The editor integrates with Visual Studio allowing you to easily move back and forth between the two while coding and testing.
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.
Both the normal and extension scripting API come with a complete API documentation, and are accompanied with manuals explaining the most common use cases.
Text, button, toggle, input box, drop down, slider, scroll area and dozens more built-in GUI controls ready for use.
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.
Automatic GUI element batching with support for texture atlases ensures minimal performance impact.
Apply arbitrary 3D transformations to GUI elements in order to present GUI on off-screen surfaces.
Unicode text rendering and input, with localization support via string tables.
Tiled deferred/forward+ renderer hybrid using physically based shaders with support for reflection probes ensure modern high fidelity graphics.
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.
Multiple render API support with implementations for DirectX 11, OpenGL 4.4 and Vulkan. Extensible to others via a fully transparent plugin interface.
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.
Support for soft shadows using cascading shadow maps or per-object shadows.
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.
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.
Support for multiple listeners for purposes of local multiplayer.
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.
Input support for mouse, keyboard and many popular gamepads.
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.
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.
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.
Supports reporting of input from multiple devices at once for situations like local multiplayer.