Content-blind by architecture · no speculative token · earned standing
Silt is resilient, content-blind, neutral storage infrastructure — files split into encrypted fragments, scattered and healed across many machines. A node cannot read what it holds; it was built to be unable to. Standing to publish is earned — backed by an identity-bound storage bond, coin-free, no speculative token — and by default the published record names no author, with opt-in blind tokens for true cryptographic unlinkability (a transport IP+timing link remains until issuance-mixing ships, Pre-V1). Meaning lives elsewhere, with whoever holds the keys.
Every fragment is named by the SHA-256 of its bytes. Verification is intrinsic — you never have to trust a host, because a chunk that doesn't hash to its name is rejected on sight. Trust is replaced by arithmetic.
Files are Reed-Solomon coded into stripes: lose any six fragments of sixteen and the file reconstructs, bit-perfect. A repair loop watches for decay and rebuilds what's missing. Losing machines degrades redundancy, not the file.
Chunks are encrypted. The manifest that reassembles them is itself encrypted. The public name is thirty-two bytes that reveal nothing. To open a file you need a link — a key that travels between people, never through the network.
The registry is a chain the operators keep together. Publishing a new entry needs a quorum of nodes whose standing clears a bar — earned by an identity-bound proof-of-space-time bond: challenged, held storage that costs real disk. Passing audits proves you still hold the bond but mints no standing; served bandwidth funds durability, not standing. Coin-free, no speculative token. The published record names no author by default — with opt-in blind tokens, publishing becomes cryptographically unlinkable from the identity that earned standing.
Nodes behind ordinary home routers find each other and move data — a content-blind relay bridges them, and where the network allows it they upgrade to a direct, hole-punched link. No public IP or port-forwarding required.
The file is split into fixed-size fragments, each framed so it rejoins exactly.
Every fragment is sealed. Identical data can dedupe; secret data stays unguessable.
Fragments are grouped into stripes with parity, so any k of n reconstruct.
Shards are placed on the nodes nearest each hash, spread so one death costs little.
The file's root is committed to the chain. Retrieval reverses every step, verifying all.
Retrieval is the mirror image: resolve who holds the shards, fetch them, verify every hash, rebuild what's missing from parity, decrypt with the key in your link, reassemble.
A public node contributes a slice of disk and bandwidth and serves encrypted shards to whoever asks. Pledge an identity-bound storage bond and survive its spot-check audits, and your standing rises — until the network trusts you to help write its history. There is no sign-up. Generating a keypair is joining.
The list of what the network hosts is an append-only chain the operators keep together. A block commits only when a quorum of reputable validators sign it — no single node decides, and no electricity is burned. Because a node's identity is its key, a bad reputation can't be shed without becoming a stranger again.
One self-contained binary — no runtime, no install. The desktop client consumes and contributes in the same process: downloading and helping carry the network are the same act. It's Go with no cgo, so building it yourself takes one command:
# clone and build for your machine… git clone https://github.com/nerolabs/silt && cd silt go build -o silt ./cmd/silt && ./silt client # …or cross-compile every target at once ./build.sh v1.0.0 # → dist/silt-v1.0.0-<os>-<arch>
Signed, checksummed binaries for macOS, Windows, and Linux will land on the releases page when V1 is cut. Until then, build from source (one command above).
▶ Want to see it work? Build your own Silt test network on your own computer — a hands-on walkthrough from a one-command simulation to a real multi-node swarm on your laptop that survives a node death.
Neutral infrastructure. It stores, serves, verifies, heals, and proves that encrypted fragments are still here — the way a road moves traffic and a wire moves current: faithfully, without opinion about the cargo.
It is not a place to browse, search, or discover what exists. It attaches no names, no descriptions, no meaning to anything. Resolving a file's identity into what it actually is belongs to a separate layer, built by others — the way DNS sits above IP. Silt answers a smaller, honest question: is the data still here?