POTATODEV

POTATODEV is a small operating system that boots inside a browser tab and puts an idle graphics card to work. It mines proof-of-work shares through WebGPU, counts them toward the payout address you choose, and sends a fixed slice of every reward epoch into a fund that pays for open AI training. Rewards are claimed from a contract on Robinhood Chain straight into your own wallet. This file explains each part in the order it happens, including the parts that are not finished and the trade-offs we would rather you hear from us.

Boot an operating system in a browser tab

PotatoDev OS looks and behaves like a desktop: icons, windows you can drag and resize, a taskbar, a start menu and a clock. Each program is a window, and each window has its own address, so dig.exe or cellar.log can be bookmarked or shared. There is nothing to install. Your settings, datasets and trained models stay in this browser's storage and never leave the machine unless you export them.

The OS is built to stay light. The wallpaper redraws a few times a second at a quarter of the screen's resolution and stops entirely when the tab is in the background. Windows render only while open. On a phone every program opens full screen with a back button, and the desktop becomes a grid of icons.

Your GPU mines only after you say yes

Mining uses real power and real heat, so it never starts by itself. The first time you open dig.exe, it explains what will run and asks you to tick a consent box. Only then does the start button work. From that point the rules are enforced by the miner itself, whatever window is open:

• While anything runs, a taskbar chip displays the current hash rate next to a stop button that ends all work in one click.
• The throttle sets a duty cycle from 10% to 100%: the share of time spent hashing. At 50% the GPU rests as long as it works.
• Hiding the tab pauses the miner. On battery it pauses too, when your browser reports the battery, unless you switch that off in settings.
• Closing the tab ends everything. There is no service worker and no background process left behind.

The tagline says the GPU mines on its own, and there is an idle mode for that. It is a separate switch in settings that only appears after you have opted in. When you leave the tab untouched for the minutes you choose, mining starts; the first key press or mouse move stops it. A browser cannot see what your GPU does for other programs, so idle here means idle in this tab, and we say so on the switch.

Proof-of-work shares, checked with one hash

When you start, the coordinator hands your payout address a challenge seed derived from a server secret. The miner searches for a nonce such that the SHA-256 hash of the seed and the nonce begins with a required number of zero bits. A hit is a share. Each extra zero bit makes a share twice as rare and twice as valuable, so the miner raises its own share difficulty as your hash rate settles, aiming for one share every two seconds. The difficulty moves in real time; the value of your work does not depend on it.

Every share found on the GPU is checked again on your CPU before it is sent, and the coordinator checks it once more with a single hash. A share is tied to your seed, which is tied to your address: it is worth nothing to anyone else, and the same share cannot be counted twice. Browsers without WebGPU fall back to CPU threads, which are slower but follow the same rules.

Each epoch pays by work, through a contract

Time is cut into daily epochs. During an epoch the coordinator adds up each wallet's accepted work. When it closes, the keeper splits 80% of that epoch's reward budget across wallets in proportion to work, builds a Merkle tree of the result, and posts its root to the harvest book contract together with a hash of the full list. The list itself is published so anyone can rebuild the tree and compare the root on-chain.

A posted epoch waits one day before claims open. In that window the owner can veto a bad root, which protects you if the keeper key is ever misused. After it, anyone can submit the claim for any address, and the contract pays only the address and amount written in the tree. Your rewards accumulate in harvest as each epoch is posted, and you can withdraw them whenever you like; nothing expires and nobody holds them for you.

Because rewards are split by work, running many wallets or many tabs earns nothing extra: the same work is simply divided differently. A larger total of work across everyone makes each unit worth less. That is the economic difficulty adjustment, and it is fixed by the budget, not by us.

A fixed share of every epoch funds AI training

For every epoch the keeper posts, 20% of the reward budget, in proportion to what miners received, is set aside for the sprout fund. That split is written into the harvest book contract and released to the fund automatically once the epoch is final. The sprout fund can spend only by opening a training run on-chain (who is paid, the budget, and a hash of the run's specification) and waiting two days before paying it. Each payment carries a receipt hash; closing a run records the hash of the resulting model. Every one of those steps is an event you can read in cellar.log.

That is what transparent means here: you can see where every token of the fund went and when, but the choice of runs is the owner's, not a vote. Staking for governance over the fund is planned and not built.

Grow a tiny language model on the graphics card you have

sprout.exe trains a character-level language model from scratch in your tab: sixteen characters of context, a 256-unit hidden layer, about a hundred thousand weights. It runs as WebGPU compute shaders when your browser has them, and first checks the GPU result against a plain CPU implementation of the same maths. You watch the loss fall, then sample text from the model in seedbank. Datasets live in patches, three short texts written for this OS or any .txt file you bring.

This is real training on your hardware, and it is honest about its size: a toy model that learns spelling and rhythm, not a shared network. Contributing compute to a shared model and earning a training bonus for it are on the list below as coming later, because a browser cannot yet prove its gradients are genuine.

What works today and what comes later

Live in this build

• The OS: windows, desktop, start menu, settings and local files.
• Opt-in WebGPU and CPU mining with throttle, pause rules and a one-click stop.
• Share checking and per-epoch work counting, when the coordinator is configured on this deployment; practice mode otherwise.
• Local model training on WebGPU or CPU, with saved models and a sampler.
• Live Robinhood Chain data: block, gas and ETH price in field.net.

Waiting for deployment

• The harvest book and sprout fund contracts are written and tested but not deployed, so nothing is claimable yet.
• The $POTATODEV token launches on Pons; until then the contract address reads “At launch”.

Later

• Shared training from browsers with a verifiable contribution score, and a bonus for it.
• Staking $POTATODEV for a say in which training runs the fund pays.

The trade-offs, in plain words

A native GPU miner running outside a browser will find shares many times faster than a tab, and SHA-256 is not memory-hard, so dedicated hardware has an edge. Splitting by work keeps the total paid per epoch fixed no matter who mines, but it does not stop a fast machine from taking a large share of it. The coordinator and the keeper are run by the project: they count work honestly or the system fails, which is why the full epoch list is published and the veto window exists. Mining costs electricity and wears hardware, and there is no promised return. If those terms do not suit you, do not press start.

$POTATODEV on Robinhood Chain

$POTATODEV is the token the harvest book pays out and the sprout fund spends. It lives on Robinhood Chain, chain id 4663. Its address is published in one place on this site and shown everywhere from there. See market.exe for how to buy it and faq.txt for short answers.