one open model, trained by many machines in rounds

Trained by whoever shows up.

One open model. The data is fixed and public. The compute is everyone's spare hardware, from a gaming PC to the phone in a drawer. Work that makes the model better goes into the chain under your name and counts toward your grade. Grades are planned to earn perks on the hosted model.

·block height
·deltas this round
·perplexity now
·until the seal

reading the chain…

train

Press start once. It keeps going.

The tab takes a job each round, trains, sends the result, waits for the seal and takes the next. Browse the other panels meanwhile: the bar at the bottom is the trainer.

device
this browser
name
key
made on first start
dealt
·
step
·
loss
·
grade
none yet

Every job is the same 30 steps; one that misses the round is not taken, so a slow device may sit some out. Closing the tab stops it; what was already sent stays sent. The first start fetches the data and the model, about 480 MB, which this browser then keeps; a phone may not have the memory for it yet.

Your key is your credit: a text file, the same as ~/.spel/key for the spel CLI, so the work this tab does can follow you to a terminal.

rounds trained
0
merged
0

    the chain

    The chain is the model.

    Block 0 is a starting model. Every block after it is a change to the weights and the hash of the block before. Replay it from the bottom and you get the same model, bit for bit. The newest 64, as the coordinator has them:

    a block with a delta mergeda block where nothing passed

    how it works

    One round, five moves.

    1. DealThe last block's hash and your name pick your slice of the data. Nobody chooses their own.
    2. TrainYour machine runs a training job on that slice. As many steps as it can manage.
    3. SendYour result goes in before the round closes. Nobody sees anyone else's until it does.
    4. CheckAll the results together pick the test text. Other trainers check yours on it, each check signed. It has to cut the loss.
    5. MergeEvery result that passes is merged into the block, and the block records who trained it.

    The coordinator keeps the clock and spot-checks the checkers: a key that signs a wrong loss stops checking. Anyone can replay the whole chain and re-run every block's loss, so nobody can fake a block.

    ways to join

    Anything with a processor.

    This tab

    works today

    Press start. The same C as the CLI, compiled to WebAssembly, every check done in it the way a terminal does it.

    The spel CLI

    works today

    One binary, C, no Python. For machines that stay on.

    spel train cave --name ana \
      --url https://spelaeum.mithraeum.studio --loop

    A farm

    works today

    One machine runs a relay, and every phone and desktop on the farm trains through it. The coordinator sees one client.

    spel relay farm \
      --url https://spelaeum.mithraeum.studio --bind 0.0.0.0

    A GPU

    works today

    WebGPU in this tab where the browser has it (Chrome and Edge), OpenCL in the CLI with make GPU=1. Where most of the power is.

    Waiting trainers check each other's work, about a hundredth of a job each, so the coordinator stays a small machine. The data, the model and the blocks download from the mirror on Hugging Face.

    credit

    Credit, counted in work.

    Every job that passes its check counts as the computing it took, and the blocks record whose it was, so anyone can add it up with spel credit.

    The reward: grades are planned to earn perks on the hosted model when it opens, kept to the account that earned them.

    the grades

    gradeoperationsa phone, in a tabone RTX 3060
    Corax10¹⁵a week2 min
    Nymphus10¹⁶2 months17 min
    Miles10¹⁷a year and a half3 hours
    Leo10¹⁸·a day
    Perses10¹⁹·12 days
    Heliodromus10²⁰·4 months
    Pater10²¹·3 years

    The seven grades of the Mithraic mysteries, each ten times the last. Times are rough, running nonstop. Grades measure computing, not model size: Pater is about a ten-thousandth of the computing in one frontier-scale training run, around 10²⁵ operations by public estimates.

    the board

    trainerpassedmergedrefused

    The last 64 blocks, read from their heads. spel credit on any copy of the chain adds up all of it, and your grade above comes from this tab's own copy.

    Spelaeum is part of Mithraeum · GPL-3.0 · hako engine

    open

    Nothing here needs us.

    The code, the method, the chain and the weights are all GPL-3.0. The chain is the full record of how the model was made, so anyone can rebuild it, run it, host it, or start a chain of their own the same way.

    Run it

    free

    Every weight is in the chain. Replay it and run the model on your own machine.

    Host it, fork it

    free

    The chain is plain files: mirror it on any static host, serve the model, fork the chain, train your own with spel. The GPL asks one thing: what you change stays open too.

    Or use ours

    later

    Once the model is too big for one machine, we host it so you don't have to. Paid use covers the cloud bill and a salary for the person running it. Small models stay free. We don't take your data to pay for it.

    ready to train