Let’s start with a question that sounds slightly stupid:
In a line of game text, which parts are actually meant for humans?
Take this line:
Welcome back, {player_name}!\nHP: %03d
Humans see “Welcome back” and “HP.”
The game, quite obviously, sees something more complicated:
{player_name}is a variable. At runtime, it needs to be replaced with the player’s name. Otherwise, every player gets the exact same name:{Player Name}.\nis a line break, not the letter n. Please do not pretend you didn’t see the backslash in front of it...%03dis a numeric placeholder. It does not mean “three percent D,” because players have no idea why D is three percent of anything.
They are crammed into the same line, and they all look like characters. But they are fundamentally different kinds of content.
To a translator, this is just one line of dialogue.
To a game engine, it is a tiny contract with binding terms: some parts may be changed, while others will crash the game over a single missing symbol.
Then we throw the entire line into an AI model and give it a very serious warning:
Please translate only the text that humans can see. Do not touch anything else.
The model politely agrees and says, “Sure, I’ve got it.”
Whether it caught anything at all—and what sort of pose it struck while doing so—is another matter entirely.
01 First, AI Is Not Trying to Sabotage Anything. It Just Doesn’t Know What It May Touch
AI may recognize that {player_name} looks like a variable, but it has not actually run your game. It does not know what will really happen if one bracket goes missing. To the model, the variable is still part of the input text, which means it still belongs to the category of things that can be rewritten.
So things like these happen every day:
{player_name} → {Player Name}
%03d → %3d
\n → \\n
{b}...{/b} → {b}...{b}
Sometimes it translates a variable name. Sometimes it helpfully tidies up the spacing and punctuation. Sometimes it decides that two strange-looking tags must be duplicates and very enthusiastically deletes one for you.
Even if you tell the AI which engine you are using, it may indeed recognize most of the variables and tags. Recognizing them is one thing. Following the same rule strictly for the next forty thousand lines is another.
Once the context gets long enough, your earlier warning—“Don’t touch these”—is pushed into a dusty corner of its memory. And game developers inevitably add their own custom tags or peculiar syntax. It is perfectly reasonable that the AI has never seen them before.
Compared with a traditional translation engine, AI is also “alive.” It may start thinking for itself:
“This space looks unnecessary. Delete!”
“Wait, aren’t these two tags duplicates? Delete!”
“Is this actually a variable name? Never mind. I’ll translate it.”
So yes, it may know the rule. Things still slip through.
Individually, none of these changes looks particularly dramatic.
Put the text back into the game engine, however, and the results may include but are not limited to:
- The player’s name vanishing into thin air.
- The number format turning into complete nonsense.
- The UI displaying the literal characters
\n. - A sentence charging straight through the edge of the dialogue box and disappearing into the horizon.
- The next several thousand words suddenly becoming bold or red.
- Or the most straightforward outcome: the game throws an error and refuses to launch.
And this particular form of confusion is not exclusive to AI.
At line 3,000, late at night, the human prefrontal cortex is equally capable of a routine shutdown followed by an immediate slip of the hand.
A translation tool can also break things if it handles escape sequences incorrectly.
When it comes to working memory, human brain cells are not much more reliable than a large language model. AI hallucinates. Humans do too, and humans can be spectacularly confident while being wrong.
This gets even better when several people are working on the same translation project. “I thought this was what we agreed on?” and “Oh no, I missed a bracket” occur with a probability of roughly 100%.
Before I started building Goblin Forge, I was already working on a collaborative game translation project.
I once spent an entire day manually checking more than 40,000 lines to see whether a line-break marker was missing half a bracket, and whether player_name had been translated into “Player Name” again.
I checked each line with a perfectly calm expression while my brain screamed:
We have said this countless times. How are this many things still missing?
That was when I became increasingly convinced that “protecting code” cannot depend on AI, and it cannot depend on humans either. Once text has passed through importing, editing, translation, batch replacement, or exporting, it can be damaged at any stage.
If none of us is particularly reliable, we need a different approach.
02 So, Does Adding More Warnings to the Prompt Help?
Yes, but not enough.
You can absolutely put this in the prompt:
Preserve all variables, placeholders, tags and escape sequences exactly.
And it will indeed lower the chance of an error.
The problem is that “a lower chance” is not as useful as humans imagine when the foundation of a game is this fragile. Sooner or later, uncontrollable variables will make the model produce a new variation, and it will blow up the foundation again without telling you.
Change the model, and the odds change.
Make the sentence longer, and the odds change.
Put a piece of natural language in the context that happens to look like code, and the result changes again.
Worse, even if it behaves like a flawless model employee for the first 999 lines, whether it makes a mistake on line 1,000 is still a separate event.
And it may fail differently every time: translate a variable name here, swallow half a bracket there, add an extra backslash somewhere else. The same variable may even receive two different translations in two different runs.
When the errors are this disorderly, a human does not even know where to start looking.
03 The Ultimate Blast Shield: Give the Code a Read-Only Buff
Human working memory has already proved unreliable. So has a model with its alignment dialled all the way up. The obvious answer is to stop treating everything in the line as ordinary text.
We need to peel the untouchable parts away from the sentence, so the AI cannot reach them and a human cannot casually slip and edit them either.
In a line of game text, the only part that truly needs editing is the part meant for humans.
Variables, placeholders, tags, and line breaks should be identified separately and locked down.
Changing their color is not enough. That is merely a visual reminder—and it is mostly a reminder for the human, not the AI.
Real protection means making these parts read-only.
They can be viewed and moved as a whole, but they cannot be split open so that half a character gets casually changed.
While translation is in progress, they stay exactly where they belong. Humans edit human language. AI is only allowed to process human language.
Finally, compare the structure of the source and translation one more time, like checking the parts before sealing a parcel: everything that should be there is still there, and everything still has the same name.
04 But Tools Can Still Get It Wrong
Different game engines use different syntax. Add plugins and the strange little languages invented by individual developers, and things become chaotic very quickly.
No matter how many patterns a tool knows in advance, it cannot automatically guess what every game developer was thinking.
Make a rule too broad, and it locks text that should have been translated. Make it too narrow, and real code slips through.
The safer approach is to take a few dozen lines containing all kinds of strange symbols and test those first. Once they look right, move on to a project containing thousands or tens of thousands of lines.
Please resist the urge to hand over the entire project on the first attempt.
When a rule is wrong, the tool will not necessarily complain. It may confidently translate all forty thousand lines for you.
By the time you have to redo everything, the suffering belongs entirely to you. I have no further comments on how I obtained this information.
05 Whatever Tool You Use, Follow These Rules for Survival
Whether you eventually choose a spreadsheet, a script, a chatbot, or some advanced CAT tool, remember one thing:
Do not trust your memory.
- Always make a backup first, unless you genuinely want to spend the middle of the night staring at disk-recovery software in a continuous cold sweat.
- List everything that must not be touched, including but not limited to variables, placeholders, tags, escape sequences, and script commands.
- Translate a small sample first—preferably 50 to 100 lines containing every strange symbol you can find.
- Compare the structure of the source and translation. Check the counts, names, and matching pairs.
- Only then process the full batch. Please do not reverse this order unless you consider repeatedly reinstalling a game a form of entertainment.
- Finally, test it in the game.
Many people assume that if the file was written successfully and the game launches, the job must be finished.
Reality tends to look more like this:
Every placeholder is present. The player opens the dialogue box, and the text immediately breaks through the atmosphere.
A grizzled middle-aged man opens his mouth and starts talking like a coy teenage girl.
Or, more quietly, the file appears flawless until the player triggers one very specific story branch, at which point the game dies on the spot with admirable efficiency.
Never treat “translation complete” and “testing complete” as the same thing.
You still need to open the game and look—probably more than once. Otherwise, the time you save now will return with interest when the rework begins.
06 So I Built This Physical Shield into Goblin Forge
After being repeatedly ground into the floor by both AI memory and human memory, the first problem I tackled in Goblin Forge was this one.
Once a file is imported, the system automatically identifies variables, tags, placeholders, and escape sequences, then packs them into read-only “code capsules.”
In the translation editor, each capsule is a single, indivisible object. You can see its original characters or switch the display to see what it means.
You can move, add, or delete an entire capsule, but you cannot split it open and change half a character inside—unless you deliberately change the default settings and templates.
This physically prevents things like deleting one bracket from a pair or losing half a tag.
When translation is finished, Goblin Forge compares the source and translated structures again, as if checking a parts list.
If a part is missing, duplicated, or out of place, the corresponding line is marked so you know where to look during editing and review.
Of course, every game has its own peculiarities. Alongside the common formats and engine templates built into the software, you can add custom protection rules for an individual project.
The first time you use it, I still recommend testing a small piece of real text to see whether anything slipped through the rules.
From identification during import to locking during translation and structural checks afterward, the steps are connected inside Goblin Forge.
I did all this because I never want to spend another entire day fishing for a missing bracket in forty thousand lines of text.