📦 Where your data lives

local-first darts — every byte accounted for

The trainer is built local-first: your board plays perfectly with zero internet, forever. The network exists for exactly one reason — the shared detection model that every board helps train and every board gets back. This page shows everything that is stored, where, and why. Numbers are live as of 2026-07-18.

On your board (the Raspberry Pi)

🎯 Every throw — `stats.db`

SQLite on the Pi · the local-first source of truth · works offline forever

Three tables: games (every run: mode, config, players, final metric), throws (every dart), derived (computed stats).
Each throw row carries the full story: score / sector / ring, the exact board position in millimetres, what the model proposed vs what you confirmed, whether you corrected it, the game context it was thrown in (what you were aiming at, points remaining, at-double pressure), plus bounce-out and undo (void) flags — undone throws are voided, never deleted.
This is why per-player heatmaps, grouping spread and zone stats are possible: the board knows every dart's exact landing point, not just its score.

📸 Frames in flight — RAM staging

ramdisk (/dev/shm) · ephemeral · never wears the SD card

Every throw is captured by 3 cameras; each visit keeps a reference picture of the empty board plus one capture per dart.
Frames stage in RAM, upload in the background, then vanish. If the internet is down they spill to the SD card and upload later — gameplay never waits on the network.
A decision log (one JSON line per detection decision, with the numbers that drove it) lives alongside — it is how "why did it do that?" gets answered remotely.

🏆 Boards, players, identity — small JSON stores

on the board, not in the browser

Local leaderboard (highscores.json): the board-scope leaderboard is complete offline — every game mode's best runs, per combo.
Roster (players.json): everyone who played on this board — the same quick-pick list from any device that opens the page.
Groups (groups.json): only a hash of the group passphrase is stored — the passphrase itself never exists on disk, anywhere.
Player identity: an opt-in 12-word phrase derives your key; the key file lives on the board, the words live only in your head/notebook. Losing both is unrecoverable by design — that is what makes it yours.

🧠 The model & calibration

the seeing part

tipnet.onnx: the dart-tip detection model, shipped with the app and updated over the air; the previous version is kept for instant rollback.
Calibration JSONs: per-camera geometry (where the board is in each camera's view). Every throw is stamped with the calibration it was captured under, so recalibrating never poisons old data.
Outbox: the offline-first upload spool — every outbound record (frames, scores, match results) queues here and survives days of no connectivity.

On central (dart-room.com)

One small service holds the shared brain: the training data both boards contribute, the model registry they update from, and the cross-board leaderboards. The darts themselves are tiny — the whole database is 12 MB; it is the camera frames that weigh 13 GB.

Table	Rows	What it holds
`game_throw`	6,464	every uploaded throw: label, model proposal, correction flag, game context, capture timestamp
`capture` / `capture_image`	6,464 / 19,392	the capture sets — 3 camera frames per throw, lossless WebP, content-addressed (SHA-256), stored in the 13 GB blob volume
`highscore` + `highscore_tag`	91 + 9	leaderboard rows with extensible tags (`board:`, `group:`, `variant:`…) — new scopes need no schema change
`elo_rating`	5	the ranked-match ladder (K=32, saved players only)
`player` / `player_identity`	9 / 1	display names · opt-in 12-word key bindings (only the public key is stored — never the words)
`rig` / `rig_token`	3 / 5	enrolled boards and their per-board access tokens (each board holds only its own key; any one can be revoked alone)
`rig_health` / `rig_event`	471 / 14,313	heartbeats + the shipped decision log — a friend's board can be debugged without SSH
`rig_calibration`	28	calibration snapshots — per-throw provenance for training
`model`	16	the published model registry: every trained model with its provenance and metrics — boards pull updates from here
`feedback`	11	in-app bug reports, arriving with screenshot + rig context as evidence
`eval_run` / `eval_result`	0 / 0	reserved: detector-vs-truth evaluation slices

🔐 Access

No user accounts. Boards authenticate with per-board bearer tokens minted at enrollment; players are just names unless they opt into a 12-word identity.
Groups are knowledge, not records: central only ever sees an opaque hash — knowing the passphrase is the membership.
Backups: timestamped database snapshots before every schema-touching deploy.

The flywheel — how a dart becomes a better model

you throw→ 3 cams capture→ model proposes a tip position→ you accept — or tap to correct

↳ scored instantly, stored in stats.db and frames + label queue in the outbox→ central capture store

↳ training pulls the throws — your corrections are the gold (a tap marks exactly where the tip really was)

↳ new model trained & field-tested→ published to the registry→ every board updates over the air

The loop's honest rule: models are judged by field acceptance — how often real players accept proposals untouched at a real board — not by lab metrics alone. A model that aces the test set and annoys players does not ship.

What never leaves your board

Gameplay needs nothing. Scoring, leaderboards, all game modes — fully offline.
Group passphrases — never stored, never transmitted; only their hash.
Your 12 words — never stored anywhere, never transmitted; only the derived public key is bound to your name, and only if you opt in.
What does upload: capture frames + throw labels (to train the shared model), scores for the shared boards, and health/decision telemetry so a broken board can be helped. An upload opt-out switch is on the roadmap — scoring then simply stays on the shipped model.

install · game modes · statistics
dart-room.com — open dart detection, local-first