Localization-Friendly Writing for Game Scripts | Skrib
Seven hidden dependencies in your strings, why concatenation breaks translation, how to write context notes, interface length limits and when to involve loc.

The usual guidance arrives as a list of prohibitions. Avoid idioms. Keep sentences short. Don’t concatenate. Leave room for expansion.
All correct, all presented as a tax the writer pays to a downstream department - which is why writers absorb the rules, resent them, and break them the moment a line would be better.
There’s a more useful way to hold it, and it starts with an observation about your own language.
English is unusually permissive, and you’ve been unconsciously exploiting that permissiveness on every line you’ve ever written. It has almost no grammatical gender. Adjectives don’t inflect. Nouns barely decline. Word order is rigid enough that you can slot a variable almost anywhere and get a sentence.
None of that generalises. The failures aren’t caused by difficult English - they’re caused by English being easy in ways most languages aren’t. Once you can name what you’re depending on, the rules stop being arbitrary.
It’s one of the production constraints covered in our video game writer’s handbook.
What is localization-friendly writing?
Localization-friendly writing is source text authored so it can be translated accurately and fit its interface in every shipping language - avoiding assembled strings, ambiguous fragments, culturally specific references and constructions that only work in English grammar. In practice it also means supplying translators with the context a spreadsheet row doesn’t carry.
The industry spells it localization almost universally, often shortened to loc.
Seven dependencies you didn’t know you had
Each of these is something English lets you ignore and most target languages don’t.

The gender one causes the most silent bugs. A string like You found it. It’s heavy. is fine in English and unresolvable in French, because it and heavy both need to agree with a noun the translator can’t identify from the row in front of them. They’ll guess, and roughly half the time they’ll be wrong, and it will ship.
The plural one is the most under-known. English has two forms - one and other. The Unicode CLDR plural rules, which most engines follow, define up to six categories, and Arabic uses all of them. A string with a bare {n} needs the engine to support plural variants, and the writer to have provided them.
The formality one is a writing decision, not a translation decision. Whether two characters address each other formally is characterisation, and English hides it entirely. If nobody decides, translators decide - inconsistently, across a dozen languages, for every relationship in your game.
Concatenation is the main event
If you fix one thing, fix this.
Assembled strings are the single largest source of localization defects, and writers create them without ever seeing the code.
"You have " + count + " " + itemName + "s."
Every element there is a landmine. The plural s doesn’t work in most languages. The word order is fixed to English. itemName may need a different case form. The article that should precede it doesn’t exist. In several languages this sentence cannot be assembled from those parts at all.
Write whole strings. Provide variants rather than variables where you can:
STR_PICKUP_ONE "You pick up a health pack."
STR_PICKUP_PLURAL "You pick up {n} health packs."
Where variables are unavoidable:
One variable per string where possible
Never split a sentence across concatenated fragments
Name variables meaningfully - {playerName} not {0}
Note the variable’s type and gender in the context field
Never assume position - translators must be able to move it
A related trap: reusing strings. The same English word serving two functions saves nothing and breaks translation. Fire as a verb and Fire as an element need separate string IDs, because most languages have no word that covers both.
The translator’s problem is context, not vocabulary
Professional translators are not struggling with your English. They’re struggling with a spreadsheet row that arrived out of order, with no speaker, no addressee, no tone and no idea whether the word is a noun or a verb.
What a translator cannot see from a string:
Who is speaking, and to whom
Whether the tone is sincere, sarcastic or threatening
Whether a fragment is a full sentence or part of a UI element
What the variable will contain
Whether the maximum length is 20 characters or unlimited
Whether a term is a proper noun that should not be translated
All of that is the writer’s deliverable, and it costs a line per string.
Writing the context note
Write it while you write the line, not in a pass afterwards. A pass afterwards never happens.
A workable note format:
ID: DLG_MARA_BETRAY_03
Speaker: Mara (f), 40s, military
To: Player (gender variable)
Tone: Controlled anger, not shouting
Context: Player has just sided with her brother
Type: Spoken dialogue, VO
Max chars: none (subtitled)
Notes: "Concord" is a faction name - do not translate
The five fields that matter most are speaker gender, addressee gender, tone, whether the text is UI or spoken, and any do-not-translate terms. Those five prevent the majority of avoidable errors.
Terminology belongs somewhere central, not in every note. A world bible’s terminology section is effectively the localization contract for a project - approved spellings, proper nouns, banned terms, pronunciation for VO. World Bibles for Game Studios: Documenting Lore at Scale covers building it.
Length and the interface
Text expansion is the constraint that produces the most visible failures, because they’re on screen.
Plan for 30% expansion from English as a working default, more for short strings. A single English word can double or triple in German or Finnish, and a button label with no headroom will clip, wrap or overflow.
Practical responses:
Set and respect character limits per string, and put them in the note
Write short in the source - every character you save is multiplied across languages
Avoid puns in constrained spaces - a compressed joke has no room to be rebuilt
Flag anything in a fixed-width element so it gets tested first
Never solve overflow by abbreviating in translation - that’s a design fix, not a loc fix
Barks are a special case. Their pools are recorded in every shipped language, which multiplies both cost and schedule - the sizing decisions in barks and ambient dialogue look different once you count them per language.
Culture, not just language
Translation handles words. Localization handles everything else, and some of it is your problem at the drafting stage.
Idioms and metaphors. Anything built on a domain that isn’t universal - baseball, cricket, specific weather, a national institution - will be replaced or lost. Not fatal, but know when you’re spending it.
Wordplay. Puns don’t survive. A translator will invent a new joke or drop it. Both are acceptable outcomes if you flagged it; neither is if the pun was load-bearing for a puzzle.
Humour built on register. Comedy that depends on formal-versus-casual speech can land harder in languages with a formality distinction - occasionally a gain rather than a loss.
Regional sensitivities. Symbols, historical references, gestures, colour associations, and content that affects age ratings in specific markets. These decisions belong to production, but a writer who raises them early saves a late rebuild.
Names. Invented names are frequently unpronounceable, unfortunate or already meaningful in another language. A quick check across your shipping languages costs an hour and occasionally saves a rename.
What not to sacrifice
The necessary counterweight, because writing defensively for translation can produce bland English.
Be flexible about mechanism, not about voice. The rules above are about how a sentence is constructed, not about how much personality it carries. A character can be sharp, strange and specific in fully localizable text.
Spend complexity where it survives. A pun in a bark that fires four hundred times is a bad trade. A pun in a named character’s signature moment, flagged for the loc team with a note explaining what it’s doing, is often worth keeping - translators are writers, and given intent they’ll build something that works.
The thing to avoid is silent complexity - a construction that depends on English grammar with nothing marking it. Flagged complexity is a conversation. Unflagged complexity is a bug.
When to involve localization
Almost always later than it should be.
At concept: which languages are shipping, and whether any require content changes. This determines things as basic as whether your protagonist has a fixed gender.
At first draft: a loc review of your string structure, before ten thousand rows exist in the wrong shape.
During production: a channel for translator questions. Queries mean they’re doing it properly.
At string freeze: everything locks. Changes after this are pickups, and they cost per line, per language.
During LQA: localization QA plays each language build looking for overflow, wrong gender, broken variables and context errors. Budget for fixes; there will be some.
The expensive mistake is treating localization as a phase at the end. String structure decided in month two determines what’s possible in month twenty, and by then it’s a refactor rather than an edit.
Where it goes wrong
Concatenated sentences. The main event.
Missing context. Translators guessing, half-right.
Reused strings. One English word, two meanings, one ID.
No plural variants. {n} with an English s.
Undecided formality. Twelve languages, twelve inconsistent choices.
No character limits. Overflow discovered in LQA.
Do-not-translate terms unmarked. Faction names translated into nonsense.
Loc involved at the end. Structural problems discovered when they’re a refactor.
Writing strings and their context together
Localization work has an awkward shape: the text is rows in a table, the context is prose, the terminology is a third document, and the three usually live in separate applications. Context notes are what prevent most avoidable errors, and they’re precisely what gets skipped when writing them means opening something else.
Skrib fits that shape. String tables move in and out as .csv and .xlsx, which is where this material actually lives, and the Plan is a canvas with no page edge where terminology, speaker notes and do-not-translate lists can sit beside the strings you’re writing. The Library keeps every project and imported file searchable, so checking how a term was rendered two years ago takes seconds.
Scope note: Skrib isn’t a translation management system. It doesn’t handle translation memory, vendor workflow, string freeze or LQA tracking, and it doesn’t replace a TMS. It’s where the source text and its context get written before they reach one. You can start free.
Frequently asked questions
What is localization-friendly writing? Source text written so it can be translated accurately and still fit its interface in every shipping language - avoiding assembled strings, ambiguous fragments and constructions that depend on English grammar, and supplying translators with the context a spreadsheet row doesn’t carry.
Why is string concatenation a problem for translation? Because it assumes English word order, English pluralisation and uninflected nouns. A sentence assembled from fragments frequently cannot be reassembled in another language at all, and it’s the single largest source of localization defects.
How much longer does translated text get? Commonly 20–35% longer than English, and short strings can expand much more - a single word may double or triple in German or Finnish. Planning around 30% expansion is a reasonable working default for UI elements.
What context do translators need? Speaker and their gender, addressee and their gender, tone, whether the text is spoken or UI, any character limit, what variables will contain, and which terms must not be translated. Those few fields prevent the majority of avoidable errors.
Do puns and idioms have to be avoided entirely? No, but spend them deliberately. Wordplay doesn’t survive translation intact, so a pun in a frequently repeated line is a poor trade while one in a signature moment can be worth keeping - provided it’s flagged with a note explaining what it’s doing.
When should localization be involved in a game’s development? At concept, to confirm shipping languages and any content implications, and again at first draft to review string structure. String architecture decided early determines what’s possible later, and fixing it after thousands of rows exist is a refactor rather than an edit.


