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 a seed phrase into a memorable madlib or latin proverb — check that either decodes into the original.
A 12-word BIP39 seed is 128 bits of entropy plus a checksum. Glossia weaves those exact words into grammatically valid prose, filling the gaps with cover words that carry no data. English shares the BIP39 wordlist, so the seed words appear verbatim in the sentences; Latin and Czech map the same bits onto their own wordlists (Latin's larger list packs the seed into ~9 words).
Decoding just filters the prose against the payload wordlist to recover the seed words — byte-for-byte, with no AI or approximation. Press ⇄ to run it backwards, or hide the cover words to see the payload alone.
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.
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.