This is the gentlest on‑ramp into Echo. It assumes you don’t know (or don’t want) programming concepts yet.
It’s written as a spiral: we explain an idea simply, then we loop back later and explain the same idea with a bit more precision.
If you only read one page before clicking around the docs site, read this.
Echo is a way to run a simulation so reliably that:
- you can replay it later and get the exact same result,
- you can prove what happened (and when),
- and multiple computers can stay in sync without “close enough” guesswork.
Imagine a tabletop game with:
- pieces (characters, doors, items, UI widgets, planets, anything),
- connections (“is holding”, “is inside”, “is targeting”, “depends on”),
- and rules (“if X is true, do Y”).
Echo treats the world like a relationship map: what exists, and how things relate.
Time moves forward in steps (“ticks”). Each tick, Echo applies rules in a careful order so the outcome is consistent.
That’s it.
State means “everything that’s true right now”.
Echo models state as:
- a graph: a set of things and the connections between them, and
- attachments: the data that sits on those things (numbers, small payloads, tags).
You can think of the graph as the shape of the world, and attachments as the details.
A tick is one step of time in the simulation.
On every tick:
- Echo looks at the world.
- It asks which rules apply.
- It applies a set of changes.
A rewrite is “change the world’s relationship map in a controlled way”.
Example (informal):
- If a character is holding a key and is near a locked door, the rule might rewrite the world so the door becomes unlocked.
This is why you’ll see the word “WARP” in Echo docs: it’s the name of this graph‑rewrite style of simulation.
Most simulations are approximately the same across machines. Echo aims for exactly the same.
Echo cares because it unlocks things you can’t safely build otherwise:
- Replays that don’t drift: a replay that “mostly matches” is not a replay you can trust.
- Debugging you can believe: “why did this happen?” must have a stable answer.
- Networking without vibes: when machines disagree, you want a clean “desync” signal, not a mystery.
- Verification: tools/peers can validate history.
Echo is intentionally strict about sources of randomness and “it depends” behavior.
Echo uses hashes as a compact fingerprint of the world.
You don’t need to know cryptography to understand the role hashes play here:
- If two worlds are identical, their fingerprints match.
- If anything differs (even a tiny bit), the fingerprints diverge.
This is how tools can quickly answer:
- “Are we still in sync?”
- “Did something change?”
- “Which change caused the divergence?”
Spiral Level 4: Two Planes (The “No Hidden Edges” Idea)
This is a core Echo idea, and it’s worth learning early.
Echo separates the world into:
- Structure: the relationship map (the graph)
- Data: the payload details (attachments)
The key rule is:
If a piece of information affects what rules apply, or whether two rules conflict, it must be visible in the structure (or visible attachment identity), not buried inside opaque bytes.
Echo calls this the “no hidden edges” law.
If you want the formal version, see: /invariants/warp-two-plane-law
- Start Here (recommended paths + how the docs are organized): /guide/start-here
- WARP primer: /guide/warp-primer
- Collision DPO tour: /collision-dpo-tour.html
Runnable browser work currently centers on the Collision DPO tour and the WASM/browser host surfaces. WARP stream wire-schema reference lives at /spec/warp-view-protocol.
This page intentionally avoids implementation terms. If you’re writing or editing docs, try to preserve this gradient:
- this page explains why Echo exists and what it feels like,
- the WARP primer explains the model more precisely,
- the specs define the contractual boundaries.