What the grid does today
One lane runs end to end right now. The others are built or designed, and this page tells you which is which rather than blurring them together.
Transcription
Drop in a recording. The grid cuts it on the silences into pieces of one to two minutes, hands them to whatever machines are awake, and re-runs a share of them on a second machine to check. You get back one transcript. The audio is deleted from every machine that touched it as soon as the piece is done.
Images, and photos 4× sharper
Built, and measured on this grid in June: batches split across the swarm, big photos cut into tiles, enhanced in parallel and stitched back without visible seams. It is paused, not gone. Every machine here is currently running the audio worker, so image work has nowhere to land until nodes join that want it.
Video, when the grid grows
Designed into the protocol from day one: clips become pieces, and each piece gets the same checks. It is not running yet; video needs bigger cards than the grid has today, so it switches on as nodes join. Until then, this card says next, not now.
Send a job
Drag a recording onto the app window. That's the whole form.
The swarm gets to work
Your job becomes pieces. Idle GPUs pick them up, and a second machine re-runs some of them to check the first.
Get the result
Verified pieces come back together as one transcript, ready to download.
Where this stands: some of what we are building is running today and more is on the way, on machines we own. Seats open a few at a time as the network grows. Request an invite.
Have a graphics card? That is the way in.
Most cards sit idle most of the day. Reshoot gives yours real work: pieces of real jobs, run whole on your card, checked by someone else's machine, and recorded to you. Only work that passes the check ever counts, and that record is what buys you the grid.
One icon, one window
Install one app. It makes a key that is yours alone, and joining is a key, not an application form. Opening the window does not touch your GPU.
Flip the switch
One switch, inside the window. You decide what your computer will and won't run, and when. Pause any time; it stops instantly.
Bring as many machines as you like
One account, many computers, one record. That is deliberate: your contribution is the sum of everything you run, so a second machine adds to your score rather than starting a new one.
Watch real numbers
Pieces delivered, pieces verified, seconds of work recorded, and your tier. All from your own machine, live.
On tiers: contribution moves you through Bronze, Silver, Gold and Diamond, and every rung is computed from the ledger alone. Not from uptime, not from signups, not from how long the app was open. Gold requires a clean record with no failed checks. Diamond requires every one of your machines to have earned trust. Ten people who signed up and ran nothing score nothing, and that is the point of the ladder.
Where this stands: the app is running on our own machines today, and seats go out by invite while the network is small. Ask for one on the start page. One promise holds either way: we will never show you an earnings estimate we haven't measured. When you join, you see real numbers from your own machine, and nothing else.
Chunk
A job arrives: a recording to transcribe, a render batch, one day a video clip (designed in, not running yet). The coordinator splits it into pieces sized for one GPU. Audio is cut where the speaker pauses, never mid-word, into pieces of one to two minutes. That window is measured, not guessed: below thirty seconds accuracy collapses and machines stop agreeing with each other. A piece always runs whole on one card. We never split a single inference pass across the internet; the physics says no, so we don't pretend.
Swarm
Nodes pull pieces they have consented to run. Connections are outbound only, so a node works behind any home router with no ports opened. A node that goes quiet loses its lease and the piece re-queues for someone else. Nothing waits on anyone.
Verify
Roughly one piece in three is quietly handed to a different machine, owned by a different person, which runs it again. The two answers are compared. Honest machines disagree slightly, because different GPUs round differently; the widest honest disagreement we have measured is 2.14%, and the subtlest cheat we could build scored 10.5%. The threshold sits at 5%, in the gap. Caught work earns nothing, ever. Known-answer decoys are built too, and are switched off right now because the ones we have are image puzzles and the grid is running audio.
Reassemble, then receipt
Verified pieces come back together as one result, deterministically. Every passing piece gets an Ed25519-signed receipt and writes one line to an append-only ledger under the contributor's account in the same database transaction. Receipt and record land together or not at all. Those receipts seal into a hash-chained Merkle log once a day, and you do not have to take our word for any of it. The verifier is public, at github.com/spaceninja89/grid-verify, and so is the key it checks against: 4371409900c1e7dd9bae47a3d7ec20da77df1c09e96905a61fb2e5299121129e. Point it at grid.reshoot.ai and it refetches every epoch from /api/v0/epochs, rebuilds every Merkle root leaf by leaf, and checks every signature and the chain between them. It is written to disagree with us; that is the point of it.
What runs today
Two vehicles, kept apart on purpose: a lab coordinator on our own machines that ran from June to August 2026, and the live grid, which moved to its own host in August and counts from there. Updated by hand when the numbers change, not by hype.
Network size today: one coordinator and one account, whose two machines show on the public leaderboard with one of them awake. Two different GPU models have checked each other's work. Small, real, and verifiable beats large and imagined.
- Chunking engine. Audio cut on silence into pieces of one to two minutes; image batches and tiled upscales split with deterministic seeds and overlap-aware reassembly. Every piece independently verifiable.
- Pull-lease dispatch. Outbound-only long-polling, heartbeats, dead-man requeue. Works behind any NAT.
- Verification plane. Cross-node duplicate checks with a measured threshold, node trust tiers, escrowed verdicts, and known-answer decoys for the image lane: a receipt is minted once, at a terminal pass, never retracted. A duplicate must run under a different account, not merely a different machine, so nobody can verify their own work by owning both computers.
- Receipt log and ledger. Signed piece receipts sealed into hash-chained epochs, a standalone verifier that recomputes every root independently, and an append-only contribution ledger written inside the receipt's own transaction.
- The app. One icon, one window: a switch, a file drop, live progress across the swarm, your tier, and hold-a-key dictation that runs on your own machine rather than the grid, because for a five second clip the grid would be slower.
For node operators
The three questions every GPU owner asks, answered the way we answer everything.
What a job can never do
Jobs are data, never code: pinned, signed runtime packs run an audited vocabulary of workflows, and a job cannot reach the internet from your machine, ever. The sandbox that enforces this for strangers' jobs ships with the public client; until it does, no stranger's piece touches anyone's hardware.
What your card needs
Transcription runs in about three gigabytes of video memory, so a 4 GB NVIDIA card is enough, and one of our own nodes is a four year old laptop. Image work wants sixteen. Pieces move as a few hundred kilobytes to a few megabytes. Windows and Linux both proven, one node of each. The switch is yours, so it never competes with your game unless you let it.
Electricity, counted honestly
Your card draws real watts, and at some electricity prices this is a net loss. The app does not yet subtract electricity from what it shows you, and until it does, that sum is yours to do. The rule it will follow is written now: where the math says don't join, it will say don't join. Worth doing on hardware you already own; never a reason to buy a card.
Your recordings, on the grid
A node can hear the audio it transcribes; that is physics, and we won't pretend otherwise. What we do instead: pieces are deleted from the machine that processed them as soon as it is done, nothing is kept to train on, and today every node is hardware we own. Before strangers' machines hear your recordings, the consent story ships in the open, written before it is needed. If you would rather no one else ever hears it, the same app transcribes locally on your own card.
The rules we build by
Written down before launch, so you can hold us to them.
One piece, one GPU
All parallelism lives between pieces, never inside one. Anyone who claims to split a single inference pass across home internet connections is selling something the interconnect math does not allow.
Only verified work counts
Nothing is earned for capacity, uptime, signups, or recruiting. Delivered, verified pieces are the only unit that matters, and every one of them traces to a signed receipt in a public log. The ledger counts the work itself, in seconds of audio handled, so a slow card and a fast card are paid the same for the same piece. Otherwise the smart move would be to run the worst hardware you could find.
No unmeasured numbers
The network is new. We do not estimate earnings we have not measured, and no number ships on any Reshoot surface before it is measured on real hardware. This page obeys that rule.
Agreement is not the same as accuracy
Our checks prove that two machines produced the same answer. That is what catches a cheat, and it is not proof the answer was right. Both could be wrong together on hard audio, and no one has yet sat down and checked a Reshoot transcript against the recording by hand. When someone has, that number goes on this page like every other one.
There is no token
No coin exists, none is for sale, and nothing on any Reshoot surface promises one. If a settlement design ever ships, it pays only against verified work receipts, and you will read it here first, in this register, with the same rules applied.
Honest about today
Right now Reshoot is a company-operated service implementing an open protocol: one coordinator, hardware we own, and nobody outside our own household has run a node yet. Every object is signed and content-addressed, so the exit from that is checkable, not rhetorical: anyone will be able to run a coordinator without asking us.
You are a key, not a customer
An account is a keypair made on your machine. No name, no email in the ledger, no identity check, and the leaderboard shows a short string from your public key. Which machines belong to which account is never published, because publishing it would let anyone reassemble your fleet and undo the anonymity we just promised you.