Open Compute
Pool GPUs from many contributors and donated clusters into one training fabric.

Open compute. Open training. Open weights.
A community lab building fully open models on pooled, distributed community compute. Data, code, recipes, checkpoints, logs and weights, all public. Early stage: nothing has been trained yet.
The open frontier
Community-driven infrastructure to train and advance world-class models in public, with every step logged and every result shared. None of it is built yet.
Pool GPUs from many contributors and donated clusters into one training fabric.
DiLoCo-style pretraining and asynchronous RL with open tools, open data and open recipes.
Every checkpoint and the final weights are planned for release under Apache-2.0.
Contribute what you have, from a single consumer GPU to an 8-GPU node.
Manifesto
Frontier intelligence is the most important technology of our lifetime, and right now a handful of companies own it. They train on all of us: our writing, our code, our questions, our art. Then they lock the result behind an API and call it safety.
We think there's a better way. We think the frontier should belong to the people who built it.
We build in the open, all of it. Not just the weights. We publish the data, the code, the recipes, the training logs and every checkpoint along the way. If you can't reproduce it, it isn't open, and if it isn't open, nobody can check what it does.
We train together. No one of us has a datacenter, but all of us together might. A gaming PC in Osaka, a lab cluster in São Paulo and a spare GPU in a dorm in Lagos all count, and they all add up. Every machine that joins makes the run faster, and every person who joins makes the model theirs too.
We show our work, including the failures. We'll publish every loss spike, every bad run and every dead end, in public, as it happens. We will never fake a number to look bigger than we are. Today we're just getting started: Run 0 is forming, and you can see exactly where it stands.
We share the credit. Every contributor of compute, code, data or evals is named in the ledger. What we build together belongs to everyone, released under licenses that keep it that way.
We do this because we care. Not for an exit or a moat. We do it because we want to understand these systems, because we think humanity's most powerful tools should be inspectable, and because building something enormous with thousands of strangers is one of the best things people can do.
OpenAI was supposed to be this. We'll be it instead.
Frontier intelligence. Built together.
Bring a GPU. Bring an idea. Bring yourself.
How it works
Islands of GPUs train locally for many steps, then sync compressed updates rarely. Slow links cost little, and nodes can join or leave without stopping the run. This is the design; none of it has run yet.
A spare machine or GPU, offered to a run.
Islands will join through a small coordinator and object storage.
Every checkpoint will be published as the run goes.
Final weights will be open for anyone to use, build on and improve.
Configs, logs and a credit ledger will be open to check.
Platform support
The goal is to welcome the hardware people already own. None of these platforms work yet: this is what we want to build, and we need help.
Planned: Apple M5 and Apple M6 Macs as first-class contributor nodes, training through MLX on Metal. Not built yet.
Help us build itThe first target: CUDA training from consumer RTX cards up to 8-GPU nodes.
Help us build itA flexible platform for any consumer or prosumer GPU. Not built yet.
Help us build itOpen community
Build, train and advance frontier intelligence together, in the open. Credit goes to everyone who contributes, by name.
Planned: trainers, data pipelines and a node agent, all in public repositories.
Planned: every checkpoint released as it is produced.
Decisions in public; a nonprofit foundation is planned.
Methods, evals and negative results, shared openly.
Open to builders, researchers and compute providers anywhere.
Research and protocol
The foundation we are designing for large-scale, community-driven training. Specified in the open; not yet implemented.
Decentralized coordination of training across contributors.
Planned: models, checkpoints and data identified by their hash.
Planned: nodes whose updates hurt the loss are dropped automatically.
Planned: every step logged, results traceable to configs and code.
Join, leave or scale compute with minimal friction.
Network growth
Nothing has been trained and no GPU has joined yet. This chart will plot real numbers from the first run; until then it stays empty on purpose.
0
Contributors on GitHub, read from github.com at build time
0
GPUs in the network
Run 0: forming
Training runs
0
Open artifacts released
The network starts with you. Run 0 opens soon.
About 1B parameters, DiLoCo across 4 to 8 nodes in two regions.
About 10B parameters, our first community base model.
Asynchronous RL with community-built environments.
30B to 70B parameters, as large as pooled compute allows.
Contribute compute, build with the protocol, and help advance open frontier intelligence with a global community.