A private-by-default transport

Watch the wire all day.
You still can't tell who's talking to whom.

The mixnet is an onion-routed transport. Every link runs at a constant rate with constant-size frames whether or not you're sending, so an observer sees one traffic shape at all times. Your calls and messages travel inside that shape, indistinguishable from the silence around them.

Download the seed Read the whitepaper
mixnet mark

Get the Mix.

Download the seed, verify it, run it. It fetches the client through the mix and checks every byte on the way. One honest catch: this first download crosses the ordinary web, so check it against the sums below or build it from the source tarball. Everything after that arrives through the mix.

Seed · Linux x86_64 Seed · Linux arm64 Source tarball
SHA256SUMS The audit protocol The six theorems Whitepaper

Preview builds from the development branch: the relay pin inside is a placeholder, and the seed says so and refuses to run against a real network until a stamped release replaces it. Read it, build it, hold it to its word. macOS and Windows: build from source for now.

You encrypted the message.
An observer still reads who, when, and how often.

Surveillance runs on metadata. Apps that call themselves private encrypt the content and leave the pattern in the clear. The mixnet works on the pattern first: constant rate, constant size, no rhythm for an observer to read.

How it works

Four properties the protocol enforces

01 · SPHINX ONIONS

Peeled one layer at a time

Every packet is a Sphinx onion. Each relay peels one layer and learns the next hop, nothing more. No single relay sees both the sender and the recipient, and length-invariant filler keeps the packet the same size at every hop.

02 · COVER TRAFFIC

Cover around the clock

Links run at a constant rate with constant-size frames even when you have nothing to say. Flood the link or let it idle: it looks the same. A voice call and a phone in a pocket are one shape on the wire.

03 · CHAIN-ANCHORED ROUTES

Routes from a public dice roll

Your client draws each route across the stratified relay layers from a blockchain's verifiable-delay-function output: a shared random value no party can predict before it's computed or bias after, and one any node can check.

04 · NO SENDER ATTACHED

Delivery carries no from

The mixnet hands your app opaque bytes with no sender attached, by design. You and your contact authenticate each other end to end with Noise, where the network can't watch. It holds nothing that maps your social graph.

The seed

Install the network by asking the network for it

You shouldn't have to trust an app store to hand you an anonymity tool. The mixnet distributes itself. You start from one small program, the seed, and everything after it arrives through the mix, checked byte by byte.

Short enough to readThe seed is 1,479 lines of code. You can read all of it in an afternoon and know exactly what it sends, to whom, and what it trusts. A build gate fails if it ever grows past 2,000.
One anonymous requestThe seed asks the mix for a signed index of software. The first entry is the full mixnet client. It fetches the pieces, checks each hash, checks the signature, writes the file, and exits.
No hidden connectionsOne UDP socket, aimed at a relay list compiled into the source. No web requests, no DNS, no telemetry. The dependency list is ten cryptography libraries, enforced by a gate that fails the build if anyone adds an eleventh.
Roll dice if you wantDon't trust your computer's random number generator? Run the seed with --dice, roll a hundred dice, and type the faces. Your key mixes the rolls with the machine's randomness, so neither source can weaken the other.
Nothing unverified touches diskEvery piece checks against its hash. The assembled program checks against a signature from a key printed in the seed's source. An older index than one you've seen is refused. A stale seed says so and stops.
It sounds like everyone elseThe seed's traffic uses the same fixed-size frames as all mixnet traffic. A network observer can't tell a first-time bootstrap from a phone that's been quiet all day.
Proofs

Small enough to read. Written to be checked by a machine.

Most software asks for your trust. The seed publishes its promises as six theorems, and ships the tools that check them. Today, every claim maps to a command in AUDIT.md: build gates, a strict dependency check, and a test harness that replays every exchange the seed can make against the real relay code. A Lean 4 proof development for the six theorems is in progress and lands beside the code, checked by the same CI. We publish the obligations now so you can hold us to them.

T-PARSEThe two parsers accept exactly the published grammar. No input crashes them, and nothing hides in bytes they'd skip.
T-WRITENo byte reaches your disk before the signature and every hash have passed. The write is the last thing that happens, never the first.
T-SINKThe program has one network destination: the pinned relay. There is no code path that talks to anything else.
T-ROLLBACKAn old index can't replace a newer one, and a stale seed refuses to run without you overriding it out loud.
T-BOUNDThree tries per piece, then a clear failure. The seed never loops forever and never retries into the void.
T-FORMATThe packets the seed builds match the Sphinx wire format, layer for layer. Proven about the code; the format's own security rests on the published cryptography it implements.
Build & run

One primitive in, a delivery callback out

Applications link the client SDK and get one call: send bytes to a 32-byte address, receive bytes with no sender attached. Voice, calls, group audio, and file transfer already ride on it. Relays run from one static binary, and every link you carry adds cover for everyone else.

mixnet_client::send(to: Address, bytes: …) // that's the transport. everything else rides on it.