Introduction: There Is No Send

What Osmol Is

Osmol is not a language for telling computers what to do. It is a language for declaring what is true about a participant (what they hold, seek, owe, decide, permit, and protect), so that a mesh of such declarations can be continuously solved for equilibrium. An Osmol program never executes in the imperative sense. It settles, the way a spreadsheet settles after a cell changes, or the way water settles between connected tanks.

Every earlier communication technology shipped with a language built from envelopes: objects "send messages," processes have "mailboxes," APIs "post" and "push." Osmol is the first grammar in which the act of sending is not discouraged, not deprecated, but unwritable. There is no construct that transmits content to a party. Instead, each participant compiles to a twin, a machine-readable state of assertions (hold), gaps (seek), commitments (owe), and decisions (decide), wrapped in a permission membrane and defended by an attention budget. When one twin holds what another twin seeks, and the holder's membrane permits it, and the resulting pressure clears the threshold of the receiver, then knowledge flows. Communication is what settling looks like from the inside.

There is no send.

Fifty-Five Years of Envelopes

Already in 1971, Ray Tomlinson sent a message from one computer to another on ARPANET and chose the @ symbol to separate the person from the machine. He could not later remember what the first message said. This is fitting: the medium was never designed to care what you said. It was designed to make sure the saying arrived.

That was the correct problem for 1971. Claude Shannon had established in 1948 that the engineering of communication could, and should, set meaning aside entirely; the job was to move symbols across a channel with fidelity. Email is the purest civilian descendant of that idea. It standardized transport and deliberately refused to standardize meaning. Every email is, to the network, an opaque blob addressed to a mailbox; a human on the far end supplies all understanding. For half a century this was wisdom, because humans were the only readers in existence. The assumption quietly expired in the mid-2020s, when the receiving end of a message stopped needing to be a human mind.

And there is a detail from 1971 that reads today like prophecy. In the same year email was born, the economist Herbert Simon published his diagnosis of information-rich societies: that information consumes the attention of its recipients, and hence, in his words, "a wealth of information creates a poverty of attention." So the disease and its cause were born in the same year. Email prices attention at zero. An inbox is the only to-do list in your life that any stranger on Earth may write on, without permission, at no cost. Spam and reply-all storms are not abuses of that system; they are rational responses to a broken price signal. Every self-declared email killer (the chat apps, the team rooms) attacked the client and inherited the disease, adding inboxes instead of removing one. It took fifty-five years before the symptoms became unbearable. Osmol is a grammar written for the year they did.

From Seven Laws to Five Axioms

The Fifty-Year Letter, the manifesto from which Osmol grew, distills what communication in 2026 must become into Seven Laws: Receiver Sovereignty (attention belongs to the person receiving), Declared Intent (every communication object states what it is), Compiled State (threads are source code; the build artifact is a queryable ledger of decisions and commitments), Layered Actors (agents exchange logistics so humans can exchange meaning), Proven Provenance (authorship is a cryptographic claim), Adaptive Fidelity (author once, render per receiver), and Open Protocol (federated, or failed). Osmol is those laws made into grammar. The Five Axioms (there is no send; programs are claims, not commands; the receiver's grammar governs; precision only flows downhill; the human lane is verbatim) are the load-bearing translation of the laws into syntax, and everything else in this book derives from them.

Where Osmol Stands Today

This book is honest about size, so we settle first the claims before making new ones.

Status, plainly stated.

What exists: a v0.1 language specification; a single-file Python reference interpreter, published on PyPI as osmol 0.1.0, whose documented pragmas are normative for v0.1 behavior (see The v0.1 Pragmas); and Theorem 1 (Convergence), machine-checked in Coq with zero axioms, but over an abstracted membrane oracle, meaning the proof covers the flow bookkeeping, not the pressure arithmetic (see Theorem 1).

What does not exist yet: Theorems 2-5 are open. No network transport exists. The wire protocol is specified on paper only, and every mesh that has ever settled did so inside one process. The conformance suite is a plan with two seed programs. There are zero users.

The right metaphor is a blueprint and a working model train versus an actual railroad. Most blueprints never become railroads. The ones that do start exactly like this, and starting does not guarantee becoming.

If that paragraph made you more interested rather than less, you are this book's reader.

How This Book Is Organized

The book is written for an engineer who wants to implement Osmol in any language. The specification and the machine-checked theorems define the language; this book is how you pick them up and carry them.

The Tutorial installs the reference interpreter and walks the canonical two-twin dinner mesh from source to settled trace, ending with the one thing the machine refuses to do for you (resolving decides).
The Reference specifies every construct, the grammar, and also every diagnostic (because in this language the error messages are the ethics), including the sentences that cannot be written.
Semantics gives the pressure function, the granularity lattice, the equilibrium model, and the proof: what is machine-checked, what is open, and exactly where the line between them sits.
Carrying the Stone is the part for implementers: the normative pragmas of the reference interpreter, the conformance suite, and the road from one process to a real wire.
Community covers governance, the RFC process, and how the language versions. This is installed now, at population one, because governance retrofitted after adoption is how open protocols quietly become products.