Vision
An engine designed around the AI's loop
Open Terrain Engine is being built so an agent can author a complete, shippable desktop game in idiomatic C# — and verify it the way a careful engineer would.
The problem
LLM agents can't build real games today — not for lack of intelligence, but because they're missing two senses. Editor-based engines hide the game behind a GUI the agent can't drive. Code-only engines let the agent write rendering code but leave it blind: it can't see the result or test whether the jump feels right.
The thesis
An AI-native engine is built around a closed author → introspect → verify loop. Everything is text and code, the world is introspectable as structured data, verification is deterministic and headless, and the engine ships its own machine-readable API surface so the agent always knows the full interface.
Determinism is the keystone
Fixed timestep plus seeded RNG makes a game a replayable, assertable simulation. The agent reads back exact state and a screenshot a multimodal model can look at — and that same property unlocks lockstep netcode and replays for free.
Why C# is the wedge
One unified, statically-typed representation with the compiler as a free verifier, mainstream training mass so models are genuinely fluent, and no editor that owns the truth. A developer inherits world-class .NET tooling and can refactor anything the agent wrote.
What it's made of
The determinism spine
Two authoritative sim paths: a fixed-point one (Q32.32) that's bit-identical on every machine for lockstep, and a float one for single-machine games. A Roslyn analyzer firewall guards the fixed-point assembly — and the path is chosen per game, so no genre pays a tax it doesn't need.
The verification contract
An explicit, test-covered MCP API: simulate(seed, frames, inputs), renderFrame, dump_world, save/load, mp_assert_no_desync, and record/run replay. A recorded input log is the bug repro. This is the part we lead with.
Genre-general composition
FPS, third-person, side-scroller/2.5D, top-down, and RTS — each composed from shared primitives. Genre lives in composition, never baked into the core.
Cross-platform lockstep + replays
Bit-identical simulation makes Linux↔Windows lockstep netcode and deterministic replays fall out for free. The same headless runtime used to verify the game is the dedicated-server binary.
Tier-1 PBR rendering
A Vulkan renderer with physically-based materials, cascaded shadows, HDR + tonemapping, bloom, SSAO, TAA, and GPU instancing — plus headless offscreen screenshots for the AI's visual channel. Cross-vendor by construction.
Dual physics
BepuPhysics (float, fast, server-confined) for genuine rigid bodies, and an engine-owned fixed-point movement layer for RTS-scale units — bit-identical where it has to be, fast where it can be.
Hardened asset pipeline
Import → validate → bake to a safe, engine-native format; untrusted importers run out-of-process and the shipped runtime never parses a raw model. Bring your own models, textures, audio, and fonts.
Permissive & secure by construction
A zero-copyleft dependency tree, enforced in CI, so adopting the engine never pulls copyleft into your game. The dedicated server treats every client packet as hostile — authenticated before it's ever deserialized.
Status
Open Terrain Engine is in active development — design complete, implementation under way. The table below is what v1 commits to, framed as a target, plus what's explicitly deferred. It is not a snapshot of what's built today.
| Capability | Status |
|---|---|
| Genre-general core (FPS · 3rd-person · 2.5D · top-down · RTS) | v1 target |
| Fixed-point + float sim paths | v1 target |
| Cross-platform deterministic lockstep | v1 target |
| Dedicated server | v1 target |
| Tier-1 PBR Vulkan rendering | v1 target |
| MCP verification contract | v1 target |
| Save / load + schema evolution | v1 target |
| Asset import + bake pipeline | v1 target |
| Steam on Linux + Windows | v1 target |
| BSL license + SBOM dependency gate | v1 target |
| macOSNear-free to add later via SDL3 — not a launch target. | Roadmap |
| Hardware ray tracing (RTX)Architected to slot in as a Vulkan extension. | Roadmap |
| GUI editorEvery capability is reachable from code + MCP. | Not in v1 |
| Runtime modding / hot-swappable game DLLs | Not in v1 |
| Mobile · console · browser (WebGPU) | Not in v1 |
| Asset marketplace / cloud services | Not in v1 |