Skip to main content
Euca is one engine — ECS-native, agent-native, written in Rust, white-box. It has two faces, and they are the same coin:
  • As a game engine, it runs worlds. Real ECS simulation, physics, and a forward PBR renderer — a world you build, play, watch, and act in, through one typed HTTP API.
  • As a world engine, it knows worlds. The same ECS state reads out exactly (observe), its next-step odds read analytically (peek), it advances deterministically (step), and it branches counterfactually (fork). It hands you the answer key to the world it’s running.

​
Why they compound rather than conflict

A world engine needs a world to be the truth of. The game-engine face produces the world; the world-engine face exposes its exact truth. They share one ECS substrate and one deterministic core, so the richer, faster, and more convincing the game engine, the richer the worlds the world engine can ground. “Great game engine” and “exact world engine” aren’t a trade-off — they’re two requirements on one artifact. The one thing you must never do is let appearance leak into truth — and the architecture enforces exactly that (see CPU-core / GPU-edge): authoritative state lives on the CPU and is hashed into a state_digest; the GPU is a read-only consumer. Two AI-generated visual skins of the same world produce a byte-identical digest.

​
Which face matters, by use

Resolve the “is it about graphics or about ground truth?” question by use, not by ranking — both faces are first-class.
Using the engine as…The face that mattersWhat it optimizes for
The grader (benchmark, regret, evaluation)World engineExact ground truth, peek == step, determinism, forkability
The environment models live in (experience, training, demos)Game engineRendering, physics richness, performance, world breadth
Two render paths keep them from contaminating each other: an observation path (crisp, deterministic, frame↔tick↔entity-aligned — the data/eval signal) and a presentation path (the full feature set — demos, marketing, editor; never a data source). Both are kept genuinely good; only determinism-breaking effects (TAA accumulation, motion blur) are confined to presentation.

​
The code world model — ruler, not contestant

Under the thesis that the world written as code is the code world model, Euca is the ruler: it writes the world as executable, inspectable code so it can grade every model architecture against the same exact truth. A learned world model (even one that happens to be a program) is just a contestant, scored the same way as a video or latent model. Being code earns it no privilege — only a white-box world can report its own exact next-step distribution, which is why exact evaluation is only possible from the world-as-code side. See Evaluation.

The world-engine API

observe · peek · step · fork — the four verbs of the world-engine face.