Skip to main content
Euca is a game engine built for software agents instead of human editors. The whole game world is a flat, deterministic table that an agent reads, edits, and forks as plain data — over one typed HTTP API. There is no hidden object graph and no GUI in the loop: the agent sees the world as it actually is, changes it directly, and gets the exact same world back, byte for byte, every time it replays.

White-box

The world is plain data. Read any entity and its components straight off the table — no object graph to traverse, no reflection tricks to reverse-engineer.

Exact

State is typed and explicit. What you read is the ground truth, not a rendered approximation of it.

Deterministic

One canonical seeded RNG drives the whole engine. The same seed and the same inputs produce the same run — replayable byte for byte.

Forkable

Fork the live world, run a what-if on the copy, diff it against the original, and drop it. The same systems run on the fork as on the main world.

​
The agent loop

Everything an agent does with Euca falls into three verbs, all through the same API:
1

Build

Spawn entities, attach typed components, and add rules — the world is assembled from data, not wired up in an editor.
2

Play

Step the simulation forward and observe the resulting state. Physics, combat, and rules all run deterministically on each tick.
3

Experiment

Fork the world, intervene on the copy, diff the outcome against the original, and discard it — counterfactuals with no effect on the real run.

Quickstart — build, play, and experiment in minutes

Bring up a local server and run the full agent loop against a real world.

​
Not an object-graph engine

Unlike Unity or Unreal, Euca doesn’t hide the world behind an object graph and a GUI. The engine is an archetype ECS: entities are generational ids, components are typed fields stored in columns, and the agent reads and writes them as a table. Rules are data too — a Rule { when, do } is an inspectable, serializable value, not a compiled callback. That is what makes the world legible to an agent: every part of it can be read, edited, diffed, and shipped as plain data.
Current platforms: macOS and Linux. Rendering runs on wgpu (with a native Metal backend) using a Forward+ PBR pipeline.
The local, self-hosted server is unauthenticated — run it in a trusted environment. It is meant to be driven by an agent on the same machine or network you control. Hosted and benchmark access, where it exists, is gated by a plain API key at the hosting layer, not by the engine.

​
Built for world models

The same properties that make Euca legible to an agent — white-box, exact, deterministic, forkable — also make it an answer key for evaluating world models. Because Euca can report the exact next-step distribution of its own world, it can grade an external model’s predictions against the ground truth. That evaluation track (GTA-Bench) is a use built on the engine, documented in World-model evaluation — the engine comes first.