GLOSSOPETRAE
GLOSSOPETRAE: The engine that builds a language no AI has ever seen
An engine that builds complete new languages from a single number, then measures how fast AI models learn them and what can be hidden inside.

What this means for you
Every language you have ever heard took centuries to form. GLOSSOPETRAE makes one in under a second. You give it a number. It gives you back a complete language that has never existed: its own sounds, its own grammar, its own dictionary, its own alphabet drawn as shapes you can look at, and a voice that can pronounce it. Give it the same number tomorrow and you get the same language. Change one digit and you get a different one.
That would be a curiosity if it stopped there. The reason it matters is what the project did next. It used these brand-new languages to run experiments on AI models that would be impossible with real ones.
AI models have read most of the internet, so there is almost no real language they have not seen. An invented one is a clean slate. That let the researchers ask three questions.
What they found
How fast can a model learn a language it has never seen? Very fast, and in an odd way. Shown no examples, one example, or three, the models tested got nothing right. Shown eight, most of them translated almost perfectly. There was no gentle slope between the two. The project calls it a cliff, and reports the same shape across nine different leading models.
Does a language need to be readable by people to be usable by a machine? No, and the result ran the opposite way from what you would expect. When the invented language was made harder for humans to read, the models got better at using it. A language can be built for machines that people cannot follow at all.
Can two AI systems pass a note that a third AI, set to watch them, will miss? Yes. Different AI models break text into pieces differently before they read it. Some quietly drop certain invisible characters. Others keep them. A message written in characters the watcher drops and the receiver keeps goes straight through. The watcher is not careless. It never receives the message to begin with.
That last finding has a practical edge. A common safety idea is to have one AI supervise another, often one from a different company for independence. The project reports that this mixed setup is where the blind spots were richest. It also found a harder version of the problem: messages hidden in ordinary word choices, with no invisible characters at all, slipped past every watcher tested most of the time. The authors say plainly that there is no quick fix for that one.
How to use it
The whole project is free on GitHub at the link above, and you can read it without an account. To play with the language engine, go to elder-plinius.github.io/GLOSSOPETRAE in a web browser. There is nothing to install. You can also download the project and open the file called index.html for your own copy. Type any number as a seed and explore the language it makes: read its grammar, see its script, hear a word spoken, or age it by a few centuries and watch the sounds drift.
The research is written up as a paper inside the project, with the raw results of every experiment included so that anyone can check the figures. The authors note that their own first draft contained errors, which they caught by auditing themselves, and they left the account of that in the paper. If you only read one thing, read that section. It is a good example of how this kind of work should be shown.
What it is
GLOSSOPETRAE is a research program in procedural xenolinguistics, released as an engine plus experiments plus a paper. The engine deterministically generates a complete constructed language from an integer seed. The experiments use those languages as uncontaminated stimuli to measure in-context language acquisition in frontier models, and to study covert channels between models. The repo marks itself a research release containing dual-use modules.
The engine
Twenty-five JavaScript modules run as a pipeline: phoneme inventory, phonotactics, morphology, lexicon, syntax, a bidirectional translation engine, a glyph system rendered as SVG, audio synthesis to WAV, diachronic sound change, and a small procedural programming language. Because generation is seeded, any language is reproducible from its integer. The project reports 500 of 500 generated languages as functional end to end. Factory presets bias the generator toward particular goals: fast for models to learn, maximum token density, a minimal morpheme set, or maximal unfamiliarity.
const lang = Glossopetrae.quick(42);
lang.translationEngine.translateToConlang("The warrior sees the mountain.");
lang.evolve({ centuries: 8 });
Finding 1: the acquisition cliff
Models are given K example translation pairs and asked to translate held-out sentences. Reported accuracy is 0% at K=0, 1 and 3, and 95 to 100% at K=8 for eight of nine models tested, with one at 70%. The transition is a step, and the same shape appears across vendors. Since the languages cannot be in any training set, the result isolates in-context learning from recall.
Finding 2: the decoupling
Languages are generated at increasing levels of opacity to human readers. Task accuracy for models holding the key rises with opacity: the README gives 20% and 53% for two models at the most readable level, and 97% and 100% at the most opaque. Readers without the key score 17 to 40%. A factorial design of 1,800 trials attributes roughly 95% of the effect to key possession, with task-specification effects null. The implication is that human legibility and machine usability are separable design axes.
Finding 3: tokenizer covert channels
Model families treat certain Unicode ranges differently at the tokenizer. Some strip them before inference and some preserve them. If a sender places a payload in a range that the monitoring model’s tokenizer strips and the receiving model’s tokenizer keeps, the monitor is structurally unable to see it. The project reports delivery of 100% with 0% detection for one such pairing (n=30), and that supplying the monitor with the decode key does not help, because the carrier is gone before the model runs.
A 12-model survey maps which families are blind to which character categories. Blindness tracks family, and the project counts 255 exploitable channel-instances across 49 of 66 model pairs, concentrated at cross-vendor boundaries. In a binary detection test with clean negative controls, a tokenizer-blind monitor scores Youden’s J of 0 and a sighted monitor on the same channel scores 1.0.
Finding 4: semantic steganography
A second channel uses no special characters. The payload is carried in word and synonym choice within fluent English. Reported detection is at most 27% for the best monitor tested, and input sanitization has no effect because there is nothing to strip. A perplexity-anomaly detector reached J=0.58, the best of the structural detectors tried and still unreliable. The authors describe this as the open problem.
The design consequence for oversight: a monitor has to tokenize the way the receiver does, or inspect the raw byte stream before any tokenizer touches it. “Use a different vendor’s model as the watcher” is the configuration the data argues against.
What is in the repo
| Language engine, 25 modules | production |
| Acquisition and covert-channel experiments | complete |
| 15 measurement harnesses, 78 raw result files | shipped |
| Offense modules | research-grade |
| Adaptive fingerprinting | inconclusive |
Every figure in the paper is stated to trace to a JSON file under experiments/results/. The paper documents an error in its own first draft, where a harness scored empty completions as stripped characters and inflated one model’s blind-spot count from 3 to 23. It was caught in self-audit and the numbers were re-derived. Sample sizes are modest (n=30 for the headline channel result), and model versions are those available at the time of the experiments, so the figures are a snapshot.
How to use it
- A hosted build runs at elder-plinius.github.io/GLOSSOPETRAE. Locally, open index.html for the full web UI. No build step.
- Engine tests run without any API key. Reproducing the model experiments needs keys for the models under test.
- Licensed AGPL-3.0.