I maintain a project that treats runic inscriptions as something like a composable system: you state an intent, the system picks runes and orders them into a sequence. My shorthand for it is "runescript as program".
That framing gets attention, so this post is about the part that turned out to be actually hard. It wasn't the runes. It was that most of what's written about them is wrong, and I needed the machine to know which kind of wrong.
The metaphor, briefly
If you write code, the appeal is obvious. A small finite alphabet, elements that combine, order that matters. It has the shape of a DSL: tiny token set, heavy composition rules, most sequences are noise.
Useful, right up until it isn't.
Where it breaks
The honest version starts with an admission: runes were a writing system. The Elder Futhark is an alphabet. Its characters encoded phonemes the same way Latin letters do. People carved names, ownership marks, memorials, occasionally jokes.
The idea that each rune is an operator with a magical function, that Fehu "does" wealth, that stringing three runes together "executes" something... the inscriptions don't show that. Nearly all of it is modern, invented in the 19th and 20th centuries by revivalists and occultists (with some outright ideologues in the mix, which is its own ugly story).
So the metaphor breaks exactly where it gets interesting. "Runes as a programming language" is a design frame I chose. It is not a historical property I discovered, and if I let those two blur, the project turns into one more content farm with better typography.
The actual engineering problem: typing your claims
Once you accept that, the problem stops being about runes. It becomes a provenance problem, which is a data modeling problem, and I suspect a lot of you have hit the same shape in other domains.
Every substantive statement in my corpus carries a provenance tag. There are five:
-
historical-fact: attested by inscriptions or academic runology, with a citation -
revival-claim: constructed in the modern era, recorded with who invented it and when -
practice-instruction: what a contemporary practitioner actually does -
mechanism-evidence: psychology on why a practice might produce effects -
ethnographic-data: what a community reports doing, kept as observation
A statement with no source gets marked unverified instead of quietly promoted. When academic sources disagree, both readings stay in as competing interpretations and nobody picks a winner.
Functionally this is a type system. It won't pass a compiler, but it does the same job: it makes an illegal state unrepresentable. The illegal state here is a modern invention rendered as an ancient fact.
Why this isn't optional with an LLM in the loop
Point a language model at a corpus like this and ask for a paragraph about a rune. Without constraints you get fluent, confident text that welds a 9th century inscription to a 1930s esoteric invention with no visible seam. The model isn't broken. That blend is what its training data looks like: while collecting sources I'd estimate that roughly 90% of what's online about runes is confidently wrong, so the statistically likely sentence is also confidently wrong.
"Please be accurate" in the prompt doesn't fix this. Accuracy isn't a style. What fixed it for me is structural: the provenance tag travels with the claim into the model's context, and generation is constrained by it. The model is never asked to know what's ancient. It gets handed claims that already carry their epistemic status.
If you build retrieval over any contested corpus, the transferable part is this: provenance can't be metadata that lives in a footer. It has to reach the generation step. Tags in a sidecar table the model never sees are decoration, not typing.
A small, stupid, real problem: the runes don't render
One practical note for anyone rendering historical scripts on the web.
Unicode has a Runic block (U+16A0 to U+16FF). Support is genuinely bad. On plenty of systems those code points fall back to tofu boxes, and the failure is silent and platform dependent: fine on your machine, broken for a third of your readers.
Two things helped.
- Ship the font. Don't trust system fallback for a historical block. I bundle Noto Sans Runic, and what used to be an unreproducible bug report became a solved problem.
- Keep the code points out of text whose rendering you don't control. Social posts, syndicated copy, anywhere a third party picks the font stack: write the rune's name in Latin letters. A tofu box says "this site is broken" much louder than a glyph says "authentic".
I learned the second one the embarrassing way.
What I'd keep
The interesting problem in a contested domain is rarely the domain itself. It's building the discipline that keeps you honest at scale, then making that discipline machine readable so it survives contact with generated text.
Runes force the issue nicely, because the temptation to embellish is enormous and the sources are thin. The same shape shows up in medical claims, in legal precedent, in any field where "someone said this once" and "this is established" both look like grammatical sentences.
If you want to see the epistemics applied rather than described, the Elder Futhark reference is the densest example. Every entry keeps the historical layer and the revival layer apart, down to flagging that reconstructed rune names are not the same thing as attested ones. The wider project lives at runoscript.com.
If you've solved provenance typing in a cleaner way, tell me in the comments. That's the part I'd most like to steal.
Top comments (0)