Game translation and localisation turn a playable build into a language- and market-appropriate experience. This involves more than dialogue: games contain menus, items, quests, tutorials, system messages, achievements, subtitles, player-generated values and sometimes recorded performances. A successful translation must work inside the game, not just read naturally in a spreadsheet.
This developer-focused guide covers the workflow from source preparation and string extraction through translation, Unity or Unreal implementation, linguistic quality assurance and release updates. It consolidates TranscribeLingo’s earlier overlapping articles on gaming-industry translation and game localisation best practices. The practical examples are hypothetical; they are not claims about named games or customers.
For an introduction to the concept, see what game localisation means. If you are evaluating a partner for an active game, see game localisation services. This guide concentrates on implementation, translation review and testing.
Game translation vs localisation: what changes?
Translation expresses the source text in a target language. Localisation also adapts the supporting systems and player experience: word length, terminology, font coverage, date or currency display where relevant, region-specific conventions, interface direction and audio timing. Cultural adaptations should be considered deliberately rather than assuming every storyline, symbol or mechanic needs changing.
| Component | Translation task | Localisation or implementation task |
|---|---|---|
| Character dialogue | Meaning, personality, relationships and tone | Place dialogue in the correct event/branch; validate subtitles and voiced timing |
| Menus and HUD | Buttons, controls, inventory and status labels | Text expansion, responsive layout, fonts and input prompts |
| Quests and tutorials | Objectives, hints and branching conditions | Ensure translated instructions still match the player’s available actions |
| Dynamic strings | Item names, quantities, player names, system variables | Preserve placeholders and language-appropriate plural and word order |
| Cinematic and recorded content | Scripts, subtitles, signs, spoken performances | Timing, voice direction, caption metadata and region-specific assets |
| Store and player support | Descriptions, achievements, update notes and help | Platform requirements, market-facing copy and consistency after patches |
1. Prepare the game for localisation before translating
Treat localisation as a production feature. If the game still builds visible sentences from small concatenated fragments, hard-codes menu labels in assets or duplicates text in scripts, translating the string list may produce broken target-language sentences. The development team should first identify all player-facing strings and the assets containing language.
- Define locales: choose precise targets, such as French for France or Canadian French, Brazilian Portuguese or Arabic for the intended region.
- Inventory content: include game scenes, cutscenes, menus, tutorials, quests, notifications, accessibility prompts, achievements and downloadable content.
- Stabilise identifiers: give each translatable entry a persistent key rather than relying on the current English phrase as the only reference.
- Supply context: record speaker, intended audience, scene, text limit, screenshot, gender or relationship where relevant, and whether a string is a button or a message.
- Agree constraints: identify terms and names that must not be translated, external ratings or legal issues for review, and the required delivery format.
- Create ownership: name the developer, language lead, narrative lead, audio producer and QA owner responsible for sign-off.
Localisation should begin while a game is being built, not only at release. Early planning lets the team test layouts with longer placeholder strings and establish a reproducible process for importing translations into later builds.
2. Extract and organise strings without breaking the game
Use a resource-based approach such as engine translation tables or external localisation resources rather than manually translating values in compiled game files. Depending on the engine and pipeline, common formats include CSV, JSON, PO and XLIFF. Not every engine natively imports every format; the project needs an explicit conversion and validation step.
An export should contain a stable ID, source text, target text and relevant context. Store resource files in version control and define who is authorised to edit them. For complex games, separate player-visible content by functional domain such as UI, quests, dialogue and live operations; avoid silently reusing the same string identifier for different meanings.
| String ID | Source text | Context for translator | Engineering check |
|---|---|---|---|
| ui.inventory.empty | Your inventory is empty. | Inventory panel when no items exist | Fits empty-state card on console and mobile |
| quest.reward | You received {count} coins. | Reward banner; count varies by language | Retain {count}; use locale-aware plural rules |
| combat.retreat | Retreat! | Urgent action command, not noun | Confirm tone and on-screen length |
| npc.greeting | Welcome back, {playerName}. | Friendly NPC speaking to player | Retain token; handle name order and grammar |
| settings.audio | Audio | Settings category, not an in-game sound effect | Translate with UI context and stable key |
Never ask translators to reconstruct meaning from keys such as menu_023 alone. A build screenshot, character description and maximum display width can prevent costly misunderstanding.
3. Preserve placeholders, pluralisation, gender and context
Many UI errors are caused by string assembly, not bad translations. A source such as {playerName} obtained {count} item(s) may need different grammar, word order and plural forms in the target language. Do not split this into separately translated words and concatenate them in English order.
- Keep tokens intact: validate named placeholders, variable syntax and markup such as rich-text tags before and after import.
- Use plural categories: different languages distinguish zero, one, few, many or other quantities; an English singular/plural switch may be inadequate.
- Add disambiguating context: “Charge” could mean an attack, power level or payment; “Save” could refer to progress or rescuing a character.
- Avoid grammatical assumptions: player names, character gender or optional nouns may change the correct ending of a translated phrase.
- Protect functional strings: button glyphs, key bindings, URLs, command names and format specifiers need to survive localisation.
The Godot internationalisation guidance gives concrete examples of named placeholders, translation contexts and language-specific pluralisation. The principles apply across engines, though the exact APIs differ.
4. Build terminology and narrative guidance
Develop a style guide and glossary that distinguish established in-world terminology from generic UI language. A character may use a sarcastic register while the accessibility menu needs neutral instructions. Include examples of character relationships, formality, jokes, invented spell names, factions and fictional locations where the target-language choice affects continuity.
A translation memory can help when quest systems, inventory descriptions and recurring announcements repeat across a game or downloadable content. However, a stored translation can also repeat an earlier error or appear in the wrong context. Review matches rather than accepting them automatically.
Read our guide to translation memory for match types, ownership and reuse. Keep language assets versioned and assign clear responsibility for glossary updates after narrative or gameplay changes.
5. Localise UI, menus, tutorials and quest logic
A translated sentence can be longer than its English source and may no longer fit a button, overlay, item tooltip or controller prompt. Design for variable text length: allow wrapping and flexible containers where appropriate, keep readable font sizes and avoid clipping within scrolling lists or popups.
Test the real state combinations, not just static screenshot captures. A quest might display “Find 1 crystal” and “Find 10 crystals” using different plural rules; a combat message might appear alongside a long user name. Some languages also require bidirectional text shaping and different arrow conventions. Test at the smallest supported resolution and under console safe-area constraints where relevant.
Tutorials deserve particular attention. Verify that the translated instruction names the correct action and corresponding key or controller icon. If the gameplay inputs change by platform or user remapping, the text should use a dynamic input reference instead of a hard-coded English key.
6. Translate dialogue, subtitles and voiceover
Game dialogue combines meaning, performance and timing. Translate with character biographies and gameplay context, then review whether the target-language line still fits its cinematic or combat use. Short barks, environmental dialogue and branching conversations require different constraints from a long scripted cutscene.
- Scripts: retain stable line IDs, speaker identity, emotional direction, pronunciation notes and branch conditions.
- Subtitles: review readability, timing, line breaking, speaker changes and whether the voice track actually matches the approved line.
- Dubbing and voiceover: confirm casting direction, takes, filenames, audio technical requirements and triggers before recording begins.
- On-screen text: localise signs, maps, tutorial screenshots and text embedded in cinematic video assets.
- Accessibility: provide needed speaker and sound information in captions where appropriate; do not assume a bare script serves every player.
These production details are examined separately in our video game voiceover guide. Narration, dubbing, subtitling and gameplay-localisation assets should be priced and approved as distinct tasks where their scope differs.
7. Unity game localisation workflow
Unity’s current localisation documentation describes a locale-aware runtime, translation table collections and dynamic Smart Strings. Depending on the Unity Editor version and package, the implementation can reference localised entries from scripts, components or UI bindings and load locale-specific assets such as textures, audio or fonts.
- Configure the supported locales and a fallback language for your project.
- Create table collections with stable keys and translated values for UI, dialogue and other content.
- Use Smart Strings or the relevant formatting feature for values, conditions and plural forms, preserving variable arguments.
- Bind gameplay UI and other player-facing text to localised entries rather than hard-coded English strings.
- Create locale-specific assets when graphics, audio or typography need alternate versions.
- Test language switching, missing-entry fallback and asset loading in an actual build.
For current Unity Editor 7000 documentation, see the official resource table structure, including shared keys, entry metadata and per-locale resource tables. Older Unity versions use different packages and UI terminology, so follow the documentation corresponding to your exact project.
8. Unreal Engine game localisation workflow
Unreal Engine provides a Localization Dashboard to manage targets, source culture, cultures and an iterative sequence to Gather → Export → Import → Compile translation resources. The Dashboard is labelled experimental in the documentation but is described as stable and used internally. Project setup and engine versions should be checked before automating it.
- Define a Game localisation target and its appropriate loading policy.
- Specify which source code and assets contain user-facing text to gather.
- Set the native culture and desired target cultures.
- Gather source text, export for translation, then import reviewed translations using the intended workflow.
- Compile translated resources and package them with the applicable build or culture content.
- Test runtime language selection, fallbacks, assets, text rendering and every necessary gameplay screen.
In Unreal C++, user-facing content should generally use the engine’s localisation-aware FText rather than plain strings that are never gathered. Refer to the official Unreal text localisation guidance for text history, string tables and culture-specific formatting.
9. Test text expansion, fonts and right-to-left presentation
Before paying for every target-language asset, create a pseudolocalised build that deliberately lengthens strings and introduces characters outside the basic English alphabet. This reveals hard-coded text, missing string extraction, narrow UI containers and fonts that cannot display diacritics. It does not replace actual target-language testing, especially for Chinese, Japanese, Korean or right-to-left scripts.
Microsoft’s internationalisation testing guidance recommends pseudolocalisation and, where relevant, pseudomirroring ahead of full localisation. Its localisation testing checklist also identifies clipping, concatenation, pluralisation, fonts and mirroring as problems to verify in the translated interface.
For Arabic or Hebrew, check shaping, bidirectional text with Latin names or digits, navigation direction, arrow icons and every supported font. Avoid automatically mirroring gameplay diagrams or directions where doing so changes the intended mechanic; assess each control or asset in context.
10. Localisation QA: defects and expected results
A professional language review must happen inside the running game as well as in translation files. A linguist can approve the wording in a spreadsheet without knowing the actual context, while a developer may not notice a mistranslated quest condition. Combine linguistic, visual, functional and accessibility testing, and document each bug with a string ID, language, build version and screenshot or video.
| Defect | Example | Test and correction |
|---|---|---|
| Clipped UI | Long German label spills off an equipment button | Try real translated strings at all supported screen sizes and states |
| Broken token | {playerName} appears as untranslated markup or is altered | Compare placeholders before/after import; test runtime substitution |
| Wrong plural | French or Arabic reward message uses English singular/plural logic | Test zero, one and several values against target-language rules |
| Missing translation | English error toast remains after language switch | Audit all strings, hidden UI states, fallbacks and screenshots |
| Text-direction issue | Arabic settings page misorders mixed numbers and text | Check shaping, BiDi, navigation and input behaviour in the build |
| Dialogue mismatch | Quest subtitles no longer reflect the voiced line | Check asset IDs, final script, timing and game event |
| Broken tutorial | Instruction names the wrong input after control remapping | Test dynamic input glyphs and every supported device |
Our localisation testing guide explains how to capture reproducible functional and linguistic defects. Don’t mark a language complete until the translated build, not only the resource files, has been checked.
11. Manage continuous updates, DLC and live operations
Games change after release. New quests, balance changes, events, seasonal content and platform fixes can affect previously approved wording and layout. Plan a delta workflow instead of replacing every translation file and hoping older content remains valid.
- Freeze a reference source revision or release branch for each translation handoff.
- Identify new, changed, removed and unchanged string IDs.
- Provide enough context for altered dialogue and UI behaviour; do not rely solely on a fuzzy translation-memory match.
- Validate that returned localisation resources preserve stable keys, placeholders and file encoding.
- Run automated checks for missing locales and unresolved tokens, followed by in-context human review.
- Build and smoke-test the changed languages, including high-risk UI and gameplay paths.
- Record approvals and retain versioned language assets for the next patch.
For time-sensitive releases, agree which languages launch together, who owns late content changes and what fallback content will appear if an asset is genuinely not translated. A silent fallback to English may be technically acceptable in some cases but still be a visible defect for players.
12. Game localisation project checklist
- Target languages, locales and audiences agreed
- All player-facing strings and language-containing assets inventoried
- Stable keys, context, screenshots and placeholder rules supplied
- Style guide and terminology approved by game and language leads
- All content, UI, quest branches, tutorials and feedback translated
- Voiceover and subtitles prepared to the correct line IDs
- Fonts, text length, special characters and RTL tested
- Pluralisation, currency/number formatting and runtime variables checked
- Unity/Unreal import or compilation tested in target-language builds
- Linguistic, visual, functional and accessibility QA signed off
- Build version and translation delivery traceable
- Patch and DLC update process documented
Game localisation FAQs
What is the difference between video game translation and localisation?
Translation renders words in another language; localisation also adapts layout, cultural references, audio, interactive behaviour and language-dependent systems so the game functions naturally for the target audience.
What should developers provide to a game translator?
Send editable source strings with stable IDs, screenshots or gameplay context, character/style guidance, variables and format rules, language targets, deadlines and the agreed review/testing process. A running test build is particularly useful.
How do you avoid broken placeholders and plural errors?
Keep dynamic text in complete localisable messages, preserve variable identifiers, use locale-aware plural and formatting features, and test runtime values including zero, one, many and unusually long names.
Can Unity and Unreal handle game localisation?
Yes, both provide dedicated localisation workflows. Unity documents locale-aware tables and Smart Strings; Unreal provides text localisation types and a Dashboard-driven gather/export/import/compile process. Use documentation for the installed version.
Should all humour and gameplay mechanics be changed for each country?
No. Adapt only where it supports the intended experience, audience needs, content requirements or market constraints. Narrative meaning and game mechanics should be reviewed with the game team rather than altered by a translator independently.
Is machine translation enough for a game release?
It can help produce draft text in some controlled workflows, but it does not replace approved terminology, narrative direction, context and in-game testing. High-impact dialogue, UI prompts and sensitive market content may require specialist human review.
How is localisation quality measured?
Track unresolved strings, linguistic defects, broken placeholders, visual clipping, functional regressions, sign-off by language, and player-reported issues after release. A single translation-accuracy percentage cannot capture how well a game works.
Official development references
- Unity: current localisation overview and resource tables and keys
- Unreal Engine: Localization Dashboard and tools
- Unreal Engine: user-facing FText and text localisation
- Microsoft: localisation testing methods
- Microsoft: internationalisation and pseudolocalisation tests
- Godot: game internationalisation, context, plurals and pseudolocalisation
Need video game translation and localisation support?
TranscribeLingo offers a game localisation service covering player-facing text and related language requirements. Send the engine or file formats, language pairs, approximate string count, planned release, available build/screenshots, narrative context and any voiceover/subtitling needs through the contact page. Deliverables, review stages and turnaround should be confirmed for the actual title, rather than assuming a universal price or schedule.
