What exists to work with it

An entry names something that is in this project and that a reader could use today. A plan is not an entry. Where a thing is packaged, the page states the digest the project publishes for it, because a binary named on a website with no digest beside it is an invitation and not an offer.

The implementations

The fleet, as a roster: what exists and what each one is written in. Every one of them was written from the specification alone by a different author who could not see the others, which is the argument the bootstrapping page makes at length and this page only points at.

11 maintained implementations, no two of them in the same language, and 3 more kept in the archive. Every number about them — what each scores, on what, and when it was last measured — is on the bootstrapping page, read from the same document this roster is.

A DELIBERATE PROPERTY AND NOT AN ACCIDENT. A second implementation in a language already covered is a second reading of the same standard library and the same habits; a new language is a new set of things the specification can be silently wrong about. Every one of these found something, and the C++ one found a question no earlier author could have asked, because C++ is the first of them whose standard library has no Unicode categories.

Three implementations are archived rather than deleted, and they are on the bootstrapping page with their scores. A superseded implementation that still fails documents is evidence about what is hard, and deleting it would be deleting the evidence.

The editors

Two editors can open a .umsg file and show it as a document rather than as text. Both of them do it by handing the buffer to an implementation in this project, so what they show is what a conformant reader sees — and when they cannot parse, they say where and recover as soon as it parses again, rather than showing a stale rendering of something that no longer exists.

THE RULE BOTH OF THEM FOLLOW, and it is the one that makes a generic reader worth having. Neither renderer has a table of key names it recognises. A one-entry map envelope becomes the title, authored order becomes the page order, a uniform sequence of maps becomes a table — every rule is about the SHAPE of the value. A renderer that special-cased title would be a viewer for the documents its author happened to have.

The applets

A protocol for portable interactive documents. An applet is a WebAssembly module exporting three functions: a fresh state, a transition on an event, and a projection. The host executes it and owns every effect; the module computes and reaches nothing.

Everything crossing that boundary is unimsg in canonical CBOR, both directions. Same bytes on every host, every number exact.

render returns a DOCUMENT the host builds an interface from, not a picture of one. Three kinds: an interface, a drawing, and an interface with a document in it — one applet below for each. A host reading an interface document builds native controls with real focus and a real accessibility tree, because the document says what things are rather than where to paint them.

An applet is one unimsg document. The manifest carries the identity, the version, the modes a host may open it in, the intents it accepts with their defaults, and the WebAssembly module's bytes inline beside the sha256 that pins them. No second artefact, no path to resolve, no fetch.

The hash is verified whatever the bytes came from, including from the same file as the hash: a file whose two halves disagree is a broken artefact, and trusting one half because you trust the other leaves no way to notice.

One host, and it is none of the applets. Every button opens the same page — the open path, the ABI, the drawing projector, the interface builder and a unimsg codec, as ordinary files — and hands it a different applet document to fetch. The host knows nothing about which applet it is opening.

Before instantiating: the manifest's required keys, the sha256 of the module against the manifest, the mode, and the capability grant — by the same code savage's build runs against every applet.

The digest check uses the browser's own crypto, so it needs a secure context. Over plain http to anything but localhost the applet is refused rather than run unverified.

Nothing in the host is inline — one stylesheet, one module, every import a file beside it — so it serves under script-src 'self' 'wasm-unsafe-eval' with no hash, no nonce and no data:.

'wasm-unsafe-eval' is not optional: compiling a WebAssembly module counts as evaluating code, so script-src 'self' alone blocks every savage host in every browser, and the console error says eval and never says wasm. The keyword is narrow — it permits WebAssembly and not eval.

Capabilities are granted by the site, in the markup, defaulting to none. Nothing here is granted anything.

No transport, no identity system, no relay, no storage — a host supplies all four. An identity is an opaque value the host attributes an event to; the protocol compares two for equality and asks nothing else.

Elsewhere this site shows a document beside its bytes. Here a document is being decoded, stepped and projected in the browser by a program in another language, written for another project, and what is on screen is what came back.

Two carry documents from this project and neither restates what it carries. The chess module contains no chess: it interprets a ruleset document and draws through a board-presentation document, both checked here by tools that are not the applet. The prose applet renders a rich document it did not write, carried whole as canonical CBOR.

The host verifies each module against the sha256 in its own manifest before instantiating. This page states no digest of its own, so there is no second copy to go stale.

The vocabularies other projects write in

@vocab/spatial/v0, @vocab/measurement/v0, @vocab/git-repository/v0 and @vocab/encyclopaedia/v0 have consumers in this project and none outside it, so they are absent here and on the findings page instead.

Every vocabulary the project has, including those nothing outside it writes in yet: vocab/vocabularies.umsg raw

Highlighting

Four things colour unimsg in this project, and three of them are real implementations being asked what the tokens are rather than patterns that approximate the answer.

So the highlighting follows whichever theme the reader already chose. An extension that ships a palette is an extension that looks wrong in every theme but the one its author uses.

Two independent readings of the same grammar colour this site: one in Go, one the JavaScript implementation's own lexer. The playground shows a document coloured by each, so if they ever disagree about what a token is, a reader can see it.

Elsewhere

A companion is linked because it exists and is about this format, not because anything on it is stable or blessed. The status travels with the link, so the sentence a reader gets is what the thing is and how finished it is, in that order.

ribosome.unimsg.net — a generic renderer and presentation layer for unimsg documents. Experimental, and a separate project from this site.