What is Atlas?

Atlas is an open-source powerful and versatile game engine that provides developers with the tools and resources they need to create high-quality games and interactive experiences. It combines a full editor and engine with lower-level libraries for rendering, physics, native platform integration, and scripting.

Design Principles

Modern Graphics First

Atlas is designed around modern rendering techniques rather than preserving decades of backwards compatibility. This does not mean that Atlas is expensive to run nor use, but rather that it is designed to be efficient and performant while still providing developers with the tools they need to create high-quality graphics and visual effects.

Explicit Over Magical

Atlas provides high-level systems without completely obscuring the graphics and engine architecture underneath. This allows developers to have a better understanding of how the engine works and how to optimize their projects for performance and quality.

Modularity

A simple change in an specific framework should not require a complete rebuild of the engine. Atlas is designed to be modular, allowing developers to use the builtin frameworks or replace them with their own implementations. For instance, if you want to use a different physics engine than Bezel Jolt, you can do so without having to modify the rest of the engine or its frameworks.

Desktop platforms

Beta 2 uses Metal on macOS and Vulkan on Windows and Linux. Atlas and Opal share the same rendering abstractions across these backends, while advanced features depend on the active graphics device.

See Opal for backend selection and Photon for global illumination and path-tracing requirements.

And editor, not a DCC

Atlas leaves specialized content creation to specialized tools. The Atlas Editor focuses on assembling, programming, inspecting, debugging, and running games—closer to the experience of a modern IDE than a 3D creation suite.

How does Atlas compare to other engines?

Feature	Atlas	Unity	Unreal Engine	Godot
Open-source	Yes	No	No	Yes
License	MIT	Proprietary	Proprietary	MIT
Primary Language	C++	C#	C++	C++
Scripting Language	Typescript	C#	Blueprint, C++	GDScript, C#
Rendering abstraction	Opal	Internal	Internal	Internal
Graphics backends	Metal, Vulkan	Multiple	DirectX, Vulkan, Metal	Vulkan, OpenGL
Editor included	Yes	Yes	Yes	Yes
Modular engine architecture	Strong focus	Moderate	Moderate	Strong
Complexity of codebase	Moderate	High	High	Moderate
Maturity	Early / Beta	Mature	Mature	Mature
Editor philosophy	IDE-like, focused game development environment	General-purpose game editor	General-purpose game editor	Integrated game development + content creation environment

Rendering and Graphics

Atlas ships with the following graphics features and capabilities:

Physically-based rendering (PBR) with support for metallic-roughness and specular-glossiness workflows
Dynamic Diffuse Global Illumination (DDGI) for real-time indirect lighting
Path tracing and global illumination for realistic lighting in your scenes
Deferred rendering pipeline with support for multiple render targets and post-processing effects
Framebuffer (Render Target) support for custom rendering and post-processing
Support for multiple graphics backends, including Vulkan and Metal
Screenspace Ambient Occlusion (SSAO) for realistic shading and depth perception
Shadow mapping with support for multiple light types and cascaded shadow maps
Fog and volumetric lighting for atmospheric effects
Support for high-dynamic-range (HDR) rendering and tone mapping
Support for multiple texture formats, including compressed textures and texture arrays
Support for multiple mesh formats, including glTF, FBX, and OBJ
Screenspace reflections and refractions for realistic water and reflective surfaces

Scripting and native code

Using C++

Atlas is written in C++ and provides a C++ API that can be used to create custom game logic, systems, and components. The C++ API is designed to be easy to use and understand, while still providing the power and flexibility of C++. Here is an example of creating a debug cube in C++:

#include <atlas/camera.h>
#include <atlas/light.h>
#include <atlas/object.h>
#include <atlas/scene.h>
#include <atlas/units.h>
#include <atlas/window.h>

class MainScene : public Scene {
    CoreObject cube;
    Camera camera;

  public:
    void update(Window& window) override {
        camera.update(window);
    }

    void initialize(Window &window) override {
        camera = Camera();
        camera.setPosition({0, 0, 5});
        camera.lookAt({0, 0, 0});
        window.setCamera(&camera);

        cube = createDebugBox({0.5f, 0.5f, 0.5f});
        cube.setPosition({-1.0f, 0.0f, 0.0f});
        window.addObject(&cube);
    }
}

int main() {
    Window window = Window({.title = "My Window"});
    MainScene scene;
    window.setScene(&scene);
    window.run();
    return 0;
}

Project scripting

The editor workflow uses TypeScript components. C++ remains the native engine API for engine development and custom integrations.

Using the editor and Typescript

Typescript scripting is easier to use and more accessible than C++, while still providing the power and flexibility of a modern programming language. Atlas provides a Typescript API that can be used to create custom game logic, systems, and components.

Who is Atlas for?

Atlas is designed for developers that want to create high-quality games and interactive experiences without the hassle of complex tools or old software. Atlas is for developers that want to focus on creating their games and not on learning how to use a complex engine or editor. Developers that want to create games that look and feel like AAA games, but without the complexity and overhead of traditional game engines. Atlas is for developers that want to create games that are fun, engaging, and immersive.

Project Status

These pages document Beta 2 Lyra. Atlas is still in beta; check rendering and physics on the hardware you intend to support.

Read what is new and follow the first-scene tutorial to get started.

What is Atlas?

On this page