Cloud storage that nobody owns, and only you can read.
Slab encrypts your files on your machine, cuts them into erasure-coded shards and spreads them across independent operators. A node is one small process: no blockchain, no token, no wallet on the box. And the payment for your storage can't be linked to what you stored.
This page is stored on the Slab testnet and served from it.
What you can do today
Store, share, stream and publish.
Everything below runs on the testnet now, from the slab CLI or over plain HTTP.
Files and folders
Upload a file or a whole directory with slab put. Small files are packed together, so a folder of icons doesn't cost a slab each.
Share by link
A slab://root#key link is the whole capability. The key sits after the # and never goes over the network.
Stream and seek
Range reads fetch only the slabs a byte range covers, so video seeking works through any gateway.
Host a website
Point a signed feed at a directory and a gateway serves it as a site. This website is published exactly that way.
Mutable feeds
Owner-signed pointers that update in place: publish a new version and gateways following the feed serve it within 30 seconds.
Plain HTTP gateway
Any browser or curl reads Slab through /slab: files, directories and websites, with range reads so video seeks.
How a file is stored
Four steps, and only the first one sees your data.
Encrypt
Your client encrypts the file with ChaCha20-Poly1305 before anything leaves your machine.
Slab
The ciphertext is cut into fixed-size slabs: 256 KiB today, 1 MiB for large files next.
Erasure-code
Reed-Solomon turns each slab into data and parity shards. Any k of them rebuild the slab.
Spread
Every shard goes to a different node, with a cap on how many shards of a slab one network may hold (and next, one operator), so a failed node costs one shard and a failed machine or site a bounded few.
Durability
Large files get 48 shards, any 16 of which can fail.
A large file is thousands of slabs, and losing any one of them loses the file. A layout that looks safe for one slab adds up to real risk for the whole file, so the stripe has to grow with the file.
- Files above about 1 MiB: 1 MiB slabs coded RS 32+16. Any 16 of 48 shards can fail, at about 1.62× the stored size including metadata. Rolling out on the testnet.
- Small files and directory listings: 256 KiB slabs coded RS 10+6, where a larger slab would mostly be padding.
- Repair starts early: below 40 healthy shards of 48, still seven failures away from any loss.
Chance of losing a 1 GiB file
when a share of nodes fails at the same moment (exact model, slab-sim --scenario model)
Table view
| Profile | 5 % nodes | 10 % nodes |
|---|---|---|
| RS 10+6 | 2.4 % | 87.3 % |
| RS 32+16 | 7×10⁻⁸ | 0.2 % |
What's different
Things you don't get elsewhere.
Other decentralized storage networks are built around a token and a chain. Slab moves money off the data path entirely, which is what makes the rest possible.
Payment that can't be traced to your data
Vouchers are blind-signed (RFC 9474). The control plane sells a voucher but can't recognise it when a node accepts it, so no ledger links accounts to uploads.
A node that is just a storage node
No chain client, no token wallet, no RPC endpoint. It idles at about 25 MiB of memory, so it fits on a Raspberry Pi or a NAS next to everything else.
Euros, not a token
Customers buy vouchers at a price in euros; operators are paid for shards they prove they hold and serve. Nothing to speculate on, and no exchange between you and your storage bill. (Simulated on the testnet.)
Earn storage by storing
plannedOperators will be able to take earnings as storage credit: a node with spare terabytes pays for your own backups.
Nodes that update themselves, safely
Releases are signed feeds on Slab itself. Nodes stage an update outside their audit window and roll back if it keeps crashing. Operators don't babysit versions.
Storage made for AI agents
plannedAn MCP server with spending caps an agent can't raise, private feeds for agent memory, and forgetting by destroying a key.
Roadmap
Where it's going.
Data loss first: durability, then durability at real data sizes. Then operators (tools and a reason to run a node), standard APIs and agents.
Durability
Built: 48 shards for large files, renewing paid storage. Closing once it has run on the testnet.
Nodes at home
Port mapping, IPv6 and hole punching, so a node behind a home router needs no port forwarding. Built.
Durable at size
Every shard audited weekly at any size, repair that keeps up, disk scrubbing, safer releases.
Operators, then APIs and agents
Bulk staking and correct, checkable payouts; then S3 and WebDAV; then MCP and agent memory.
Have a disk you're not using?
The testnet is small and we're looking for the first independent operators. A node needs one UDP port, about 100 MiB of memory and whatever disk you can spare.