Introduction

Limina is an agent-native, high-performance real-time 3D engine. It ships as a single native binary, and LLM agents are first-class citizens: they build scenes and live inside them through a typed, permission-checked, fully traced skill surface.

The whole engine is one process — a Rust host embedding V8, driving WebGPU through Three.js, with native physics, spatial queries, and audio on the hot paths — running on a fixed-timestep loop. There is no separate renderer service, no game-server sidecar, no scripting daemon. One binary boots the world, opens a window (or runs headless), and exposes an MCP surface that external agents connect to.

One binary, one stack

Every layer lives in the same process. Agents call skills; skills mutate the ECS; native physics/spatial ops advance the simulation in place over zero-copy data; the renderer reads that same data and presents a frame.

┌──────────────────────────────────────────────────────────────┐
│  Agents & skills                                             │
│  Agent Builders (over MCP) · Agent Players (in-world)        │
│  45 typed, permission-checked, traced skills                 │
├──────────────────────────────────────────────────────────────┤
│  Rendering                                                   │
│  Three.js (WebGPURenderer) → WebGPU (deno_webgpu)            │
├──────────────────────────────────────────────────────────────┤
│  Simulation                                                  │
│  bitECS — SoA TypedArrays · fixed-timestep loop (60 steps/s) │
├──────────────────────────────────────────────────────────────┤
│  Native hot paths                                            │
│  Rapier3D physics · rayon spatial/ECS ops · rodio audio      │
├──────────────────────────────────────────────────────────────┤
│  Host                                                        │
│  Rust embedder + V8 (deno_core) — the single `limina` binary │
└──────────────────────────────────────────────────────────────┘

Data flows down and back up every tick: agents and authoring code call skills at the top, the simulation and native subsystems advance the world’s Structure-of-Arrays (SoA) state in the middle, and the renderer reads that state to present a frame — with no serialization between the layers. See Architecture & stack for the crate-by-crate breakdown.

Two kinds of agents

Limina treats agents as participants, not plugins. There are two kinds, and both speak the same skill vocabulary.

Kind	Where it runs	How it acts	Typical profile
Agent Builder	External process, connected over MCP	Constructs and edits the world: create entities, set transforms/materials/lighting, load glTF	`builder.readWrite`
Agent Player	In-world, on the engine’s loop	Runs perceive → decide → act, inhabiting an entity and moving it via physics/locomotion	`player.limited`, `social.actor`

A Builder discovers tools over the MCP interface and calls them remotely; a Player runs its perception → decision → action cycle inside the engine, with its (slow, async) model decisions resolved off the frame loop so a slow model never drops a frame. Either way, every call is the same typed, permissioned, traced skill invocation. See Building agents and the agent ecosystem pillar.

Standing principles

Two principles are load-bearing — they decide architectural tradeoffs across the engine.

Where to go next

Getting started — prerequisites, build, and your first demo.
Architecture & stack — the full layered stack, crate by crate.
Skills reference — the 45 typed skills agents and authors call.
For agents ↗ — the agent-oriented entry point into Limina.