Blog

There is no universal list of best languages to localize into. A practical framework for picking languages based on your own traffic, genre, and text volume.

Fan translation can reach languages you'd never budget for professionally, but it comes with quality variance, consistency risk, and licensing questions worth settling up front.

Localization is not a free win. A clear-eyed look at what it gives you and what it costs, so you can weigh the decision for your own game instead of assuming the answer.

Localization cost is not just per-word translation. A working estimate needs review, engineering, coordination, and every update after launch.

These five terms get used interchangeably, but they cover different work done by different people. Why the distinctions matter when you buy services or divide work internally.

Full localization is not the only option. Store-page-only, UI-only, and subtitle-only are all legitimate scopes players tolerate — as long as the game does not mix languages inside the core loop.

A qualitative comparison of the four common ways to get a game translated, and why file and format integrity stays the developer's job no matter which one you pick.

A reasoning framework for deciding on localization: the cost side is knowable and bounded, the upside is uncertain, so test demand cheaply before committing.

Simultaneous launch and post-launch localization solve different problems. What each costs, the signals that tell you it is time, and the middle roads that let you start small.

Digital stores already sell your game worldwide — language is the barrier that remains. What localization buys you, what it costs, and when it makes sense.

UTF-8 as the default, what a BOM is and how it surprises parsers, what mojibake actually is, how legacy encodings sneak in through spreadsheet exports, and why encoding needs checking per file.

CSV is spreadsheet-friendly but has quoting pitfalls; JSON is structured but merge-conflict-prone and hostile to raw editing. What matters is single source of truth, diff-ability, and round-trip safety.

Decimal separators, digit grouping, date component order, clock format, and currency symbol placement all differ by locale. A hardcoded format string quietly leaks the developer's own locale into every build.

Text buried in source code can't be exported, counted, or translated safely. Moving it to keyed resource files and away from concatenation is the fix.

Silent fallback, the raw key, or an empty string — the trade-offs of each in development versus production, chained regional fallbacks, and why the usual answer is loud in dev, graceful in production.

Translated text can be perfectly correct and still render as empty boxes if the font that draws it has no glyphs for the language. What glyph coverage, fallback chains, and Han unification mean in practice.

The general shape of localization in Godot — CSV-based translation import, a translate function used at display time, and locale selection — plus the engine-independent essentials.

Many languages assign gender to nouns and inflect words by case. A template that works fine in English can become ungrammatical the moment a variable is substituted in.

Deleted tokens, extra tokens, case changes, fullwidth brackets, unsupported reordering, stray spacing — a catalog of how placeholders break, and why each one is mechanically detectable.

Japanese text has no spaces between words, so space-based word wrap either does nothing or breaks in the wrong place. What kinsoku shori actually requires, and why embedded newlines betray you after translation.

One file per language versus one per feature, naming conventions with language tags, where the source language lives, stable key order, and how structure shapes merge conflicts.

Why a key rename looks like a delete plus an add to everything downstream, how to retire a key without losing its translations, and detecting orphaned and missing keys.

Custom engines, small frameworks, and jam-scale projects often have to build localization from scratch — a key/value store, a lookup function, and the traps that catch home-grown systems.

Resource files per language, how the OS language setting picks a locale, layouts that survive text expansion, and why the store listing is a separate job from the app itself.

printf-style, indexed, named, ICU MessageFormat, custom tags — the placeholder syntaxes you'll meet in game text, and why a project should standardize on one.

English has two number forms; Japanese has none; some languages have several. What CLDR's plural categories actually mean, and how ICU MessageFormat lets one string template cover all of them.

Visual novels live and die on prose — the sheer volume of dialogue, character voice, text box limits, and why regression tracking matters when scripts get revised.

Color tags, bold, ruby annotations, icon substitutions — inline markup has to survive translation intact. The common ways it breaks, and why checking it is mechanical and cheap.

Arabic, Hebrew, and other right-to-left scripts change more than reading direction. Layout mirroring, bidirectional text, and cursive letter shaping are all engineering concerns translation alone cannot solve.

Files labeled Shift_JIS from Japanese Windows tools usually carry Microsoft's CP932 extensions. What that superset adds, where it breaks, and how to handle it safely.

Hierarchical namespacing, stable IDs vs content-derived keys, encoding context in the key, and why reusing one key for two meanings is the mistake that costs the most later.

Different languages expand or contract by different amounts, and 'character count' does not mean what most length checks assume it means. What to measure instead, and how to budget for it.

The general shape of localization work in Unity — locales, string tables, fonts, and the checks that matter — with a heavier focus on what applies no matter which engine you use.

The general workflow of gathering, translating, and compiling text in Unreal Engine — and the engine-independent groundwork that determines whether it goes smoothly.

The lang attribute, why URL-based locale selection is what search engines can index, hreflang for alternate pages, formatting dates and numbers correctly, and keeping text out of templates.

How Android stores UI text as XML resources, how it picks a language and region at runtime, and the escaping and plural rules that trip up translators.

The key-value .strings format, .stringsdict for plurals and width variants, the newer string-catalog concept, and how XLIFF fits the round trip.

How BCP 47 language tags are built from subtags, why script matters more than region for Chinese, and the mistakes that break matching and fallback.

A precise look at GNU gettext's PO/POT format — plural forms, msgctxt, comments, fuzzy entries — and why it is still the default in open-source localization.

A precise walkthrough of ICU MessageFormat syntax — arguments, plural with CLDR categories, select, selectordinal, nesting, and the offset feature — and its main risk.

Java's key=value .properties files and .NET's XML .resx files have solved the same problem for decades, in different ways — and each has its own bite.

TMX stores translated sentence pairs, TBX stores approved terminology, and both exist so your linguistic assets outlive any single tool.

What CLDR actually provides — plural rules, date/time/number patterns, collation, display names — and why locale-aware code reads it instead of hardcoding conventions.

How XLIFF structures file/unit/segment translation data, tracks workflow state, and protects round-tripping between your source files and translation tools.

Both formats can hold the same key-value translations, but they behave differently under editing, diffing, and merging — and that difference matters more than syntax taste.

A character's voice is spread across every line they speak, written over months by more than one translator. What keeps it consistent, what can be checked mechanically, and what still needs a human reader.

A working checklist of the localization defects that show up in almost every project — what each one looks like in game, how it gets introduced, and whether it can be caught mechanically or needs a human.

Target-identical-to-source is the basic signal for an untranslated string, but it comes with false positives worth knowing about, plus the quieter cases: empty targets, fallback leakage, and strings added after the last translation pass.

A diff is supposed to show you what changed. On a localization file it often shows you everything, unless the file is kept in a shape that keeps diffs meaningful.

UTF-8 bytes decoded once as a single-byte encoding, then re-encoded as UTF-8 again — a specific two-step corruption with a specific fix, and a reason it tends to happen twice.

Duplicate keys rarely crash anything, which is exactly what makes them dangerous. How they get introduced, why last-one-wins hides the problem, and how to detect and prevent them.

A single emoji shows up as a broken glyph, a missing character, or blows past a character limit that should have had room to spare. The cause is almost always a naive substring or truncation operation.

A localization CSV that Japanese spreadsheet software opens perfectly and everything else reads as mojibake — the encoding default behind it, and a workflow that survives round trips.

Sampling-based review quietly assumes quality is uniform across a file. That assumption held better for a single human translator than it does for machine output — here is why, and what to check instead.

A string table strips away who is speaking, where the text appears, and what a placeholder expands to. What to hand translators instead of a bare spreadsheet.

Item names, skill names, and UI verbs need one translation each, everywhere. A glossary and a style guide are how you get there — if you write them before translation starts.

Fluent output is not the same as correct output. A rundown of the specific ways machine and AI translation break localization files, and which failures a script can catch versus which need a human.

Zero-width spaces, stray BOMs, directional marks, non-breaking spaces — characters that look like nothing on screen but break exact-match comparison, key lookups, and diffs.

English I carries no personality signal. Japanese has a real repertoire of first-person pronouns, each carrying age, gender, formality, and personality cues — and EN to JA localization has to pick one per character and keep it.

English gives almost no signal for which Japanese politeness register a line should use. For EN to JA localization, that choice has to be made deliberately, per speaker and relationship, and kept consistent.

Parseability, encoding, placeholder parity, tag balance, duplicate keys — the same discipline you apply to source code, applied to the files that carry your game's text.

Source edits, retranslation, and re-imported files all silently change lines that were already approved. Treat localization the way you treat code: baseline, diff, verify.

A short, repeatable pass through every language that catches the failures a full regression pass would also catch, but in minutes instead of days.

MTPE flips the order of translation: a machine drafts, a human edits. That order change moves where errors hide and what a QA pass has to look for.

Strings like 縺ゅ↑縺溘 or äö are not random corruption — they are the correct bytes decoded with the wrong encoding. How to read the pattern and recover the original text.

A raw token like {playerName} or %s shows up in the UI instead of a real value. Four different bugs produce the same symptom — here is how to tell them apart and fix each one.

Pseudolocalization transforms source text into an exaggerated stand-in translation so you can catch pipeline bugs — hardcoded strings, overflow, encoding issues — before translators ever touch the file.

Most people who touch a localization file cannot read most of the languages in it. Here is what you can still verify, and what genuinely has to wait for a native reader.

An inventory, leaderboard, or friends list sorts translated names into an order native readers immediately flag as wrong — even though nothing crashed. The sort itself needs to be locale-aware.

A button label runs off its edge or two lines overlap only in translated builds. The container was designed for one language's average length — here is how to find the actual fix.

Text renders as tofu boxes or a fallback glyph while the underlying data is completely correct. How to tell a font problem from an encoding problem, and what to check.

You do not need a single quality number to know whether localization is getting better or worse. Counting issues by category and severity, build over build, tells you more and lies less.

Review only works if it is clear who checks what, decisions get written down instead of re-argued, and an accepted fix actually reaches the file — not just the tester's notes.

LQA gets used as a catch-all, but it covers two genuinely different kinds of check: linguistic quality and functional or format quality. They belong in different places in the pipeline, done by different people.

「The Japanese feels off」 is not a bug report — it is a feeling. The anatomy of a localization bug report that a translator can fix on the first pass.

A line begins with a comma, a closing bracket sits alone at the start of a line, or a term splits awkwardly mid-word. These are real, well-defined rules being violated — not just an aesthetic complaint.

Right-to-left layout, cursive letter shaping, bidirectional text, and plural categories beyond singular and plural. Why Arabic support is mostly an engineering task.

Brazilian and European Portuguese differ in spelling, vocabulary, agreement, and address forms. Why the language tag needs to specify which one you mean.

Japanese localization is not a drop-in text swap. Three writing systems in one line, no word spacing, and layout rules English never forces you to think about.

French text runs longer than English, grammatical gender can break templates built from fragments, and French typography has its own spacing rules. A practical guide for engineers.

Compound nouns, noun capitalization, and case-driven word forms make German one of the hardest languages to lay out for — which is exactly why it is worth designing against.

Going the other direction has its own set of traps: text that grows, subjects that must be added, and UI that was built for a language English is not.

Hangul is not an alphabet used the way Latin script is used. Syllable blocks, spacing rules, honorific levels, and font coverage all need separate attention.

Russian uses more plural categories than English and changes noun endings by grammatical case. Why ICU MessageFormat plural syntax, not string concatenation, is the only durable fix.

They are not interchangeable, and treating them as one 'Chinese' language file is one of the most common localization mistakes teams make.

Spain Spanish and Latin American Spanish diverge in vocabulary and address forms. What the BCP 47 tags mean and how to decide between one neutral variant and two.

Text reflow, screen reader pronunciation, subtitles, and hardcoded layouts are problems that show up for both accessibility and localization — solving one properly tends to solve the other.

General translation skill and game translation skill are not the same thing. How to evaluate a Japanese translator and brief them well, even if you do not read Japanese yourself.

There is no universal number for what localizing a game costs. Here is how to build an estimate from your own word count, content mix, and scope decisions.

Full translation of an unstable script wastes work every time a line changes. Here is how to localize an early access game as a series of deltas instead.

Live-service games don't localize once — they localize on every recurring content drop, against a fixed event deadline. What that does to the process, and how to avoid shipping an event half-translated.

Localization has its own schedule, with dependencies that are easy to miss until they cause a rushed, error-prone translation pass right before launch.

A spreadsheet and a running game are different renderers. What breaks between them, how to build a fast language-switch testing workflow, and what to prioritize when time is limited.

A localization kit is the difference between a translator working from a bare string list and one working with everything they need to get it right the first time.

In the Japanese market, text quality is read as a signal about the whole product. A craft-level look at register, character voice, and typography from the Japanese reader's perspective.

A final pass before you ship: the localization items that are easy to overlook in the last week, why each one matters, and what to have ready for the inevitable post-launch fix.

The store page is many players' first contact with your game, has the lowest word count of any surface you can localize, and is where a bad translation can cost you more than none at all.

Nobody on a small team holds the title, but someone still does the work — preparing files, briefing translators, fielding queries, coordinating review. Naming the job makes the gaps visible.

What a translation memory actually stores, how fuzzy matching works, and why reusing a past translation can be either your biggest time-saver or your fastest way to spread an error.

Freelance translators are how most small and mid-size studios localize. What makes that relationship work — and why switching to whoever is cheapest per job quietly costs you more.