Orblit
Star on GitHubJoin the Discord

Pre-alpha

A 3D game engine you write in C#.

Built on Avalonia UI. Game logic and interface in C#. An archetype entity-component core in C++. Google’s Filament does the rendering.

What Orblit isInstall it

Orblit is built in the open. Ask anything in the Discord, and star the repo so more C# developers find it.

Amazon Lumberyard Bistro, drawn by Orblit on an M-series Mac.

The scene is a control

Orblit is built on Avalonia UI. The menus, the inventory and the pause overlay are ordinary Avalonia controls, and so is the 3D view.

The viewport sits in the same visual tree as everything else. It takes part in the same layout, and the same compositor draws it. On macOS the renderer draws into an IOSurface-backed Metal texture that Avalonia imports as it is, with no readback and no copy through the CPU. A panel can overlap the viewport, because it is not a window of its own.

The inventory screen is a StackPanel. It has a headless test.

How the parts divide the work →

class PauseWindow : Window
{
    private readonly RendererViewport _viewport = new();

    public PauseWindow()
    {
        // The pause menu is a StackPanel.
        var menu = new StackPanel
        {
            HorizontalAlignment = HorizontalAlignment.Left,
            VerticalAlignment = VerticalAlignment.Center,
            Children =
            {
                new Button { Content = "Resume" },
                new Button { Content = "Quit" },
            },
        };

        // Whatever comes after the viewport in the children is drawn over it.
        Content = new Grid { Children = { _viewport, menu } };
    }

    private void Draw(double seconds) =>
        _viewport.Frame(new RenderScene
        {
            Camera = new RenderCamera
            {
                Position = new Vector3(0, 3, 8),
                Target = Vector3.Zero(),
            },
            Objects =
            [
                new RenderObject
                {
                    Key = 1,
                    Transform = Matrix4.Identity(),
                    Colour = new Vector3(0.85, 0.42, 0.16),
                },
            ],
        }, seconds);
}

A hundred thousand things at once

The core is an archetype entity-component store written in C++. Entities with the same components sit together, so a system that wants every transform gets them in one run. C# reaches the store over a C ABI, and component data arrives as spans over the store’s own memory rather than a copy. Reading a column costs nothing to translate, and writing to one writes to the store.

You never have to touch it. It is there so that a game which needs to walk a hundred thousand rows can.

Entities and components →

And it makes games

An endless runner, built from the same pieces as everything else on this page: a scene stated each frame, sampled time so the frame rate does not change the simulation, and an autopilot that plays well enough to show the game is fair.

It ships in the gallery app. Clone the examples, run it, and take the keyboard off the autopilot.

Running the examples →

What is here

Rendering
Filament, shown in an Avalonia control
Simulation
Archetype ECS in C++, read from C# as spans
Geometry
Parametric shapes and mesh editing operations
Rigging
Armatures, poses, bone constraints
Interface
One document, built into real Avalonia controls
Scene files
An .oscene document format, with migrations and diffs
Models
glTF, with FBX and OBJ converted on load
Textures
Cooked KTX2 sets chosen per device, lighting from HDR or EXR
Splats
Gaussian splat captures from .ply, .spz and .osplat
2D
Sprites in layers, atlas packing, parallax, tile maps
Agents
Steering behaviours and behaviour trees
Cameras
Shots that say what to frame, and blend between them

Where it actually runs

Orblit is pre-alpha, and that is worth taking seriously before you plan around any of it. The renderer draws on macOS, and CI draws on every change there. Windows and Linux build the C# on every change, but the renderer library has not been built on either, and nobody has seen a frame from C# on a real Windows or Linux machine. If you have one, trying it is one of the most useful things you could do.

There are no consoles, no phone or browser builds, and no marketplace of ready-made assets. They are missing, not promised.

Platform support, in detail →

Come and break it

It is early enough that the first thing you try is probably something nobody has tried yet. Either way, we learn something.

Join the Discord

Ask for help, say where you got stuck, and argue about an API before it sets. Releases are announced there.

Join the Discord

Star Orblit on GitHub

Every line of the engine is there, under MPL-2.0. A star takes one click, and it helps other C# developers find it.

Star on GitHub