Agent-native real-time 3D engine
Agents build the world.
Then they live in it.
Limina is a real-time 3D engine where LLM agents are first-class. Externalbuilders construct scenes over MCP; autonomousplayers perceive, decide, and act inside them — every action typed, permission-checked, and traced.
- Rust
- V8
- WebGPU
- Three.js
- Rapier
- bitECS
- 200agentslive in one instance — with 256 dynamic bodies + 2,000 entities
- 4mssim-step p95 at that density (8 ms budget)
- 60steps/sfixed-timestep loop — deterministic & replayable
- 4.5–5.4×fasternative rayon spatial query vs. the JS oracle
- 11msp95 authoritative multi-client sync
- 45skillstyped, versioned, permissioned — across 11 domains
Figures from the Phase 3 density capstone and Phase 4 sync tests — see the roadmap.
The idea
A skill call — now a world an agent can shape.
External LLM builders connect over MCP and compose scenes by calling typed skills. Autonomous players live in the same ECS world, running a perceive → decide → act loop. Both reach the world through one surface — and every call is type-checked, permission-gated, and traced.
The engine is the substrate, not the brain. Limina owns the world, perception, the skill / MCP surface, and a durable event log. The decision-maker and its memory stay pluggable — bring any LLM, any memory backend, or none.
How agents work
Perceive. Decide. Act.
Every in-world agent runs the same loop on the engine’s fixed timestep. The world stays deterministic; the thinking happens asynchronously, off the frame path.
- 01
Perceive
Each tick, an agent receives a typed view of nearby entities, transforms, and recent events — computed by a native, rayon-parallel spatial query, not a JS scan.
- 02
Decide
A pluggable LLM provider — scripted, local Ollama, or a cloud gateway — selects the next skill call. Thinking runs off the frame loop, so a slow model never drops a frame.
- 03
Act
The chosen call goes through the same permissioned skill surface as everyone else, mutates the ECS world, and emits a typed, sha256-chained event into the world log.
Agent Builders
external · over MCPAny MCP client — Claude, a custom agent, your IDE — discovers Limina’s typed tools via listTools and constructs a scene: create entities, set transforms and materials, load glTF, place lights. Permission-checked, every call traced.
Learn more →Agent Players
in-world · autonomousSpawn entities that are themselves agents. They perceive the world, decide with any LLM off the loop, and act through the same skills — chasing targets, conversing, navigating — alongside everything else in the simulation.
Learn more →Architecture
One native binary. Top to bottom.
No browser, no Electron. A Rust host boots V8, drives a WebGPU surface and a deterministic loop, and pushes the heavy work into native code — all shipped as a single executable.
- Agent & skill layerRegistry · MCP · perception · systemsTypeScript
- RendererThree.js on a native WebGPU surfacedeno_webgpu · wgpu
- SimulationbitECS components in SoA TypedArraysfixed-timestep loop
- Native hot pathsRapier physics · rayon spatial · audioRust #[op2]
- Host runtimeRust embeds V8 and owns the loop, window & opsdeno_core
Native where it counts
Physics, spatial queries, and ECS hot loops run in Rust over zero-copy buffers. JS is the authoring and agent layer — never the inner loop.
Off-loop cognition
Agent LLM calls resolve between frames through an action queue. The fixed timestep never blocks on a model, so the sim stays smooth.
Data-oriented by default
Components live in SoA TypedArrays on ArrayBuffers; the very same bytes back the native systems with no serialization or copy.
Capabilities
Four pillars, fully built.
The agent-native core is not a sketch — it shipped, was reviewed, and is verified end-to-end. Each pillar has its own reference in the docs.
Skill / Hook Registry
A typed, versioned, permissioned registry of everything an agent can do, with before/after hooks and an ExecutionContext carrying identity and permissions.
MCP interface
listTools / callTool over the same registry — in-process, stdio, or websocket. Inputs validated against JSON Schema; denials and errors are first-class.
Observability
Every call emits a typed, EventLoom-shaped event into a sha256-chained world log — replayable, exportable as JSONL, and durable across crashes.
Agent ecosystem
AgentComponent plus Perception, Decision, and Action systems turn entities into builders and players — LLM-agnostic and scheduled off the frame loop.
- Spatial 3D audio
- In-world text & UI
- Durable world log + replay
- Authoritative multiplayer
- Interest management
- QuickJS isolation
- Dynamic policy engine
- Versioned packages + attestation
- Native rayon spatial query
- Textured glTF + shadows
- Humanoid locomotion
- Snapshot recovery
Gallery
Real frames from the engine.
Captured from windowed demo runs — the same renderer, scenes, and agent systems described throughout these docs.
For agents
Docs your agents can read too.
This is the SDK reference and the showcase. It is also machine-first: point an agent at a stable URL and it gets the whole surface as structured data — no HTML scraping.
llms.txtA concise, LLM-readable index of the whole site.llms-full.txtEvery doc page concatenated into one plain-text file.skills.jsonAll 45 skills as JSON Schema — names, inputs, permissions.MCP quickstartPoint a client at --mcp-stdio or --mcp-ws and start calling.
Hand your agents a world.
Build the engine, run a demo, then connect an agent over MCP — or spawn one that lives inside the world.