> ## Documentation Index
> Fetch the complete documentation index at: https://docs.eucaengine.com/llms.txt
> Use this file to discover all available pages before exploring further.

# The agent-native game engine

> An ECS-first engine in Rust where agents build, play, and experiment through one typed API — on a deterministic world they can read, change, fork, and replay exactly.

Euca is a game engine built so software agents are first-class. The whole game world is a
**flat, deterministic table** that an agent reads, edits, and forks as plain data — over one
typed HTTP API. No GUI is *required* in the agent loop and there is no hidden object graph: 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. (When you do want one, the same projects open in the
[`euca-studio` visual editor](/concepts/two-faces) to author and play by hand.)

```mermaid theme={null}
flowchart LR
    Agent(["AI agent"]) <-->|"one typed HTTP API"| API
    subgraph engine ["Euca engine · :3917"]
        direction TB
        API["build · play · experiment"]
        API --> World[("World: a flat table of<br/>entities and components")]
        Systems["Systems<br/>physics · rules · combat"] -->|"advance every tick"| World
        World -->|"fork"| Fork[("Fork — isolated copy")]
    end
```

<CardGroup cols={2}>
  <Card title="White-box" icon="eye">
    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.
  </Card>

  <Card title="Exact" icon="crosshairs">
    State is typed and explicit. What you read is the ground truth, not a rendered
    approximation of it.
  </Card>

  <Card title="Deterministic" icon="dice">
    One canonical seeded RNG drives the whole engine. The same seed and the same inputs
    produce the same run — replayable byte for byte.
  </Card>

  <Card title="Forkable" icon="code-branch">
    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.
  </Card>
</CardGroup>

## The agent loop

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

<Steps>
  <Step title="Build">
    Spawn entities, attach typed components, and add rules — the world is assembled from
    data over the API (or, if you prefer, authored by hand in the visual editor).
  </Step>

  <Step title="Play">
    Step the simulation forward and observe the resulting state. Physics, combat, and
    rules all run deterministically on each tick.
  </Step>

  <Step title="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.
  </Step>
</Steps>

<Card title="Quickstart — build, play, and experiment in minutes" icon="rocket" href="/quickstart" horizontal>
  Bring up a local server and run the full agent loop against a real world.
</Card>

## Not an object-graph engine

Unlike Unity or Unreal, Euca doesn't hide the world behind an opaque object graph. 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. (Euca also ships a visual editor — `euca-studio` —
but it's a complement to the data API, not the only way in.)

<Note>
  **Current platforms:** macOS and Linux. Rendering runs on `wgpu` (with a native Metal
  backend) — a real-time **PBR forward renderer** (cascaded shadows, SSAO, HDR + ACES tonemapping).
  See [Engine internals](/concepts/engine-internals) and [Performance](/concepts/performance).
</Note>

<Warning>
  The local, self-hosted server is **unauthenticated by default** — no global gate, so run it in a
  trusted environment, driven by an agent on a machine or network you control. The engine also
  ships **opt-in Ed25519 auth** (install an `AuthStore` → `/auth/login` + per-agent ownership);
  hosted or benchmark access can additionally layer an API key at the hosting tier. See
  [Hosting & deployment](/systems/hosting-deployment).
</Warning>

## 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 is a *use built on
the engine*, documented in [World-model evaluation](/evaluation/overview) — the engine
comes first.