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.
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.
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.
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.
What it draws
Every one of these is a page in the gallery app, running on a real machine. Follow one to read what it does and why.

Gaussian splats
Captures from .ply, .spz and .osplat, lit to sit in a scene.

Physically based materials
Filament’s material model, and a tone mapper that behaves like a camera.

A sky that moves
A sun on a clock. The sky and the lighting follow it.

Volumetric light
Light you can see the shape of, through whatever is standing in it.

Irradiance fields
Bounced light sampled through a volume, rather than faked per object.

Cascaded shadows
One sun, four cascades: sharp up close and cheap in the distance.

Somebody else’s models
glTF, with FBX and OBJ converted on the way in. Clips, skins, variants.

2D, in layers
Sprites, atlas packing, parallax and tile maps, in the same scene.

A world to walk around
A block game, built from the same pieces as everything else.

Decals
Marks projected onto whatever is already there.

Selection outlines
Including the outline of whatever is hidden behind something else.

Motion blur
Per object, from motion the renderer already knows about.
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.
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 DiscordStar 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