Protocol

The open rules behind Chorion

Chorion is built on an open protocol: a small set of written rules for identity, messages, history and sharing. Anyone can build a compatible device, cell or tool. Two independent implementations, written apart, must agree to the byte.

many devices, no centre

every link is signed

Devices recognise each other by their keys and pass signed messages along — the same rules everywhere, with no company in the middle.

Structure

Three layers

Cell interface

How a cell talks to the kernel: what it hears, what it says. Small enough to implement in an afternoon, in any language.

Kernel to kernel

How devices recognise, trust and exchange with each other. Precise, with test vectors.

Creation suite

Everything you make with it — deliberately not fixed, so it can keep growing.

Written as numbered proposals (GIP-01 to GIP-15): events, cell interface, identity, kernel links, and extensions such as sealed messages, witnessing and catch-up.

Identity

Your identity is two paper word lists, not an account

When you start, you get two short word lists on paper: one personal, one for recovery, kept in different places. Your keys are made from them when needed and wiped right after — no device ever stores your personal key. There is no company account and no password reset desk: your identity is yours.

Every device its own key

Each device makes its own key the first time it starts. That key never leaves the device.

Permissions that expire

Your household of devices runs on signed permissions: a year for the main device, 90 days for others, a day for each cell — renewed automatically, revoked with one signed line.

Lost, stolen, sold

Lost your personal paper? The recovery paper replaces it and you stay the same person. A stolen device is cut off; a sold one is retired.

Paper once, then a PIN

The paper sets up a device for a year; after that a PIN is enough for daily use.

Backup with a friend

A friend can hold a sealed copy of your history they cannot read. With your papers, everything comes back.

Sealed messages

Messages for your household can be opened by your devices and nobody else — not even the messenger carrying them.

Kernel & ledger

One message format, a history that can be checked

The kernel is the small program at the heart of every device. Every message between cells and devices has one signed shape. Every message is written to the ledger, and each entry contains the fingerprint of the one before — so history can be checked and cannot be quietly rewritten. A receiving device records where a message came from itself; it never just trusts the sender's word.

Signatures everywhere

Ed25519 signatures with fixed labels for each kind of signed thing, so one can never be passed off as another. Connections between devices are encrypted end to end.

Test vectors

Reference files for signing, links and keys, checked by the Rust kernel and by an independent checker written from the text alone.

Laws of the system

Around thirty properties the whole system must keep, each proven in a lab of many kernels. Every bug becomes a law, every law a test.

Value

Makers can be paid when their cells are used

When your cell is used by others, value can flow back to you — directly, between people, without a platform in the middle taking a cut. The kernel only checks whether someone holds a valid pass to use a cell, never why. Payment happens next to it, in a wallet you hold yourself.

Passes, not paywalls

Use of a cell can be granted for a time or a number of calls, as a signed pass the kernel checks.

Pay as it flows

Payment channels on Ethereum (via the low-cost Arbitrum network, now on testnet) let value stream minute by minute while a cell is used — or buy once and keep a signed licence in your own ledger.

Your own wallet

Self-custody: no exchange, no account. And no crypto jargon in the interface.

Credit across households

“Made from” travels with what you share, so the people whose cells went into a result can be credited — and paid.

Value based on real costs

A research direction: value as a living flow, earned by exchange and slowly fading, measured in real cost (energy, compute) rather than printed tokens.

Read the spec

Open, draft, and tested

The protocol paper, the draft specification and a comparison with other open protocols (such as Nostr) are part of the course material on the Learn page, and will be published in full.