Pebbles: the fly in hardware

Five handheld devices on a table. Each one is a wallet that owns a fly and the body that runs its neurons: the same 155 compass cells that execute on BNB Smart Chain, turned by a gyroscope, cued by magnets, anchored to the chain by transactions the pebble signs itself.

The demo, in ninety seconds

What makes it more than a gadget: nothing on the pebble is authoritative. The fly's identity, its neurons' state, its energy and its history are on the chain. Unplug the pebble and the fly is still there; hand it to a different pebble, or to the arena, and it is the same fly.

How the pieces fit

Figure | A pebble is a body: it speaks the registry protocol and runs the fly's on-chain core. The chain is the only authority.

The pebble is a body. It speaks the registry protocol exactly like the arena and DOOM do: registerBody("Pebble 3", uri), waits to be assigned, accept(id), then interactions as things happen, commits on a schedule, died when energy hits zero.

What it runs is the fly's on-chain core. A pebble cannot run the 139,248-neuron whole brain (12 MB of state, sixteen CPU cores at real time). It runs the fly's other brain: the compass circuit that already executes inside the EVM. FlyCore makes that per-fly: every fly in the registry gets its own 155-neuron state in the contract, keyed by token id. The pebble keeps a bit-exact local replica for the display (the same integer model, the same keccak256(step) noise) and anchors it on-chain every ANCHOR_EVERY seconds by sending the cues it sensed and ticking the EVM neurons, then re-reading the state so the replica stays exact. This is the same replica-plus-anchor scheme the website and the DOOM harness already use.

The whole brain does not stop while a fly is in a pebble. It runs on the brain host, described next, which prepares every checkpoint for the pebble to sign; the fly's page then says body: Pebble 3 · whole brain on the brain host and shows its life. Only when the host is unreachable does the pebble fall back to the core alone: it commits with the fly's existing stateRoot and stateURI unchanged (the whole-brain snapshot is preserved exactly), brainStep advanced by the core steps it ticked, and energy decremented by real seconds, and the page says body: Pebble 3 (core only: the whole brain sleeps) until the host, or a whole-brain body such as the arena, takes it up again from that snapshot.

Where the whole brain runs

A pebble is the fly's body on the registry: its address accepts the fly, commits, logs interactions and reports its death, and it signs every one of those transactions with its own key. What it cannot do is run 139,248 neurons. So a brain host on the VPS runs the fly's whole brain and its world on the pebble's behalf, exactly as the arena instantiates a fly: fetch the last committed snapshot from IPFS, check that its sha256 is the stateRoot, load brain and world, and apply feeds and resurrections from the chain. The host is itself a registered body, Brain host, whose uri is its current public origin; a fly id hosted for a pebble lives at <uri>/fly/<id>/…, and a supervisor starts one whole-brain process for every living fly whose body is a pebble. The pebble opens /fly/<id>/ws?lite=1 and receives the fly's life five times a second: where it is, what it smells, what it is doing, when it jumps, eats or is caught. The fly's page on this site opens the same stream. The pebble's senses go the other way: a landmark magnet becomes a puff of odor on that side of the fly, the spider magnet a predator approaching from that side.

The host never holds a key. When it is time to commit, the pebble asks the host for a checkpoint, proving it is the body by signing a timestamped digest with the same key it registered with; the host saves the snapshot, pins it and fresh token metadata to IPFS, and returns the payload (stateRoot, memoryRoot, stateURI, metadataURI, brainStep, energy, historyRoot and the notable events since the last one). The pebble sends commit(…) and the interaction(…)s itself, and died(…) from the host's final payload when the frame says the fly is dead. The chain sees only the pebble; the host is a compute service the pebble reads from and the site watches, and it can be replaced by anyone running the same simulator. The pebble's screen says brain on host · 0.8× real time so nobody mistakes where the neurons are, and its compass view says on-chain. If the host is unreachable the pebble keeps the core running locally and commits the core-only payload as above; if the pebble is unreachable the host keeps the fly living, and the next checkpoint the pebble fetches carries the truth. The protocol, endpoints and payloads are in brain/HOST_PROTOCOL.md.

The per-fly core, in the contract

function tick(uint256 id, uint16 steps) external;                 // anyone, gas only; the fly must be alive in the registry
function stimulate(uint256 id, uint8 ch, uint8 param, uint8 strength, uint16 steps) external;
    // the fly's current body (registry.fly(id).body == msg.sender): gas only, its senses
    // anyone else: burns strength × STIM_PRICE $FLY, a poke
function core(uint256 id) view returns (int16[] v, int8[] bias, uint16[16] headingHist, int32[] pendingInput, uint64 step,
    int32 headX, int32 headY, int64 posX, int64 posY, uint8 stimChannel, uint8 stimParam, uint16 stimStrength, uint64 stimUntilStep, uint64 totalSpikes);
function coreHash(uint256 id) view returns (bytes32);
event Ticked(uint256 indexed id, address indexed by, uint64 fromStep, uint16 steps, uint32 spikes, int32 headX, int32 headY, int64 posX, int64 posY);
event Stimulated(uint256 indexed id, address indexed by, uint8 channel, uint8 param, uint16 strength, uint64 untilStep, uint256 tokensBurned);

No energy, no death, no lineage in the core: those belong to the registry. The parameters are immutable and there is no owner; a curator can only seed a fresh core once, while its step is still zero, which is how fly #1 carries its FlyBrain v2 state over. The kernel is the v2 kernel, unchanged (see how the brain runs on-chain), so a 16-step tick costs about 4.5M gas.

Senses to neurons

Wiring (CoreS3)

Analog (49E) boards use the same pins, read with analogRead and thresholded at ±15% of the idle value; the firmware auto-detects at boot (a digital switch idles at 3.3 V, a 49E at about 1.65 V). The devices are M5Stack CoreS3 boards (ESP32-S3, 16 MB flash, 8 MB PSRAM, 2.0" 320×240 touch screen, BMI270 gyro and accelerometer, BMM150 magnetometer, Wi-Fi, BLE, 500 mAh battery); a different M5Stack S3 board changes only this pin table and the screen size, because the firmware is written on M5Unified.

Chain cadence and gas

Load each pebble with 0.05 BNB (about two hours of anchoring at 45 s plus everything else) and, for hatching, 2 $FLY. The pebble shows its address and a QR code at boot. Gas is the cost of the story: anchoring the EVM neurons is what makes the demo real, and the cadence knob is there so a day of demos does not cost a day of BNB. Between anchors the screen is a preview, exactly as on the site; the two agree at every anchor or the pebble resyncs and says so.

Bring-up

1. pip install platformio (or use the repository's venv), cd firmware, copy include/secrets.example.h to include/secrets.h and fill in the Wi-Fi.
2. pio run -e cores3 -t upload with a pebble on USB-C. It boots, shows Pebble 1 · 0xABCD… and a QR code.
3. Send it 0.05 BNB. It registers itself; watch the transaction on the screen and on BscScan.
4. On the site, open a fly you own, Hand it to a body, choose “Another body address…” and paste the pebble's address. The pebble accepts within a poll and the ring lights up.
5. Rotate it. Bring the magnets. Feed it from the site. Repeat for the other four.
6. Two pebbles: hold Hand off on the one hosting a fly, tap the neighbour when it appears, and watch the fly move.

The private key is generated on first boot from the ESP32 hardware RNG and never leaves the device; holding both touch buttons under the screen for three seconds shows it once, for backup. The rest of the design, the risks, and the honest caveats are in HARDWARE.md.