SlabtestnetRun a node
Testnet live · operators wanted

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.

A file becomes 48 shards on 48 nodesThe file is encrypted, cut into 1 MiB slabs and each slab is coded into 32 data and 16 parity shards on different nodes. Sixteen nodes fail and the file can still be rebuilt.your fileencrypted here1 MiB slabs32 + 16 shards each●32 data●16 parity16 of 48 can fail: file intact
RS 32+16 for large files: decided, in developmenttoday: RS 10+6
23–30 MiBnode memory at idlemeasured on 20 testnet nodes
<1 %of one CPU core at idle0.1–0.8 % across the testnet
~1.62×stored per byte, RS 32+16, metadata included~1.70× for small files (RS 10+6)
0tokens, chains or wallets on a nodeprices in euros

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.

  1. Encrypt

    Your client encrypts the file with ChaCha20-Poly1305 before anything leaves your machine.

  2. Slab

    The ciphertext is cut into fixed-size slabs: 256 KiB today, 1 MiB for large files next.

  3. Erasure-code

    Reed-Solomon turns each slab into data and parity shards. Any k of them rebuild the slab.

  4. 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.

How repair, audits and vouchers work →

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)

16 shards (RS 10+6)48 shards (RS 32+16)
5 % of nodes down
10+62.4 %
32+160.000007 %
10 % of nodes down
10+687.3 %
32+160.2 %
050 %100 %
Table view
Profile5 % nodes10 % nodes
RS 10+62.4 %87.3 %
RS 32+167×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.

Slab at a glance: one table, and what only Slab does →

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.

now

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.

The full roadmap, phase by phase →

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.