gaforum

Field guide · Game development

Game Localization Workflow: From String Table to Release

A game localization workflow is the sequence that takes every piece of player-facing text out of code, hands it to translators with enough context to get it right, and puts it back into the build where it can be tested in each language. Most failures happen at the handoffs: a placeholder in the wrong order, a button that cannot hold a longer word, a plural that only works in English.

This guide follows the string from the engine to the store page, using documentation from Godot, Unity, CLDR and Steamworks.

Key takeaways

  • Localization starts in the codebase: strings must live in tables with stable keys before any translator sees them.
  • Named placeholders and translation contexts cost minutes to add and save weeks of rework.
  • Plural rules differ by language, and CLDR defines up to six categories, so never hardcode the one-or-many test.
  • Pseudolocalization finds untranslated strings and overflowing UI before a single translation exists.
  • Store languages are a separate list from in-game languages; Steam distinguishes full platform support from game-support-only.

Decide scope before you touch a string

The first decision is which languages you will support and at what depth. Text-only support is cheaper than adding voice, and voice is cheaper than recording again after a script change.

Write the scope per language: interface, subtitles, voiced dialogue, store page, and community support.

Steam draws a useful line here. Its documentation separates Full Platform Supported languages, where the Steam client and store are themselves translated and which are the only ones supported by the Steamworks APIs, from Game Support Only languages, which a developer can list on the store page for a game but which are not supported in the APIs.

Those API language codes are not always what you expect: Simplified Chinese is schinese, Latin American Spanish is latam, and Brazilian Portuguese is brazilian.

One more note from the same page: Arabic is available for game depots and game language selection, but the Steam interface itself is not translated into it. If a language is on your list, check how every store and platform you ship on treats it, not just your engine.

Move text out of code into string tables

Translators cannot work on text that is buried in scripts. Every player-facing string needs a home in a table, with a key that stays the same when the English wording changes.

Both major engines support this directly. Godot can load translations from CSV spreadsheets or gettext PO files, and its controls such as Button and Label will fetch a translation automatically when their text matches a translation key.

Unity's Localization package covers string localization and can import and export XLIFF, CSV and Google Sheets.

Pick key names that describe place and purpose, not wording. A key such as SHOP_BUY_CONFIRM survives a copy edit.

A key that is the English sentence itself breaks every translation when someone fixes a typo, unless your tool matches by context.

Godot's documentation also notes the automatic key lookup has a downside: a label showing a player name could accidentally match a key. It offers an Auto Translate mode setting to disable that on specific nodes, which is the kind of switch to check for in whichever engine you use.

Write strings that survive translation

Most translation bugs are authored into the source. A short pass over the English text prevents a large share of them.

Godot's guidance on placeholders is concrete: use named placeholders such as {character} picked up the {weapon} rather than positional ones, because translators can then reorder them to sound natural. With positional placeholders the locations can move but not the order, which will not work in some target languages.

Add a context when the same English word has different meanings. Godot's own example is Close, as in closing a window, versus Close, as in a short distance, given different contexts so a target language can use different words.

In your table, add a short note for translators on every string where the meaning is not obvious from the words alone, such as who is speaking, where it appears and the character limit.

Avoid assembling sentences from fragments. A sentence built from three joined pieces forces a word order that many languages do not share.

Keep a whole sentence in one string, even if it duplicates a few words.

  • One idea per string, whole sentences only.
  • Named placeholders, never positional ones.
  • A context note on short or ambiguous strings, such as buttons and menu labels.
  • No text baked into images or textures; if it is unavoidable, keep a layered source file.
  • No concatenated fragments to build a sentence.

Handle plurals the way the language does

The English rule of one for singular and everything else for plural does not carry over. The Unicode CLDR defines plural categories named zero, one, two, few, many and other, where other is required, and says languages vary: some have two forms, some one, some several.

Its sample bug report on Ukrainian shows why this matters, with different forms for 1, 2, and 5 of the same noun, plus another for fractions.

Both engines have a mechanism. Godot's tr_n function takes a singular string, a plural string and a count, and lets the target locale decide which form to use; it is meant for positive or zero whole numbers only.

Unity's Localization package offers Smart Strings, described as logic that replaces placeholders and plurals automatically. Use these from the first string that contains a number.

Retrofitting plurals into a shipped game means touching every counter, timer and inventory line.

Test the interface before any translation exists

Pseudolocalization replaces your source text with altered, lengthened versions that stay readable. Godot's documentation lists what it checks: it lets you spot strings that were never made localizable, it shows UI elements that cannot fit long strings, and it tests whether the font covers the characters you will need.

The same page warns that it is not an effective test for CJK or right-to-left support, because the aim is to keep the original text readable. Unity's package lists pseudo-localization too, as a way to test adaptation at an early stage, before you add translations.

Run it in the first week of UI work, not the last. Layout fixes cost little when the screen is new.

They cost a lot when twelve screens are already locked.

Godot also advises that the same text can vary greatly in length between languages, and suggests Containers, anchors and the wrapping options on Label to absorb it. Use those in place of fixed-size boxes.

Pick fonts and locale rules early

If no text appears after switching language, the font is the usual cause. Godot's documentation notes that its default project font supports only a subset of Latin-1, which cannot display Russian or Chinese, and points to Noto Fonts as a multilingual resource.

Check every language against your art direction font, since a stylized display face often lacks the characters.

Separate language from locale. Godot's example is en_US and en_GB: the same language, but different spelling, vocabulary, and units or currencies.

For most indie games a language code is enough, and you can add regional variants where it matters, such as Latin American versus European Spanish, or Brazilian versus European Portuguese. Dates, numbers and currencies should come from locale-aware formatting, not hand-built strings.

Run the translation loop

The loop is export, translate, review, import, test, and repeat. A translation management system sits in the middle so that source text changes flow out and finished translations flow back without email attachments.

Crowdin's site, for instance, lists Git integrations for automated content sync, in-context preview of translated UI, and built-in QA checks for consistency, length limits and placeholders. Comparable platforms are covered in Best Game Localization Platforms.

Whichever tool you pick, set these rules before the first batch goes out.

  1. Freeze the source text for the batch and tag it with a build number.
  2. Export strings with context notes, character limits and a glossary of game terms.
  3. Have a translator who plays games, not just a general linguist, do the first pass.
  4. Run automatic checks for missing placeholders, length overruns and broken tags.
  5. Import the result into a branch build, not straight into the main build.
  6. Have a reviewer in each language check it in the running game, not in a spreadsheet.
  7. Merge, and record any glossary decisions for the next batch.

Keep the glossary alive. Character names, ability names and faction terms should be decided once and reused across every batch and every language.

Test in the build with real screens

Spreadsheet review catches typos. It does not catch a string that overflows its button, wraps behind a portrait, or reads wrongly once its placeholder is filled in.

Have reviewers play the game in their language on the target hardware, with a checklist per screen.

Look for four failure types: truncated or overlapping text, wrong or missing characters, placeholders showing raw braces or percent signs, and meaning that is off because the translator never saw the screen. Log each with a screenshot and the string key so the fix goes to the right person.

  • Every menu and HUD element in each language, at the lowest resolution you support.
  • The longest string in each table, shown in context.
  • Every counter with plural forms at 0, 1, 2, 5 and 21.
  • Controller prompts and button glyphs, which sometimes change by region.
  • Subtitles at the fastest line of dialogue.

Localize the store page and keep it in sync

The store page is player-facing text too, and it decides whether anyone gets as far as your game. Steam's visibility documentation says players prefer games they can understand, and that Steam is more likely to show a game to players who speak a language the game supports, so translating the game into more languages makes it more accessible and may help it be shown.

Store descriptions, capsule text, trailers with subtitles and update notes should follow the same freeze-and-handoff routine as the game.

Put each language on the release checklist as its own line, with an owner. When an update changes strings, decide before the update whether the new text ships in English first with a note, or waits for translation.

A mixed-language screen is a known tradeoff, and choosing it on purpose beats stumbling into it.

Frequently asked questions

When should localization work begin on a new game?

Begin when the first UI screen exists, not at the end. String tables, named placeholders and plural handling are cheap to build in from the start and expensive to add later. Translation itself can wait until text is stable, but pseudolocalization of the layout can run from the first week.

Do I need a translation management system?

For one or two languages and a few thousand words, a shared spreadsheet and a disciplined export can work. Once you have several languages, frequent text changes, or outside translators, a platform that tracks changes and checks placeholders earns its place. Compare options in the localization platform ranking linked above.

What is pseudolocalization and why use it?

It is a test mode that swaps your text for altered, longer, still readable versions. It shows which strings were never made translatable, which UI elements cannot fit longer text, and whether your font has the characters. Godot and Unity both document it, and it works before any real translation exists.

Which languages does Steam support for games?

Steamworks documentation lists Full Platform Supported languages, where the Steam client and store are translated and the APIs apply, and a separate Game Support Only list that developers can pick when saying which languages a game supports. Check the current Steamworks page before planning, because the lists can change.

Why do plurals break in translation?

Because many games use an English-only test of whether a count is one or not. The CLDR defines categories such as one, few, many and other, and languages use different sets of them. Use your engine's plural function or a smart-string feature so each language applies its own rule.

Sources