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, or grab a release:
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.
Reputation is not granted or bought; it accumulates from what other nodes observe you do. Three inputs feed it:
| Signal | How it's measured |
|---|---|
| Storage honesty | Passing spot-check audits — proving, with a fresh nonce, that you still hold a shard. Failing one is punished heavily. |
| Serving | Bytes actually delivered to requesters. A node that hoards but won't serve is a freeloader. |
| Persistence | Staying reachable. Liveness is observed continuously, never assumed. |
Because your identity is your key, reputation can't be transferred or laundered — and can't be shed without discarding the identity and starting from zero. When your 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.