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:

Output
Lo Ne Ve Ru An Ti Me Lu Re Se Va Ko

Common, three letters:

Output
Vil Bor Ras Gol Nud Far Wos Mod Ver Ash Lon Bur Hir

So 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? and lol. all read bur.
  • Numbers are scrambled too: in Common 1 reads o and 100g reads nuff, so you cannot even pass a price or a coordinate.
  • Long words become compounds: eighteen x in a row read adorstaerume.

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:

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:

JavaScript
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 lol and LOL land 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 lol sits 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 % 300 is 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:

JavaScript
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:

DecoderWords rightWhole sentences right
Word frequency only33 %0-2 %
+ a local LLM picking from the top 25 candidates35-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:

How Forever Tongues works

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.

The Heard page of the book

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 iteveryone of the other factiononly Forever Tongues users
What gets acrossthe words the language can spellyour exact text
Needs the addononly youyou 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.

The Phrases page of the book

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:

Symbol01234567...64 (marker)
You type12360121g00...000000t
The other faction readsaglnoaggiha...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:

Output
text      h        i
bytes     01101000 01101001
6 bits    011010 000110 1001(00)
symbols   26     6      36          + checksum (104 + 105) mod 64 = 17

Each 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:

Output
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.