Glossia bridges the gap. Keys, signatures, hashes, encrypted messages, wallet addresses, access tokens — the things we're asked to copy, verify, and trust are built for machines, not people. Glossia transforms that data into structured language and other human-friendly forms, with perfect round-trip fidelity.
Most people recoil at ciphertext — even when the data is perfectly secure, it feels foreign and inaccessible.
4a5e1e4baa
→
Above engage valley to napkin. Our favorite is red.
Humans assign meaning and legitimacy to familiar forms of communication. A passage of Latin carries different weight than a block of hexadecimal, even when neither is understood by the reader. Glossia exploits this: the same payload can be represented as structured English, Latin prose, and other human-friendly forms — without changing a single bit. The goal isn't compression or secrecy — it's reducing the language barrier between humans and digital systems.
And to be clear, this isn't steganography. Glossia doesn't hide that data is present — it makes the data itself legible, meant to be seen and decoded. Freed from spending capacity on concealment, every payload word carries its full 11–15 bits, where hiding data inside text nets well under one per symbol.
Turn an opaque key into a readable sentence — dictate it, paste it, decode it back byte-for-byte
An API key — or any hex, base64, or text blob — is bit-packed into payload words and woven into prose. A leading padding word records the exact bit length, so keys of any size (including awkward leading-zero bytes) round-trip exactly. The padding word travels with the payload, so even the cover-hidden view stays decodable.
Decoding filters the prose back to its payload words and unpacks the bits, recovering the key in whichever format you pick — ASCII, hex, or base64. Press ⇄ to switch direction; the output format defaults to the one detected when encoding.
A locking script you can read, dictate, and check by eye — and that tells you when it has been damaged
Opcodes use the Book of Bitcoin notation — the same glyphs a script gets when it is read in the book (⓪ OP_0, ① OP_1, ⌁ OP_DUP, ⌖ OP_HASH160, ≡ OP_EQUALVERIFY, ∇ OP_CHECKSIG). Glossia encodes only the part that carries entropy — the 20- or 32-byte program — which is 17 words for a hash160 address and 25 for a 32-byte one.
⓪ and ① are worth a note: Unicode counts them as alphanumeric, so the decoder’s token trim does not strip them. Written flush against an address word they would hide it entirely. They are safe here because the format declares its glyphs and they are removed by name — a rule based on character category would silently lose a word.
The words are Glossia’s canonical encoding: the program is prefixed with a version byte and packed with a self-describing codec, so the artifact itself names the rules it was rendered under. When rendering improves — new languages, better prose — new artifacts get a new version while an old one keeps verifying under the rules its byte selects. The version and packing cost two words on a hash160 address; that is the price of an artifact that stays valid across releases.
The wording is the checksum. The cover words are chosen by a seed derived from a CRC-32 of the address, so a different address produces a visibly different paragraph. Verification re-renders the address you decoded and compares: only the true bytes reproduce this exact wording. That costs no extra words, because the information rides in which prose was chosen rather than in any word's value.
Errors are reported the way a word processor does. An address word that is wrong or not in the vocabulary gets a red spelling underline; a connective word that disagrees with what the address calls for gets a blue grammar underline. The split is real rather than cosmetic: an address word is either off the vocabulary or the wrong entry in it, while a connective word is the wrong choice in an otherwise well-formed sentence.
Unlike an ordinary spell checker, a suggestion here is confirmed, not guessed. Substituting the candidate and re-rendering either reproduces the received wording or it does not — so the checker can say “this is the word that was meant” rather than “this is a word that looks similar”. It is still shown as a proposal and never applied.
Try the damage buttons. A fumbled connective word still yields the right address but can no longer self-verify. A mistyped address word decodes to a different address — caught only by the wording. A lost word is caught by the word count, since a fixed-length address has a fixed number of words.
Press ⇆ to run it backwards. The words are not a label attached to an address; they are the address, and decoding hands back the string they were made from. Swap after damaging the prose and you can watch it hand back a different address — which is the whole reason the wording has to be checkable.
Turn any text into readable prose — add a passphrase to encrypt it, or leave it blank to just encode. Decodes back byte-for-byte.
Encoding. Your text is compressed (gzip or a 7-bit ASCII pack, whichever is
smaller) and bit-packed into payload words, which are woven into grammatically valid prose.
Decoding filters the prose back down to those words and reverses the packing —
byte-for-byte. With no passphrase the output is pure prose; a tiny [flag][length]
header rides along inside the payload, so there’s nothing else to carry.
Encryption. Add a passphrase and the compressed bytes are sealed with authenticated AES-256-GCM before encoding. The passphrase is stretched with PBKDF2 (SHA-256, 200k iterations) to derive both the key and the nonce from a fresh per-message salt, so the nonce never has to be transmitted. The artifact then reads as a quote with a source: the prose is the ciphertext, and the dim — attribution after it carries the plumbing (salt and authentication tag) as ~11 Latin payload words. Only the passphrase unlocks the message.
Authenticated. GCM provides integrity as well as confidentiality — a
wrong passphrase or any tampering with the prose or the attribution fails cleanly, instead of
silently decoding to a different message. The same pipeline, signed and published to nostr relays
so a board loads by #npub in the URL, powers the
Bulletins demo.
A lossless framework that converts binary data into human-oriented representations.
Every representation decodes back to the exact original bytes. No approximation. No AI interpretation. No information loss. Just a different language for the same data.
The practical payoff of machine data that reads like language
Natural prose is easier to read aloud, type, or copy by hand than hex strings. Transcribe API keys over the phone or between devices without errors.
Looks like normal text — flows through email, documents, and chat without breaking formatting or triggering spam filters.
Everything happens in your browser via WebAssembly — your keys never touch our servers. Open DevTools and disconnect your internet. It still works.
Chain encoders with natural-language pipelines: "encode into english naturally", "transcode from latin into english". Every dialect is a composable function.
Perfect round-trip encoding and decoding. Decode by simply filtering against the payload wordlist — it's mathematically guaranteed.
Control output density with natural language: encode "compactly" for 20-30% fewer words, "naturally" for readable prose, or "optimally" to pick the best of 50 variations.
The encoding pipeline turns bytes into prose — decoding reverses the same path
Decoding follows the same principle: filter the output against the payload wordlist to recover the encoded tokens, then reverse the codec to get the original bytes.