Pseudo Localization: What Translators Need to Know About i18n Test Builds
Pseudo localization replaces source strings with accented, expanded characters so engineers can catch i18n bugs before translators receive the files.
Pseudo localization sits inside the software internationalization pipeline as the engineering quality step that runs before any translator opens the source file. For translators and agencies working downstream, understanding this pass explains why some XLIFF handoffs arrive clean while others drag mid-sprint source edits across the project. This article reframes pseudo-loc for the people who receive the files, not the engineers who configure it, as one upstream stage inside How App Localization Works and What Clients Are Buying.
What is pseudo localization?
Pseudo localization is a software testing method that replaces source-language strings with accented, expanded, bracketed versions of the same text so engineers catch internationalization defects — hardcoded strings, truncated UI, broken encoding — before real translators receive the files. The transformation is mechanical, not linguistic. Every string is still semantically English after the pass.
The pass produces three visible effects on every resource string:
- Character substitution: Latin letters swap for accented look-alikes (a→à, e→é).
- Length padding: strings grow 30–50% longer than the source.
- Bracket wrapping: markers such as [! … !] frame every translated key.
Why is pseudo localization not a real translation?
Pseudo localization is not a translation because no target language is involved. Every string stays semantically English and is only transformed visually. That is what lets engineers test the UI without waiting on a translator's turnaround, and it is why the pass costs nothing in translation hours.
How does pseudo localization relate to i18n and l10n?
Pseudo localization is the QA bridge between internationalization (i18n) and localization (l10n). Internationalization prepares the code to accept any locale. Localization produces the translated strings. Pseudo-loc verifies i18n readiness so l10n work is not wasted on broken resources. For a worked example of the i18n setup that pseudo-loc then validates, see How to Add i18n to an Astro Site.
How does pseudo localization work on a source string?
Pseudo localization works by running every source string through three transformations in sequence: character substitution, length padding, and bracket wrapping. Each transformation targets a specific defect class. The three together give engineers a single build they can inspect visually.
- Substitute each Latin character with an accented Unicode equivalent.
- Pad the string by 30–50% to simulate text expansion in target languages.
- Wrap the result in bracket markers so untouched text stands out.
How are characters substituted in pseudo localization?
Characters are substituted one-for-one with accented or decorated Unicode equivalents — 'Hello' becomes 'Ĥéļļö'. Readability is preserved for English-speaking testers. The renderer, font stack, and encoding path are forced to handle non-ASCII code points. Any pipeline that assumed ASCII breaks visibly during this pass.
How much are strings padded in pseudo localization, and why?
Strings are padded 30–50% longer than the source to simulate expansion in German, Finnish, and Russian translations. Those three languages routinely take significantly more characters to carry the same meaning. The padding blows out buttons, labels, and fixed-width columns in the test build, where a layout fix is cheap. A fix after translation is not.
What do the brackets and markers do in pseudo localization?
Each pseudo-localized string is wrapped in markers such as [! … !] or ⟦ … ⟧. Any text still appearing in plain English on screen is visibly a hardcoded string that bypassed the resource file. The marker turns a subtle bug into a flare the tester cannot miss.
What issues does pseudo localization catch before translation starts?
Pseudo localization catches four issue classes before translation starts: hardcoded strings that never reached the resource file, UI truncation from text expansion, broken character encoding, and concatenated strings that will not grammatically survive translation.
| Issue class | How pseudo-loc exposes it | Who fixes it |
|---|---|---|
| Hardcoded strings | Text remains in plain English against bracketed accented text | Engineering |
| UI truncation | Buttons, menus, tooltips clip under 30–50% padding | Engineering (layout) |
| Encoding failures | Tofu boxes (□), mojibake, or missing glyphs appear | Engineering (font / encoding) |
| Concatenation bugs | Two bracket pairs appear mid-sentence | Engineering (source rewrite) |
How does pseudo-loc expose hardcoded strings?
Hardcoded strings are exposed because they remain in plain English while every resource-file string is visibly accented and bracketed. The untouched text is a visual flare for the engineer. For the translator downstream, the same bug means strings that would never have appeared in the XLIFF are now caught and routed to the resource file before handoff.
How does pseudo localization stress-test text expansion?
Pseudo-loc stress-tests expansion by inflating every string 30–50%. Truncated buttons, overflowed menus, and clipped tooltips surface in the test build. Layout fixes happen in code. They do not come back to the translator as late-stage reduction requests asking for a six-character German label.
What encoding and font failures does pseudo localization reveal?
Encoding and font failures surface as tofu boxes (□), mojibake, or missing glyphs. These appear wherever the UI's font or character pipeline cannot render accented and extended Latin characters. A font that lacks Cyrillic or diacritic coverage fails here, long before a real Russian or Polish translation lands in the build.
Why does pseudo localization flag concatenated strings?
Concatenated strings get flagged because pseudo-loc wraps each resource key independently. A sentence stitched from two keys shows two bracket pairs mid-sentence. That is a structural problem translators cannot fix inside a single segment — the source needs a rewrite into one key with a placeholder.
Which frameworks and engines support pseudo localization natively?
Pseudo localization is natively supported by Android, Unity3D, Symfony 5.2 and later, and Windows. Each framework exposes the pass differently, but the goal is identical: generate a build with accented, expanded, bracketed strings without producing a real translation. Web frameworks with similar i18n hooks follow the same downstream handoff pattern — see React i18n: How Translators Fit Into a React Localization Pipeline.
| Framework | How to enable | Pseudo-locale identifier | Notes |
|---|---|---|---|
| Android | pseudoLocalesEnabled true in build.gradle defaultConfig | English (XA), Arabic (XB) | XB tests bidirectional (RTL) layout |
| Unity3D | Localization package, PseudoLocale class | Derived from any source locale | CreatePseudoLocale() and GetPseudoString() methods |
| Symfony 5.2+ | Built-in Pseudo-localization translator service | Runtime wrapper | Applies at runtime, source XLIFF untouched |
| Windows | qps-ploc / qps-plocm pseudo-locales | qps-Ploc, qps-Plocm | Available from Windows 8 build 7973 onward |
How is pseudo localization enabled on Android?
On Android, pseudo localization is enabled by setting pseudoLocalesEnabled true in the defaultConfig block of build.gradle. The build generates two pseudo-locales: English (XA) for accented expansion and Arabic (XB) for bidirectional testing. Both appear in device Developer Options for selection.
How does Unity3D expose pseudo localization?
Unity3D exposes pseudo localization through the Localization package's PseudoLocale class. Engineers generate a pseudo-locale from any existing source locale and apply transformation rules without authoring a separate asset. The CreatePseudoLocale() and GetPseudoString() methods carry the configuration.
How does Symfony 5.2+ handle pseudo localization?
Symfony 5.2 introduced a built-in pseudo-localization translator. The translator wraps the standard service and applies accenting, expansion, and bracketing rules at runtime. The underlying XLIFF resources stay untouched, which keeps the source file clean for the translator who inherits it later.
What does pseudo localization look like on Windows (qps-ploc)?
On Windows, pseudo localization ships as the qps-ploc and qps-plocm pseudo-locales, supported from Windows 8 build 7973 onward. Build 7973 is the earliest OS-level pseudo-locale build on record. ASP.NET Core projects typically consume qps-ploc via the xliff-tasks package, which generates a qps-Ploc satellite resource assembly at build time.
What does a pseudo-localized string actually look like?
A pseudo-localized string takes the source — for example 'Save changes' — and renders it as '[!! Šàvé çĥåñĝéš !!]' with roughly 40% added padding. The three target behaviors are visible at a glance: character substitution in the letters, expansion in the padding exclamation marks, and bracketing in the outer frame.
More examples from a typical UI:
- 'OK' → '[!! Öķ ķķ !!]'
- 'Settings' → '[!! Šéţţîñĝš ššš !!]'
- 'Log in' → '[!! Ļöĝ îñ îîñ !!]'
- 'Delete account' → '[!! Ðéļéţé àççöûñţ ààç !!]'
How are source English characters mapped to pseudo characters?
Source English characters are mapped to pseudo characters through a fixed substitution table. Typical mappings include a→à, e→é, i→î, o→ö, u→ü, A→Å, E→Ë, I→Ï, O→Ø, U→Ú. Each glyph stays readable to an English-speaking tester. Non-ASCII code points are forced through the rendering stack on every character.
Why do end users sometimes see pseudo-localized text on Xbox or Windows?
End users occasionally see pseudo-localized text on Xbox or Windows because a preview or beta build shipped with the pseudo-locale accidentally enabled. The device is not hacked, infected, or corrupted. It is running a build that Microsoft or a game studio uses for internal i18n QA, and the locale selector landed on qps-ploc instead of a shipping language.
Is pseudo-loc text a sign the device is hacked?
Pseudo-loc text is not a sign the device is hacked. It is a deliberate test transformation that occasionally leaks into preview channels. The symptoms resolve when the build switches the locale back to a shipping language, or when the next preview update ships. For translators and agencies, the practical read is that pseudo-loc has entered mainstream consumer awareness — expect occasional client questions about it.
How does pseudo localization affect what translators and agencies receive?
Pseudo localization affects translators and agencies by shaping the quality of the XLIFF they receive. A project that ran pseudo-loc arrives with fewer hardcoded strings, pre-sized UI containers, and documented expansion limits. A project that skipped it typically returns to the translator with mid-sprint truncation fixes and late-stage source edits.
What a clean upstream pseudo-loc pass delivers to the translator:
- Resource files that contain the full user-visible string set, with hardcoded strings already pulled into keys.
- UI containers already sized for 30–50% expansion, so no reduction requests mid-project.
- Encoding and font coverage already verified for the target scripts.
- Concatenated sentences already rewritten into single keys with placeholders.
Reddit Engineering, among others, uses pseudo-localization in its localization pipeline to preemptively verify UI comfort across target languages before translators engage. The practice is standard across teams with mature i18n discipline.
How should a translator read a pseudo-loc QA report?
A translator reads a pseudo-loc QA report by sorting findings into three buckets: hardcoded-string tickets, expansion/truncation tickets, and concatenation tickets. Each bucket needs a different response.
- Hardcoded-string tickets: engineering fix only. No translation work needed until the string is extracted into the resource file. Flag back to the project manager and move on.
- Expansion/truncation tickets: UI fix on the engineering side, sometimes paired with a shorter target request. Confirm the character budget before shortening.
- Concatenation tickets: source rewrite needed before translation proceeds. Do not attempt to translate a fragment that will be stitched to another fragment at runtime.
What should agencies ask the client before kickoff?
Agencies ask three questions that preempt the majority of mid-project source churn:
- Has a pseudo-localization pass run against the current source?
- Are the resulting defects closed in the build the XLIFF came from?
- Does the XLIFF handoff reflect the post-fix source, or an earlier snapshot?
A client that answers yes, yes, yes delivers a project that runs on the quoted timeline. A client that cannot answer the questions is a client whose translators will absorb the i18n debt mid-sprint. Price the project accordingly.
Pseudo localization is a software testing pass that transforms source strings into accented, 30–50% longer, bracketed versions to expose hardcoded strings, truncation, and encoding bugs before real translation begins.
Frequently asked questions
What does "i18n" mean?
"i18n" is a numeronym for "internationalization" — the 18 stands for the 18 letters between the first "i" and the last "n." In software development, internationalization means engineering a product so it can be adapted to any locale without code changes — handling variable text expansion, right-to-left scripts, Unicode character sets, date/number formats, and more. It is the technical foundation that makes localization (l10n) possible. Translators encounter it because i18n quality directly affects how cleanly strings can be extracted, translated, and re-integrated.
What is 18 in i18n?
The 18 in i18n represents the 18 letters between the "i" and the "n" in the word "internationalization." This shorthand — called a numeronym — follows the same pattern as "l10n" for localization and "a11y" for accessibility. It originated in engineering communities as a compact way to write long technical terms in tickets, configs, and code comments. Translators working on software projects will see it in build notes, style guides, and pseudo-localization documentation.
What is pseudo-localization and why is it showing up in my app/game/OS?
Pseudo-localization is a software testing technique that automatically replaces source-language strings with accented or extended characters (e.g., "Hello" → "Ħēļļö") to simulate a translated build without real translations. Developers use it to expose UI bugs — truncated text, hardcoded strings, layout breaks — before actual localization begins. If you see strange-looking but still readable text in an app, game, or OS, you are almost certainly running a developer or pre-release build that has pseudo-loc enabled. It is not a sign of a virus or hack; it is an intentional engineering tool.
Why is unlocalized text highlighted in pseudo-loc builds?
Unlocalized (hardcoded) strings appear unhighlighted or unchanged in pseudo-loc builds precisely so developers can spot them instantly. Pseudo-localization transforms every string that flows through the proper localization pipeline, so any text that remains in plain source-language characters has bypassed that pipeline and is hardcoded — a bug. This visual contrast is the core value of the technique: testers can scan a screen and flag unhardcoded strings in minutes rather than combing through source code manually. For translators, it explains why clients sometimes share pseudo-loc screenshots when reporting untranslatable strings.
Is pseudo-loc text a sign my device is hacked or infected?
No — pseudo-localized text is a deliberate developer testing feature, not malware. It appears when a device runs a pre-release, beta, or developer-mode build that has the pseudo-localization flag enabled. The accented and extended characters are generated by the OS or app framework itself (Android, Unity, Windows, etc.) as part of the localization QA process. If you see it on a consumer device, you most likely enrolled in a beta program or sideloaded a test build. A standard factory reset or leaving the beta channel will restore normal text.
What's the difference between translation and localization?
Translation converts text from one language to another, while localization adapts an entire product — content, UI, formats, imagery, and cultural references — so it feels native to a target market. A translation of a date might render "March 5, 2025" in Spanish; localization also changes the format to "5 de marzo de 2025" and adjusts currency symbols, measurement units, and legal disclaimers. In certified translation production, localization considerations matter because the same document may need culturally adapted formatting alongside linguistically accurate rendering to be accepted by target-country authorities.
What does localization mean in translation?
In translation, localization means adapting a translated text so it conforms to the linguistic conventions, cultural norms, and regulatory expectations of the target locale — not just converting words. This includes adjusting idioms, honorifics, number formats, legal terminology, and even document layout. For certified translations specifically, localization ensures that rendered dates, addresses, titles, and official terms match the format a receiving institution (court, embassy, university) expects, which is critical for acceptance. It goes beyond word-for-word accuracy to functional equivalence in context.
What does "localization" mean?
Localization (abbreviated l10n) is the process of adapting a product, document, or service to meet the language, cultural, and regulatory requirements of a specific target locale. It covers everything from translating text and adjusting date/currency formats to redesigning layouts for right-to-left scripts and ensuring legal compliance in the target market. In the translation industry, localization applies both to software (apps, websites) and to documents — including certified translations that must reflect the conventions of the issuing and receiving countries.
What is another term for localization?
"L10n" is the standard industry abbreviation, and "adaptation" or "transcreation" are terms used for creative or marketing content where cultural reinterpretation goes beyond linguistic conversion. In software contexts, localization is sometimes called "language support" or "regional adaptation." In the translation industry, the closest formal equivalent is "locale-specific translation," though most style guides and ISO standards (such as ISO 9001 for translation services) simply use "localization" as the accepted term.
What does software localization mean?
Software localization means adapting a software product — its UI strings, help content, error messages, date/time formats, and layout — so it functions correctly and naturally for users in a specific locale. It follows internationalization (i18n), which prepares the codebase to accept locale-specific assets. For translators, software localization projects involve working inside CAT tools or translation management systems with string files (e.g., .po, .xliff, .resx), respecting character limits, and understanding context provided by screenshots or pseudo-loc builds — which is directly relevant to understanding i18n test artifacts.
Related
- React i18n: How Translators Fit Into a React Localization Pipeline
- Service Localization: What Translators and Agencies Actually Deliver
- Software Translation Management: How Translators and Agencies Run a TMS Stack
- Squarespace Localization: How Translators Deliver Multilingual Squarespace Sites
- Storyblok Localization: How Translators Produce Field-Level Multilingual Content
- Trados as a CAT Tool: Features, Costs, and Honest Trade-offs