Cerneala

A retained realtime UI framework for .NET applications and complete 2D games.

Cerneala puts traditional application UI and realtime rendering inside the same retained runtime. You can build a calculator out of ordinary controls, or build a game where the game view itself is a control in the UI tree.

It is currently in Developer Preview. The architecture is real, the repository has a large test and verification surface, and a lot of the framework already works. The public experience is still being built, contracts can change, and some areas are much more mature than others.

See the current architecture and its architecture diagram.

Why I built it

I wanted something with the useful retained UI ideas from WPF and Avalonia, but designed for games and other realtime software from the beginning.

Putting a game inside a traditional desktop UI framework usually means working around a system that was built for a different job. Going in the other direction is not much nicer. Game engines often treat application UI as a secondary overlay system with its own rules, lifecycle, and limitations.

I did not want two worlds glued together.

I wanted one application model for windows, controls, layout, input, animation, rendering, HUDs, menus, tools, and the game itself. I also did not want the usual XAML ritual spread across markup, resources, converters, code-behind, and runtime magic.

Cerneala is my attempt to build that framework.

The game is part of the UI

RenderSurface2D is a ContentControl. It participates in the same retained tree and lifecycle as the rest of the interface. Cerneala owns the frame integration, render target, presentation, and graphics state. Your code records the 2D drawing work for the frame.

Because it is a content control, normal Cerneala controls can live over the game surface. A HUD, menu, dialog, editor panel, or debug overlay does not need a separate UI integration layer.

RenderSurface2D gameView = new()
{
    ClearColor = new Color(8, 11, 17),
    Content = new TextBlock
    {
        Text = "Score: 1200"
    }
};

gameView.Draw += (_, frame) =>
{
    frame.DrawSprite(player, playerBounds, Color.White);
};

That control can redraw continuously for a changing game scene, or on demand for static and infrequently changing content.

What lives in Cerneala

Cerneala is bigger than a drawing surface. The repository contains the full path from authoring to native presentation.

Retained UI core

The runtime owns typed state, logical and visual trees, properties, resources, layout, invalidation, retained render caches, input routing, focus, hit testing, commands, and control lifecycle.

The UI is created once. State changes invalidate the work that actually needs to be revisited. An unchanged frame should not rebuild the whole interface just because another frame happened.

Realtime frame scheduling

Relay moves work onto the UI thread and refreshes bindings. The frame scheduler processes invalidation, layout, input, Motion, and rendering as explicit phases instead of hiding the work behind unrelated event loops.

Aspect, Motion, and Prism

These are separate systems with separate jobs:

• Aspect owns tokens, rules, variants, states, and templates.
• Motion owns the root clock, animation graph, animated properties, and layout motion.
• Prism owns local visual composition, filters, styles, blending, masks, and backdrop effects without pretending that a visual effect changed layout or input.

Typed authoring

Cerneala supports code-first UI and .crn markup. The markup is intentionally constrained. It goes through the Cerneala language tooling and source generator, which produce a typed C# UI tree.

Markup is allowed. Recreating the entire XAML language and all of its ceremony is not the goal.

The repository also contains a language server, Visual Studio integration, diagnostics, completion, navigation, formatting, and preview infrastructure for .crn files.

Backend-independent drawing

UI and application code record drawing intent through DrawingContext and DrawCommandList. IDrawingBackend owns the backend boundary.

SDL3 + SDL_GPU is the sole maintained desktop backend. The drawing and source-generator contracts remain backend-neutral.

The SDL3 GPU path uses Cerberus, Cerneala's GPU renderer for geometry and state batching, index rebasing, GPU uploads, and indexed draws.

The MonoGame and WindowsDX adapters have been removed, including their public configuration entry points. There is no compatibility facade or fallback. Verification results and unresolved blockers are recorded in the migration audit.

Control inventory

This is the current public control surface, not a promise of WPF or Avalonia parity. "Available" means that a public type exists in the repository today. It does not mean that every familiar API or platform scenario is complete. "Not implemented yet" means that Cerneala does not currently expose that common control as a public type. It is not automatically a roadmap commitment.

This is the beginning of the README. Read the rest at the original. Read the full README ↗