How languages work in World of Warcraft (and how we taught an addon to speak Orcish)
Intro
If you have ever played World of Warcraft, you know the joke: a Horde player types lol, and the Alliance player
next to them reads kek. The other way round, Alliance lol turns into bur. The two factions cannot talk to
each other in /say, and the game makes that visible by turning every word into a word of a fake language.
I wanted to know how exactly that works, whether it can be decoded, and whether it can be bent so the other side reads real words after all. It ended with a released addon, Forever Tongues. This post is the whole story: the game's side first, then what we built on top of it.
Who does the scrambling
The first surprise is where it happens. The server does not scramble anything. When you /say something, the
server passes on your original text plus a language id (Common, Orcish, Taurahe, ...). It is the reader's
client that looks at the language, sees that its character does not know it, and swaps every word for a fake one
before it shows the line.
You can check this in the open server emulators of the old 1.12 client (the chat handler only attaches the language), and we confirmed it the practical way: two characters, Human and Tauren, on a local test server, one saying a list of words and the other recording what arrived.
That also settles the obvious idea of "an addon that just shows the original": an addon gets the line after the client has scrambled it. The chat event carries exactly the text in the chat window. The plain text is somewhere in the client's memory, and reading it from there would be a client hack. That was never an option.
The word lists
The fake words come from a game data table (LanguageWords). In the 1.12 client it has 1,481 words in 13 languages,
grouped by length, and each length has only 5 to 16 words. Common, two letters:
Lo Ne Ve Ru An Ti Me Lu Re Se Va KoCommon, three letters:
Vil Bor Ras Gol Nud Far Wos Mod Ver Ash Lon Bur HirSo the rule we observed was simple: every word becomes a fake word of the same length, picked from the speaker's language, and the same word always gives the same fake word, for every player. A few more things fell out of the recordings:
- Case is copied letter by letter:
lol→bur,LOL→BUR,Lol→Bur. - Punctuation disappears:
lol!,lol?andlol.all readbur. - Numbers are scrambled too: in Common
1readsoand100greadsnuff, so you cannot even pass a price or a coordinate. - Long words become compounds: eighteen
xin a row readadorstaerume.
The hash
"Picked deterministically from the word" means a hash. My first attempt was to throw the usual suspects at the recorded pairs - MPQ string hash, djb2, sdbm, FNV, ELF - and all of them scored at chance. The function turned out to be a variant of Blizzard's own Storm string hash, with two seeds and a 16-entry table indexed by the two halves of each byte. Ported to JavaScript:
const TABLE = [0x486E26EE, 0xDCAA16B3, 0xE1918EEF, 0x202DAFDB, 0x341C7DC7, 0x1C365303, 0x40EF2D37, 0x65FD5E49,
0xD6057177, 0x904ECE93, 0x1C38024F, 0x98FD323B, 0xE3061AE7, 0xA39B0FA1, 0x9797F25F, 0xE4444563];
function hash(word) {
let s1 = 0x7FED7FED, s2 = 0xEEEEEEEE;
for (let c of Buffer.from(word, 'utf8')) {
if (c >= 0x61 && c <= 0x7A) c -= 0x20; // ASCII lowercase -> uppercase
if (c === 0x2F) c = 0x5C; // '/' -> '\'
const value = (TABLE[c >>> 4] - TABLE[c & 15]) >>> 0;
s1 = (((s1 + s2) >>> 0) ^ value) >>> 0;
s2 = (Math.imul(s2, 33) + c + s1 + 3) >>> 0;
}
return s1 || 1;
}And the pick itself:
function garbleWord(word, lists) {
let len = Math.min(Buffer.byteLength(word, 'utf8'), 18);
while (len > 0 && !lists[len]) len--; // no group of that length? take a shorter one
const group = lists[len];
const fake = group[hash(word) % group.length];
// copy the case of the original, position by position
return [...fake].map((ch, i) =>
i < word.length && word[i] !== word[i].toLowerCase() ? ch.toUpperCase() : ch.toLowerCase()).join('');
}A few details are worth pointing out:
- The hash uppercases the word first, which is why
lolandLOLland on the same fake word and only the case is copied afterwards. - The language only chooses which list is used. The index is the same number for every language, so
lolsits at the same position in Orcish and Taurahe whenever their lists have the same size. - The length is counted in bytes, not letters. That matters later.
- There is one more rule for players who partly know a language: if
hash % 300is smaller than your language skill, the word is shown as it was typed. That is why a half-learned language shows a real word here and there.
With this port every one of the 3,430 recorded pairs came out right. From then on we could scramble any word offline, without asking anyone to type it in game.
The Forever twist
WoW Forever runs on a modern client, and the first test there failed in an interesting way: Orcish worked exactly as predicted, Common did not. Nine words were enough to find out why. The Forever client multiplies the hash by the language id before the modulo:
const fake = group[(Math.imul(hash(word), languageId) >>> 0) % group.length];Orcish has id 1, so nothing changed for it. Common has id 7, and all nine words fit. One side effect: a language with an even id (Darnassian 2, Dwarvish 6, Troll 14) can never reach some words of its lists, so those languages have fewer fake words to work with.
The second difference is how the modern client treats characters outside ASCII. The group is still chosen by the byte length, but the reader sees the fake word cut to the number of characters typed (counted in UTF-16). So a single three-byte character picks a word from the three-letter group and shows just its first letter, and a four-byte one shows the first two. That gives many more "pieces" to build words from - but the hash for multi-byte input on Forever is not the 1.12 one, and no variant we tried fits. So those tables were measured instead: the addon has a probe mode that says a few hundred test characters, the other character records what it heard, and a script pairs them up. 648 pairs per language, and the cut tables are built from them.
Can it be decoded?
Short answer: no, not really. Each fake word stands for hundreds of real ones. With 5 to 16 fake words per length,
a fake word carries about 3-4 bits of information plus its length, and ordinary chat needs far more than that per word.
In our first 280 test words, Orcish kek already stood for 18 of them: lol, nub, yep, plz...
What you can do is guess, the way T9 predictive text guesses from number keys: take every real word that scrambles to the fake one, and let a language model pick the most likely sentence. We measured it on recorded sentences:
| Decoder | Words right | Whole sentences right |
|---|---|---|
| Word frequency only | 33 % | 0-2 % |
| + a local LLM picking from the top 25 candidates | 35-36 % | 6-11 % |
| Trigram phrase model (addon) | 89 % on known phrases, 66 % on new lines | - |
Stock phrases come out fine: gg wp, lol noob, help me please, follow me, where are you. Real sentences with names and content words do not. So the addon shows a guess, clearly marked as a guess, and lets you correct it.
Writing so they can read it
The more fun direction is the opposite one. If you know the hash, you can search for inputs that scramble into a
fake word you want. People did this long before us - an old web translator from 2002 listed what to type so the other
faction reads chosen words. For example, a Horde player types 3 0 3, and the Alliance reads l o l.
The catch is the alphabet. In 1.12, the single-letter Orcish words are only A N G O L, and the single-letter Common
words are only vowels. With the modern cut rule and multi-byte characters it gets much better: a word can be spelled
from pieces that are prefixes of fake words, like ha l lo for hello. Some letters still never appear in a
language at all (Orcish has no c f j p q w x y), so the addon also tries a stand-in letter, an English synonym or a
respelling before it gives up on a word.
The addon: Forever Tongues
All of this ended up in Forever Tongues, an addon for the WoW Forever client. It does three things:

1. Speak to them. Start a say or yell with *, for example *hello friend. The addon types the pieces chosen so
that the scramble spells your words, and the other faction reads them without any addon on their side. Phrases in
the book are marked whole (read as typed), synonym (a word swapped for one that fits) or cannot (the language
lacks the letters).
2. Read their chat. Their say and yell lines go to the Heard page, with a guess under each one. The guess comes from precomputed readings (every vocabulary word scrambled for every language, because there is no hash in the Lua code) and a small trigram model over common chat phrases. Click a word, pick what it really meant, and the book remembers it - and shares it with your guild and group, so everyone's guesses get better.

3. Talk in secret. Start a line with !, or turn on Coded mode, and the addon uses the language's 64 shortest fake
words as an alphabet: every word carries 6 bits, with a marker, a part header and a checksum. Everybody else sees
gibberish - including your own faction - while another Forever Tongues user sees your exact text, diacritics and all,
in a Tongues chat tab. How that works is the next section.
* spell it | ! code it | |
|---|---|---|
| Who can read it | everyone of the other faction | only Forever Tongues users |
| What gets across | the words the language can spell | your exact text |
| Needs the addon | only you | you and the reader |
All of it lives in a small in-game book, opened from the minimap button or with /tongues dict: ready phrases by
topic, what you heard, a glossary of their words, settings and a help page.

Coded mode in detail
Spelling has a hard ceiling: a language can only show the letters its fake words contain. Coded mode drops the idea of showing real words at all. It treats the scramble as a transmission channel and sends bytes through it.
Why not just send it as addon data?
Addons have their own invisible channel (C_ChatInfo.SendAddonMessage), and Forever Tongues uses it for the shared
glossary. But addon messages only go to your guild, party, raid or a whisper, and none of those cross the faction line.
The only thing both factions hear is /say and /yell, and those are scrambled. So the data has to survive the
scramble.
An alphabet of 64 fake words
The scramble is deterministic, so a typed input always turns into the same fake word, for everyone. The addon already knows, per language, which short input produces which fake word (those are the spelling tables). For the code it takes the 65 shortest fake words of the language - only ones made of plain letters and apostrophes, so the chat never splits them - and sorts them by length and then alphabetically. Both sides sort the same table, so they agree on the order without ever exchanging it:
- symbols 0-63 are the digits of a base-64 alphabet, so every word carries 6 bits;
- symbol 64 is the marker that starts every coded line.
For Orcish the alphabet begins like this:
| Symbol | 0 | 1 | 2 | 3 | 4 | 5 | 6 | 7 | ... | 64 (marker) |
|---|---|---|---|---|---|---|---|---|---|---|
| You type | 1 | 2 | 3 | 6 | 0 | 12 | 1g | 00 | ... | 000000t |
| The other faction reads | a | g | l | n | o | ag | gi | ha | ... | lok'tar |
The inputs look odd because they were found by brute force: they are simply the shortest strings whose hash lands on that fake word.
From text to words
The message is taken as UTF-8 bytes, so any character works - Czech ř, an emoji, whatever the chat box accepts.
The bytes are cut into 6-bit groups (the last one padded with zeros), exactly like Base64, and one more symbol is
added at the end: a checksum, the sum of all bytes modulo 64. Encoding hi:
text h i
bytes 01101000 01101001
6 bits 011010 000110 1001(00)
symbols 26 6 36 + checksum (104 + 105) mod 64 = 17Each line then gets a small frame: the marker, a header symbol, and the data. The header is part * 2, plus 1 on
the last part, so the reader knows which piece of the message this is and when it has all of them. A line is at most
255 bytes, so a message can take up to 32 lines; in practice one line holds about 35 bytes of text.
The whole hi message is one line. This is what gets typed, and what the other faction sees:
you type 000000t 2 0007 1g 000p 004
they read lok'tar g gesh gi uruk kil
symbol marker header 26 6 36 17 (checksum)To a player without the addon it is just a Horde player saying something in Orcish - six fake words, like any other line. Your own faction does not see it either: they speak Orcish, so the client shows them the raw input, which is a line of digits and letters.
Reading it back
On the other side the addon looks at every say and yell. A line is a coded line only if its first word is the marker, its second a valid header, and every other word one of the 64 symbols - for an ordinary sentence that practically never happens. The addon reads both forms: the fake words (the other faction) and the typed inputs (your own faction, who speak the language), so the same message works across the faction line and within it.
Parts are collected per sender. When the last part has arrived, the symbols are joined, turned back into bytes, and the checksum is compared. If everything fits, the exact text appears in the Tongues tab, and the coded lines themselves are filtered out of the chat window so they do not clutter it. If a part goes missing for 30 seconds, or the checksum does not match, the reader gets coded message damaged instead of a wrong text.
What it is not
It is not encryption. There is no key; anybody with the addon - or anybody who has read this far - can decode it. It is a way to carry exact text through a channel that was built to destroy it, and it keeps the conversation out of the way of people who do not care about it. It also only works between the same client: the Forever client scrambles Common differently from 1.12 (the language-id multiplier), so the tables, and therefore the alphabet, differ.
Playing by the rules
A few lines on what the addon does not do, because with anything that touches chat it matters:
- It reads only what the client already shows in chat. No memory reading, no packet sniffing, nothing in the client is patched.
- It only ever sends a say or yell from your key press. The Forever client blocks say from a timer anyway, and an addon that chats on its own is exactly what nobody wants.
- The shared glossary goes as addon messages to your guild and group only, never to strangers, and a received word is taken only if it is a real reading of its fake word.
Wrap-up
What looked like random gibberish turned out to be a decades-old string hash and a handful of short word lists - simple enough to reproduce in a few lines of JavaScript, and still impossible to undo, because the lists are so short that every fake word stands for hundreds of real ones. That combination is what makes the addon possible: you cannot read the other side, but you can choose your words so they read you.
If you play on Forever, give Forever Tongues a try, and bring your best Orcish to the Discord.