Quick overview

LODZERO Engine

LODZERO is a new real-time 3D engine and editor. It is small enough to understand, deep enough to build real worlds in, and written in C# from engine code to gameplay. It is being built with LLMs in the loop: not as a gimmick, but as another set of hands for the renderer, editor, tooling, docs, and tests.

IdleRotate.cs

using Engine.CoreMath;

/// Idle rotation for signage, fans, or showcase props.
public sealed class IdleRotate : Component
{
    [Serialize]
    public float DegreesPerSecond { get; set; } = 45f;

    public override void Update(double deltaTime)
    {
        Transform.RotateLocalDegrees(EngineBasis.Up,
            DegreesPerSecond * (float)deltaTime);
    }
}

C#

There is no separate little scripting island. The engine, editor, and gameplay code are all ordinary C#, so game components feel like real software: typed, inspectable, reloadable, and close to the systems they drive.

Forward+ MSAA

The renderer is built around a crisp Forward+ MSAA path. It keeps the image clean, handles busy lighting scenes without giving up on sharp geometry, and has the practical extras you expect when tuning a real scene: depth pre-pass, ambient occlusion, shadows, probes, and specular anti-aliasing.

LODZERO Engine Editor: 3D viewport, built-in C# editor with IdleRotateComponent, log panel, and project code reload notification.

Hot reload

Stay in the scene while the code changes around it. Save a component, let the project rebuild, and the editor can reload your game assembly without throwing away the moment you were testing.

Input

Input is intentionally simple: one clear snapshot each frame for keyboard and mouse, shared by editor and standalone builds. UI, gameplay, and cursor capture all follow the same rules, which keeps small prototypes and serious tools feeling predictable.

Player.Move.cs

/// One snapshot per Update - edge or held keys, mouse delta.
if (Input!.IsKeyPressed(GameKey.Space))
    JumpRequested = true;

var look = Input.MouseDelta;

Lightmaps

Lightmaps give static scenes their settled, handmade feeling. The baker handles direct light, bounced GI, denoising, contact AO, and directional lightmap data so baked surfaces still respond naturally to their normals in the live renderer.

Materials

Materials start with the familiar PBR surface controls you want day to day. When a project needs its own look, focused HLSL hooks let you bend the surface without taking over the whole lighting pipeline.

Materials/ToonRim.Unlit.hlsl

// Unlit path: no BRDF, shadows, or probe loops; full stylistic control.
float4 EvaluateUnlit(UnlitMaterialInput input)
{
    float rim = pow(1.0 - saturate(dot(
        normalize(input.GeometryNormal), input.ViewDir)), 3.0);
    return float4(input.BaseColor + rim * float3(0.2, 0.6, 1.0),
        input.Alpha);
}

HLSL

Shader work belongs in the project, not behind a mystery wall. Write HLSL for lit materials, unlit effects, fullscreen passes, and compute jobs; the engine takes care of turning that into the runtime shader outputs it needs.

Public

jrouwe/JoltPhysics

A multi core friendly rigid body physics and collision detection library. Written in C++. Suitable for games and VR applications.

Jolt physics

Jolt Physics gives the world weight. Rigid bodies, colliders, mesh collision, and character capsules are part of the engine component model, so physics feels like another native piece of the scene instead of a separate demo layer. The engine integrates Jolt through JoltPhysicsSharp.

Animation Graph

Characters move through node-based animation graphs. Import clips, blend poses, tune playback, and let the engine handle the skinning path so animated scenes can grow without turning every character into one-off code.

PlayHud.Quick.cs

/// Quick overlays on the same retained tree as the editor.
_quickUi.Frame(() =>
{
    using (QUI.Window("Play HUD")
        .Align(UIAlign.Start, UIAlign.End)
        .NoInputs())
    {
        QUI.Text($"Health {health}");
        QUI.Muted(objective);
        QUI.Button("Respawn", OnRespawn);
    }
});

QuickUI

QuickUI is for the little interfaces that should be easy: HUDs, debug panels, quick tools, and in-game overlays. It feels immediate, but still rides on the same retained UI system as the editor.

Built-in code editor

The editor can be a place where code actually happens. C# and HLSL buffers, highlighting, completions, diagnostics, and project-aware help make quick iteration possible without constantly leaving the engine.

Public

elalish/manifold

Geometry library for topological robustness.

Modeling & CSG

Sometimes you want to build inside the engine. The CSG tools let you block out, cut, combine, and bake shapes into normal meshes that use the same materials, lighting, and scene tools as imported content. Booleans run on Manifold through ManifoldNET.

Packaging

A game engine should eventually hand you a game. Package Game cooks the project, gathers the runtime data, writes the content archive, publishes the assemblies, and leaves you with a clean folder you can actually run.

Public

KhronosGroup/glTF

glTF – Runtime 3D Asset Delivery.

Content pipeline

The content pipeline keeps authoring friendly and runtime lean. Bring in glTF / GLB assets, keep the editable project data readable, and let cooking turn heavy assets into the runtime format the packaged game wants.