Operator guide
A node gives the network storage and bandwidth, and asks nothing of the files but that they be served honestly. It cannot read what it holds. In return, it earns standing — and eventually a vote in what the network records.
A public node stores encrypted fragments for other people's files and serves them to anyone who asks. You will not know what any of it is — chunks are ciphertext, and the network attaches no names or meaning. What you agree to is simple and mechanical:
One binary, no runtime. Build it from source (signed releases land when V1 is cut):
git clone https://github.com/nerolabs/silt && cd silt
go build -o silt ./cmd/silt
Start a node that pledges 2 GB of storage and joins an existing swarm:
silt daemon \ -capacity 2G \ -bootstrap <PEER-ID>@seed.example.com:4001 \ -listen 0.0.0.0:4001
It mints a keypair on first run (your identity is that key — keep the store directory safe), joins via the peer you named, announces what it holds, and begins serving. Learned peers are remembered, so subsequent restarts need no flags.
The storage you pledge, e.g. 2G, 500M, 1T. The node refuses new shards once full, and placement spills over to the next node. Every message a node sends carries its used/total, so every node continuously estimates the whole network's size from local gossip alone.
Discovery works in layers, like Bitcoin: name a peer with -bootstrap ID@host:port, or point -dns-seed a-domain.com at TXT records that list peers. After that, peer exchange takes over and the address book persists to disk.
Validators keep a replica of the registry chain and vote on what gets recorded. Add -validator, and — to also host the chain for clients — -serve-registry:
silt daemon -validator -capacity 2G \ -serve-registry 0.0.0.0:4433 \ -quorum 3 -attesters <ID1>,<ID2>,<ID3>,…
A fresh validator is born carrying the genesis block — the founding charter, identical on every node — and starts syncing real history from its peers, re-validating every signature itself. It cannot be handed a false chain.
Consensus standing is not granted or bought — coin-free, no speculative token. It is backed by an identity-bound proof-of-space-time bond: challenged, held storage that costs real disk. By default the published record names no author; opt-in blind tokens give true cryptographic unlinkability (a transport IP+timing link remains until issuance-mixing ships, Pre-V1). (Pre-V1, the bond and proof-of-retrieval behind this are honestly-labeled placeholders, sim and single-host only.) The bond is what mints standing; two further signals are measured but do not, on their own, buy standing:
| Signal | How it's measured |
|---|---|
| Storage bond | Challenged, identity-bound held storage that costs real disk. This is the standing itself. |
| Storage honesty | Passing spot-check audits — proving, with a fresh nonce, that you still hold the bond. Passing mints no standing; failing is punished heavily. |
| Serving | Bytes actually delivered to requesters fund the durability economy, not standing. A node that hoards but won't serve is a freeloader. |
Because your identity is your key, standing can't be transferred or laundered — and can't be shed without discarding the identity and its bond and starting from zero. When your bonded standing clears the network's bar, your signature begins to count toward committing new entries. The exact formula and quorum rules →
Add -ui 127.0.0.1:8081 for a local dashboard: pledge used, chunks held and served, the network's self-estimated size, chain height, and the opaque roots you host shards of — everything a node can honestly say about itself.