Tools and software
Computer Software Localization: How Translators and Agencies Ship It
Computer software localization is how translators and agencies adapt desktop, server, and embedded software into locale-ready builds — pricing, process, QA
Computer software localization sits inside the production-side localization program a translation agency runs for desktop, server, and embedded software clients. It covers resource-file parsing, CAT and TMS work, review, and LQA — all gated to the engineering release cycle.
What is computer software localization and how is it different from app or website localization?
Computer software localization is the production-side adaptation of desktop, server, and embedded software — strings, UI, formats, docs, EULAs — into locale-stamped resource files for one target market. Translators and agencies deliver against the engineering release cycle, not a content calendar. The lane is broader than application or website localization because it covers back-office consoles, embedded firmware, SDK documentation, and legal strings.
The three lanes split on scope and shipping surface:
- Computer software localization — desktop clients, server consoles, embedded firmware, SDK docs, EULAs.
- Application localization — a shipping end-user app on iOS, Android, desktop, or web, with store metadata. See How App Localization Works and What Clients Are Buying.
- Website localization — browser-rendered marketing and content sites with no store review.
Software localization is one of seven delivery lanes an agency runs. It shares the term base with the other six but ships against the release cycle. For the full lane map, see Service Localization: What Translators and Agencies Actually Deliver.
How does computer software localization sit next to application and website localization?
Computer software localization is the broad lane covering desktop clients, server consoles, embedded firmware, SDK docs, and EULAs. Application localization is the shipping end-user app subset. Website localization is the browser-rendered marketing lane with no store review.
| Lane | Scope | Resource formats | Release trigger |
|---|---|---|---|
| Computer software | Desktop, server, embedded, SDK docs, EULAs | .resx, .rc, .properties, .mo, .xliff | Engineering milestone |
| Application | Shipping end-user app + store metadata | .strings, .xml, .json, .xliff | Store review + engineering |
| Website | Marketing and content pages | CMS exports, .json, .po | Content calendar |
What deliverables does a translator hand back on a computer software project?
The deliverable is a locale-stamped resource bundle the developer merges into the build, not prose. Typical formats are .resx, .rc, .properties, .mo, .strings, or .xliff. The handback also includes an updated translation memory, term base, LQA scorecard, and release notes.
- Locale-stamped resource file (es-MX, pt-BR, fr-CA).
- Updated translation memory with approved segments.
- Updated term base locking product terminology.
- LQA scorecard against an MQM-style typology.
- Release notes flagging context questions and open strings.
How does internationalization (i18n) set up computer software localization (l10n)?
Internationalization is the engineering pre-step that externalizes strings, abstracts locale-sensitive formats, and makes the codebase accept locale bundles. Computer software localization is the per-locale translation and adaptation that follows. It only works if i18n is clean.
When i18n is skipped, translators receive hard-coded strings, concatenated phrases that force English word order, and dialogs that break under expansion. The agency pushes a pseudo-loc stress test back to the client before billable translation starts.
Why does pseudo-localization run before translators receive strings?
Pseudo-localization replaces source strings with accented placeholders padded 30–100% longer, exposing hard-coded strings, truncated dialogs, and encoding failures. The pass runs before any translator spends billable time on the file. For the test-build mechanics, see Pseudo Localization: What Translators Need to Know About i18n Test Builds.
What ISO language and region codes do computer software projects use?
Resource bundles are tagged with BCP 47 locale strings combining ISO 639-1 two-letter language codes and optional ISO 3166-1 country codes — es-MX, pt-BR, fr-CA. The tagging matches the hreflang discipline used across the agency's web assets.
How it works
What are the core process steps of a computer software localization project?
1
How do translators work with resource files without touching the code?
Translators work inside CAT or TMS views of the resource file. Strings surface as translatable segments with context metadata attached — character limits, UI screenshots, and developer comments. The platform enforces tag integrity so that format placeholders like %s or {0} cannot be accidentally deleted or reordered. When the translation pass is complete, the TMS exports the file in its original format — .resx, .properties, .xliff, and so on — and the developer merges the locale bundle back into the repository without touching any translated content directly.
2
How does the project sync to the engineering release train?
Computer software localization ships against engineering milestones through branch-based TMS workflows and webhook triggers, not a content calendar. When a developer merges new or changed strings into the source branch, the TMS webhook detects the diff, creates translation tasks for affected segments only, and routes them to the assigned linguists. Translators pick up new strings per sprint and QA against staging builds before the release cuts. Integrating localization directly into CI/CD pipelines is the standard pattern for teams that ship on a continuous or sprint-aligned cadence — it eliminates the manual handoff delays that compress translation windows and force teams to choose between quality and schedule.
What tools and platforms power computer software localization work?
Agencies run computer software localization on 3 tool categories: CAT tools for segment-level translation work, TMS platforms for workflow automation and repository integration, and MT engines for first-draft generation on high-repetition strings. Each category solves a distinct problem, and a production-grade localization program uses all three in combination rather than treating them as alternatives.
| Category | Examples | Primary function |
|---|---|---|
| CAT tools | Trados, memoQ, OmegaT | Segment-level translation with TM leverage and term base enforcement |
| TMS platforms | Phrase, Lokalise, Crowdin, Smartling, Transifex | Workflow orchestration, repo webhooks, multi-locale project tracking, and CI/CD integration |
| MT engines | Neural MT engines embedded inside the TMS | First-draft generation for post-editing on high-volume, lower-risk strings |
TMS platforms are the connective layer that makes continuous localization possible. A TMS integrates with the source code repository via webhooks, detects changed or new strings on every commit, and routes work to linguists automatically — a workflow that is only achievable because i18n has already externalized strings into discrete, tool-readable resource files before the TMS ever touches them. Without that engineering groundwork, no tool can reliably separate translatable content from code.
What role does translation memory play across releases?
A translation memory is a database that stores every approved source-and-target segment pair produced on the project, making each completed release an asset that reduces the cost and time of every subsequent release. When a string in a new build matches a previously translated segment exactly, the TMS applies the approved translation automatically at a 100% match rate; close matches surface at a fuzzy-match discount for human review. Menu items, error codes, dialog labels, and legal boilerplate are the string types that reuse most heavily across software releases — they are also the strings where inconsistency is most visible to end users. The TM enforces consistency across the entire language set simultaneously, so a terminology correction made in one release propagates into every future build that reuses the affected segment.
Where does machine translation post-editing fit into the pipeline?
MT post-editing applies to high-repetition, low-risk strings — status messages, log output, tooltip text, and large help corpora — where the cost of full human translation outweighs the quality risk. A neural MT engine embedded in the TMS generates a first draft; a human post-editor corrects fluency, terminology, and tag integrity rather than translating from scratch. The approach can reduce per-word cost substantially on software content. Because post-edited output carries higher residual error rates than fully human-translated segments, review and LQA carry proportionally more of the quality burden when MT is in the pipeline — the LQA scoring model needs to reflect that increased risk, and error thresholds should be set accordingly.
Pricing
How do agencies price computer software localization?
Computer software localization prices on 4 stacked line items: translation at $0.10–$0.25 per source word, review at $0.04–$0.08 per word, LQA at $40–$90 per 1,000 words, and project management at 10–15% of project value. TMS tooling is amortized per project.
| Service | Details |
|---|---|
| Translation | 50,000 words × 5 languages × $0.10–$0.25 = $25,000–$62,500. |
| Review | 50,000 words × 5 languages × $0.04–$0.08 = $10,000–$20,000. |
| LQA | 250,000 words / 1,000 × $40–$90 = $10,000–$22,500. |
| PM | 10–15% of project value stacked on top. |
| TM leverage | 100% and fuzzy matches reduce the translation line by 20–40%. |
How is quality assured on computer software localization projects?
Quality is gated by 2 audits: segment-level review at $0.04–$0.08 per source word, and an LQA sample at $40–$90 per 1,000 words. The LQA scores against an MQM-style typology covering accuracy, fluency, terminology, locale convention, and style, aligned to ISO 17100.
What does an LQA scorecard measure on a software build?
The LQA scorecard scores sampled segments across 5 categories: accuracy, fluency, terminology adherence to the term base, locale convention (dates, numbers, currencies), and style guide compliance. Error weighting blocks delivery above threshold.
- Accuracy — mistranslation, omission, addition.
- Fluency — grammar, spelling, punctuation.
- Terminology — adherence to the term base.
- Locale convention — date format, number separator, currency symbol.
- Style — brand voice and style guide compliance.
How are certified EULAs and legal strings handled inside a software build?
EULAs, privacy strings, and regulated disclosures route to a certified lane that attaches a certificate of accuracy. The certificate is mandatory on every page per the agency's USCIS production grid. Notarization is an optional $10–$50 line item when the receiving authority requires it.
What are the most common pitfalls that break a localized computer software build?
There are 6 recurring pitfalls that break localized computer software builds — and all six are preventable with proper i18n groundwork and a disciplined extraction process. Internationalization is the engineering pre-step that externalizes strings and abstracts locale-specific formats before localization begins; most of the pitfalls below are symptoms of skipping or shortcutting that step.
- String concatenation. Concatenated phrases force English word order onto every target language. German, Japanese, and Turkish regularly invert subject-verb-object order; a string built by joining two hard-coded fragments at runtime will produce grammatically broken output in most non-English locales. The fix is named placeholder substitution inside a single, complete source string.
- Missing plural forms. English has two plural states — singular and plural. Many languages have three, four, or six grammatically distinct forms governed by CLDR plural rules. A resource file that stores only one plural string produces incorrect or nonsensical output for counts in languages with more complex plural categories, including Arabic, Polish, and Russian.
- Hard-coded punctuation and spacing. French typography requires a non-breaking space before certain punctuation marks; Chinese uses full-width punctuation characters; Spanish opens interrogative and exclamatory sentences with inverted marks. Hard-coded ASCII punctuation breaks the typographic conventions of every one of these markets and signals a product that was not genuinely adapted for local audiences.
- Text expansion. Translated text routinely runs 30–100% longer than the English source. Pseudo-localization stress-tests the codebase with padded, accented placeholders at exactly that expansion range before translators receive strings — any UI container that breaks during pseudo-loc will break in production with real translations. Fixed-width dialog boxes, button labels with pixel-exact widths, and truncated tooltip regions are the most common failure points.
- Missing RTL support. Arabic and Hebrew builds require fully mirrored layouts and bidirectional text handling at the rendering layer. RTL is not a post-translation patch; it is a layout architecture decision that must be made during i18n. Adding RTL support after translation is complete is costly, time-consuming, and frequently incomplete.
- Untracked source changes. Treating the source resource file as a living document without version control and change tracking strands translators on stale segments. When source strings change between the time a translator is assigned and the time they deliver, the resulting translations may not match the shipped UI — and without a diff, neither the PM nor the reviewer can know which segments are affected.
Running a pseudo-localization pass before translation and locking the source file at string-freeze are the two process controls that catch the largest share of these failures at the lowest cost. Both belong in every software localization project plan regardless of language count or budget.
The 5 questions translators and PMs ask most about computer software localization cover scope boundaries, cost grids, tool stacks, release cadence, and where certified content fits. Each answer maps to the operator's published production posture.
Frequently asked questions
What does localization mean in software?
Software localization is the process of adapting a software product — its UI strings, error messages, documentation, and help content — for a specific locale, including language, cultural conventions, date formats, and currency. It goes beyond translation: a fully localized build replaces every user-facing text string, adjusts layout for text expansion (German and Finnish can run 30–40% longer than English), and accounts for right-to-left scripts like Arabic or Hebrew. For translators and agencies, software localization usually means working with file formats such as .po, .xliff, .resx, or .strings rather than Word documents.
What are the different types of localization?
The main types of localization are software/app localization, website localization, document and legal localization, multimedia and e-learning localization, and game localization. Each type differs in file format, turnaround expectations, and the role of certified translation within the workflow. Legal and document localization most frequently requires certified or sworn translations, while software localization typically prioritizes speed and format compatibility. Agencies often handle several types simultaneously, routing content to specialist translators based on domain and certification requirements.
What are the best practices for software localization?
The most consistent best practices for software localization are: internationalizing the codebase before translation begins, using a translation management system (TMS) to handle .xliff or .po files, maintaining a project-specific glossary and style guide, and running linguistic QA on the final build. Translators should receive context — screenshots or a staging build — because isolated strings are notoriously ambiguous. Text expansion budgets (typically 30–40% for Western European languages) must be built into UI design early. For regulated or certified content within the software (e.g., medical device labels), each string may require a documented review and certification step.
What is localization in coding?
In coding, localization (often abbreviated l10n) refers to the engineering practice of separating translatable strings from source code so they can be swapped per locale at runtime. Developers externalize strings into resource files — .resx in .NET, .strings in iOS, .po in GNU/Linux apps — which translators then work on directly. A well-internationalized codebase uses locale-aware libraries for number formatting, pluralization rules (some languages have six plural forms), and date handling. For translation agencies, understanding this structure is essential for scoping software localization projects accurately and avoiding post-translation engineering rework.
What is localization in a video game?
Game localization is the full adaptation of a video game — including UI, subtitles, voiceover scripts, in-game lore, and marketing materials — for a target market and language. It is one of the most complex localization verticals because translators must handle non-linear narrative text, character voice and tone, cultural references, and tight character-count limits on UI elements. Major titles are routinely localized into 12–30 languages simultaneously, which demands strong TMS workflows and version control. Unlike certified document translation, game localization rarely requires legal certification but does demand deep subject-matter familiarity and tight collaboration with developers.
What is the definition of localization?
Localization is the comprehensive process of adapting content, products, or services so they feel native to a specific target locale — covering language, cultural norms, legal requirements, and technical formatting. The term is broader than translation: a localized product adjusts currencies, units of measurement, imagery, and even color symbolism where culturally relevant. In the translation industry, localization projects are distinguished from pure document translation by their reliance on structured file formats, engineering handoffs, and iterative QA cycles. Certified translation is often a component within larger localization programs, particularly for regulated industries like medical devices or financial services.
Can you give me an example of localization?
A clear example of localization is a US-developed SaaS platform releasing a German version: the interface strings are translated, date formats switch from MM/DD/YYYY to DD.MM.YYYY, currency symbols and decimal separators change, and the privacy policy is rewritten to comply with GDPR rather than US standards. For translation agencies, a comparable example is producing a certified translation of a medical device's Instructions for Use for the EU market — every string in the software UI and printed manual must be translated, reviewed, and certified before the product can be placed on the market under MDR regulations.
What are the 8 types of translation?
The eight types most commonly cited in translation theory are: semantic translation, communicative translation, pragmatic translation, literary translation, technical translation, legal translation, certified (sworn) translation, and machine translation (used as a first-draft or post-editing base). For working translators and agencies, the most operationally important distinction is between certified and non-certified translation, since certified output carries a signed declaration of accuracy required by courts, immigration authorities, and regulatory bodies. Software localization typically draws on technical and communicative translation methods, sometimes with a certified layer for regulated content.
What is the hardest language to translate?
There is no single 'hardest' language, but translators consistently cite Mandarin Chinese, Arabic, Japanese, and Hungarian as among the most challenging due to script complexity, grammatical distance from Indo-European languages, and high context-dependence. For software localization specifically, Japanese and Chinese present additional engineering challenges: character-based scripts require different font handling, text expansion is often negative (strings get shorter), yet UI layout assumptions built for Latin alphabets still cause truncation or alignment problems. Languages with complex morphology — Finnish, Hungarian, Arabic — also stress plural-form handling in resource files, requiring careful engineering and linguistic QA.
Related
- Computer-Assisted Translation Tools: The Working Translator's Field Guide
- Content Localization: How Translators and Agencies Produce It
- Continuous Localization: How Translators and Agencies Run the Delivery Model
- Crowdin Translation: How Translators and Agencies Run Projects Inside Crowdin
- Define Localization: What the Term Means in Professional Translation
- Define Transcreation: What It Means Inside a Translator's Workflow