Distributed storage · encrypted at every level
Silt is a network that stores and serves files as anonymous, encrypted fragments — split, scattered, and healed across many machines. A node cannot read what it holds; it was built to be unable to. 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 reputation — passed storage audits, bytes served — clears a bar. A fresh identity is a nobody until it proves itself.
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. Serve honestly and survive spot-check audits, and your reputation climbs — 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 v0.1 # → dist/silt-v0.1-<os>-<arch>
Signed prebuilt binaries for macOS, Windows, and Linux arrive with the first tagged release — follow the changelog to know when.
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?