interaction nets on a mesh of tiles

Each square is a tile of a chip: 8 agent slots around a little router. A wire is not matter but a reference (an address) held by the one reader of a value; messages hop one tile per tick. Everything you see is the live engine, compiled to WebAssembly, the same code the Rust tests check.
LOADING

clock and work

tick0
rewrites0
rewrites / tick (now · avg)0
message hops (per rewrite)0
rewrites in their own tile–
cancelled · shipped direct0
■ rewrites per tick  ■ live agents

memory

live agents (peak)0
indirections · reserved0
messages in flight (peak)0

rules fired

–

messages sent

agents

machine

grid slots per tile speculation router buffer flits events / tick tile queues
how it works

Pull. A consumer that wants a value sends a pull to the address it holds. A producer answers by shipping itself over; an unfinished computation records the reader and starts working.

Fire. When a producer reaches its consumer the rule fires right there: fresh agents take free slots (the dying consumer's own slot first), and anything the rule hands to someone else travels as a message.

No locks. Every value has exactly one reader, so every request about a value comes from one place, and a tile settles races by handling one event at a time.

Demand and drop. Nothing runs until something asks for it. An eraser sends a drop instead: a producer is erased where it stands, and a computation nobody can read any more is cancelled.

Room. When a tile is full, a rewrite docks and follows the free-space field (toggle space) to the nearest tile with enough room. Running out of room is reported, never guessed around.

space play · → step · R restart · F fit · 1–5 layers · drag to pan · wheel to zoom · click a tile to pin it