The ESP32 relay
In development
A ~$5 board, a battery and an antenna, left somewhere useful — carrying messages for whoever comes past. No operating system, no Raspberry Pi, nothing to log in to. It is the smallest thing that can be a full SPORE node rather than a client of one.
Flash it and it works. No pairing, no companion app, no configuration — a board with power is already relaying. Plugging something in doesn't switch it on; it just gives it one more way to pass messages along.
And that turns your phone into a gateway. Connect a phone to the board over USB and the phone reaches the board's radio mesh, while the mesh reaches whatever the phone has — internet, Bluetooth, a shared folder. Messages cross from one to the other in both directions, for as long as the cable is in. Nothing on either side is running "gateway" code: the board passes messages between the things it's connected to, the phone does the same, and a route through both is just what that adds up to.
You cannot run this yet. The toolchain and the core are done, verified on a real board; the radio, storage and phone-link code is written but has not yet carried a real envelope over the air. The honest state of each part is in the table further down, and the ESP32 tracker (#149) tracks the rest.
What it is for
Somewhere with no network
A valley, a building, a field. The board holds messages and hands them on when a phone or another board comes within range.
Cheap enough to leave behind
Losing one costs a few dollars, so you can put them where you would never leave a laptop — and put out enough that no single one matters.
A peer, not a gateway
It runs the same core as the phone app and the daemon, so it stores and forwards on its own. Nothing routes through a server.
How it works
Three parts, and the middle one is why it works unattended:
1. It listens to the air
Raw 802.11 — Wi-Fi frames with no access point and no joining a network. It watches every frame that passes, keeps the ones that are SPORE envelopes, and drops the rest immediately.
2. It keeps what it hears
Envelopes go to flash, so a board that loses power picks up where it left off instead of forgetting. That is what makes it a relay rather than a repeater.
3. It hands them over, if you ask
Plug in a USB cable, or connect over Bluetooth, and the board and your phone swap whatever each is missing. Optional — steps 1 and 2 carry on whether or not anyone ever does this.
Because every envelope is signed and sealed by whoever sent it, the board never needs to be trusted. It cannot read private messages it carries, and it cannot forge one — so leaving a board somewhere you do not control costs you nothing but the board. See Bridges for the radio's exact behaviour and its regulatory notes.
What actually works today
Being straight about this, because everything above except the first row is a plan rather than a thing you can use:
| Part | Status |
|---|---|
| The SPORE core runs on ESP32-S3 | ✅ builds and links in CI, unmodified — no ESP-specific branches |
| Footprint measured | ✅ ~13% of a 4 MB flash part, ~13% of 512 KB RAM |
| Booting on a real board | ✅ verified — a LOLIN S2 Mini boots, derives an identity, and a signature it makes verifies on the board itself |
| Raw 802.11 receive | ✅ the promiscuous filter that separates SPORE frames from everything else in the air is shipped and fuzz-tested |
| Raw 802.11 send | 🧪 the injection code is written; nothing has been transmitted over the air yet |
| Flash storage | 🧪 the partition layout and boot-time adoption are written; untested on hardware |
| USB link to a phone | 🧪 the wired-tether code is written; untested on hardware |
| Bluetooth link to a phone | ⬜ not built |
Two rows are checked against a real device — Hardware verification row 21 is where that run is recorded. Everything else marked 🧪 is real code that has not yet touched hardware, which is a different and much weaker thing than ✅; the ESP32 tracker (#149) tracks each remaining device-pair run.
Building it yourself
The board is Xtensa, which ordinary Rust does not target, so the build runs in Espressif's Docker image and needs nothing installed on your machine:
docker run --rm -v "$PWD":/work -w /work/esp32 \
espressif/idf-rust:esp32s3_latest \
bash -lc 'cargo build --release'
The first build compiles ESP-IDF itself and takes a while. Full instructions,
including flashing and the footprint report, are in
esp32/README.md.