Software Localization Services
Software localization services adapt a software product for another locale, so that the interface strings, the plural forms, the sort order, the date and number formats and the layout all behave the way a native user expects. Espresso Translations localizes software from $0.10 per word, delivered in 2 to 3 working days, with a native linguist on every target language, a second-linguist revision under ISO 17100:2015, 150+ languages and a free quote within 1 hour.
Certified to ISO 17100:2015
Native Target-Language Linguists
Priced Per Word
Revised by a Second Linguist
150+ Languages
Free Quote in 1 Hour


Send Your Resource Files for a Free Quote
A project manager replies within 1 hour
What are software localization services? Software localization services adapt a software product for a new locale: the user interface strings in their own resource files, the plural and gender branching those strings carry, the date, number and currency formats, the sort order, the help documentation and the app-store listing. Translating the text is one step inside it. Espresso Translations, a translation company with an office at 99 Wall Street in New York City, works in the files a build already emits, from GNU gettext .po files to XLIFF 2.1, Android strings.xml and Apple String Catalogs, and translates from $0.10 per word in 2 to 3 working days with a free quote back within 1 hour. The correction most product teams need first is about length: text does not expand by a flat percentage. W3C’s internationalization guidance, citing IBM, puts English strings of up to ten characters at 200 to 300 percent of their original length and strings over 70 characters at about 130 percent, so short button labels break a layout long before paragraphs do.
What Does Software Localization Cover, Beyond Translating the Text?
Software localization covers everything a product has to change to work in another locale, and the strings are only the first layer of it. The work runs from the resource files that hold the user interface text, to the plural rules those strings branch on, the locale data behind every date, number and currency, the sort order of a list, the direction the layout runs in, and the help documentation and release notes a user reads after the install. Espresso Translations handles the language side of all of it, in 150+ languages, with a native linguist on every target language and a second linguist revising the result against the source. Put plainly, it is the process of adapting software and its content for a locale: the translation of the user interface is the visible part, and the translation and adaptation of everything around it is the rest.
Internationalization and localization are two different jobs, and knowing which one you are buying saves the most money. Internationalization is engineering: pulling hard-coded text out of the source, routing it through a message formatting layer, identifying locales with BCP 47 language tags, and letting the platform format dates and numbers rather than building them by hand. Localization is what happens once that is true, when the extracted content is translated and adapted for a target market. If a string is still being concatenated in code, no translator can repair it in the resource file, so we tell you which strings are a code problem before you pay to have them translated. Getting that order right is what makes localization workflows fit inside your software development cycle rather than run alongside it.
Then there is the content around the product, which is often where most of the words are. A localization project usually takes in in-app messages and system notifications, onboarding and error text, the help center, release notes, the app-store listing, and the policy pages a user is asked to accept. Where what you need is the generic localization service and process rather than software specifically, for a website, a store or a campaign, that is a different page and a wider scope. This one stays with software products, their resource files and their release cycle.
Every target language is handled by a linguist who writes into their own language, knows the subject and has at least five years of experience, and a second linguist then revises the translation against the source before delivery. That two-person process is what ISO 17100:2015 sets out for a translation service, and we are certified to it; what the standard does not do is cover localization engineering, so nobody should present it as a software localization standard. A dedicated project manager runs the project, a glossary and translation memories keep the terminology consistent across releases, and files come back in the format they arrived in. Standard work is $0.10 per word in 2 to 3 working days, with 24-hour express available on selected projects, and the quote is free and back within 1 hour. Language service providers divide this work differently, so when you compare quotes, check which of the steps above each one includes.
Which Resource Files and Formats Do You Work In?
Send the files your build already produces rather than a spreadsheet of sentences. Working in the native resource format is what keeps the identifiers, the developer comments, the placeholders and the plural categories intact, and it is what lets a translation memory tell a genuinely new string from one you have already paid to translate once. We are not a localization platform and we will not ask you to move onto one: where you already run a software localization platform or another localization tool, we work inside it.
| File or format | Where it comes from | What we return |
|---|---|---|
| GNU gettext .po, .pot and .mo | xgettext extracts the marked strings into a .pot template; one .po file carries one target language, and the .mo is its compiled binary form | A translated .po per locale with every msgid left untouched, so msgmerge picks up only what changed in the next release |
| XLIFF 2.1 (.xlf) | The current OASIS Standard, dated 13 February 2018, and the format Xcode exports and imports localizations as | The same document with the target segments filled in, so it goes straight back into the toolchain that produced it |
| Android string resources in strings.xml | An Android project under res/values, holding string, string-array and plurals resources | One values folder per locale, with the quantity strings supplied in the categories that target language grammatically requires |
| Apple String Catalog (.xcstrings), .strings and .stringsdict | Xcode: the String Catalog is Apple’s current recommendation, and .strings with .stringsdict is the earlier path | The catalog or property list returned with its plural variants populated and its format keys and variable names left alone |
| RESX, JSON, YAML, .properties and CSV | A .NET solution, a web front end, a Java bundle, or an export from a translation management system | The same structure, keys and escaping, with only the values translated, so a diff shows nothing but language |




Which Products and Content Does a Localization Project Include?
Any product whose text a user reads, which in practice means five groups: SaaS web applications, mobile apps, desktop and enterprise software, the documentation and in-product messages around them, and the testing pass that checks the lot in context. Each group has its own file formats and its own release rhythm, and the pipeline below adapts to the one you already run rather than asking you to adopt ours. Software localization projects on modern software are rarely one project and rarely one language, and complex software with a long release history takes longer to prepare than it does to translate. Shipping localized software sooner is usually a question of how the strings are stored rather than how fast anyone writes, which is also what decides time to market.
SaaS Web Applications and Admin Dashboards
A SaaS product localizes continuously rather than once, because the product changes every sprint. The practical shape is a repository of resource files your pipeline exports on merge, a short batch of new and changed strings that comes to us, and the translated files going back into that branch rather than into a backlog. We work to that cadence, in real-time batches rather than quarterly handovers, so an agile development team is not holding a release while a localization project finishes. That release-paced arrangement is what continuous localization means, agile localization in the industry’s own phrase, and it is why translation updates after the first release are incremental: a merge can trigger translation of only the strings that changed.
Dashboards and admin interfaces are the hardest part of a SaaS product to localize well. They are dense, they are full of abbreviations, and their labels sit in fixed-width table headers and chart legends where a longer word has nowhere to go. We ask for a screenshot or a staging login for exactly those screens, and where a label will not fit in the target language we propose shorter wording rather than letting the string be truncated at runtime. Terminology inside the product is handled with the same discipline as any other technical translation work, with a glossary agreed before anyone starts.
Mobile Apps for iOS and Android
Mobile apps are localized in their platform’s own resource format, and the two platforms differ in ways that matter. Android holds strings under res/values with a plurals resource whose categories are zero, one, two, few, many and other, and Google’s own guidance is that the category used is a matter of grammatical necessity rather than arithmetic: in English the zero string is ignored even when the count is 0, and in Korean only the other string is ever used. Apple’s current recommendation is the String Catalog, with .strings and .stringsdict as the earlier route, and Apple’s reference for the plural categories is CLDR. Mobile app localization also covers the store listing and its screenshots, which ship in the same release, so we localize those with the app.
The traps are the same on both platforms. A string translated without a context note comes back as the wrong part of speech, because ‘Open’ on a button and ‘Open’ in a status label are different words in most languages. A string that writes a number into the text as digits does not re-localize when the user changes region, which is why Apple’s own documentation tells developers not to put a literal 1 in the string. And a mobile app ships a build to review rather than to a server, so the localization has to be finished before the binary is cut rather than patched afterwards.
Desktop and Enterprise Software: ERP, CRM and Operating Systems
Desktop software and enterprise systems carry more strings than anything else we localize, and most of them are never seen by the person buying the project: configuration screens, audit logs, report headers, batch-job error messages, installer text. An ERP or CRM rollout into a new target market needs all of it, because the people who will complain are the finance and support teams living in the back office. We take the full string inventory, work through it against a glossary of your own terminology, and keep the translation memories so that the next version costs less than the first.
Legacy products add a problem of their own: strings embedded in compiled resources, held in a database, or sitting in a help format nobody has opened in a decade. Where the text can be extracted we work in the extracted format; where it cannot, we work in a bilingual table and hand back something your build can consume. Either way the engineering constraint belongs to your team and the language belongs to ours, and the line between the two is the thing worth agreeing in the first conversation.
Help Documentation, In-App Messages and Release Notes
The documentation is usually a larger word count than the interface, and it is where a user goes when the interface has failed them. We localize help centers, knowledge-base articles, onboarding sequences, transactional and system email, error and empty-state text, release notes and changelogs, keeping the product terminology identical to the interface so that the help article and the button agree with each other. Where a knowledge base is published from structured content, we work in the export format and return it with its metadata intact for your multilingual content to publish from.
In-app messages are short, which makes them the most expensive words in the product to get wrong. A notification has a character budget, a push message is truncated by the operating system rather than by you, and an empty state is often the only sentence that explains what a screen is for. We treat these as copy to be written in the target language rather than text to be converted, and we tell you when the English itself is the obstacle, because a sentence assembled from three fragments cannot be rewritten well in any language.
Pseudo-Localization and Release Testing
Pseudo-localization is a test rather than a translation. The source strings are mechanically replaced with accented or other-script equivalents, padded, and wrapped in markers, so that a build can be run and inspected before a single word has been translated. It exposes truncation, clipping, missing font coverage, text that was never externalized, and strings that are being concatenated in code. It is an industry practice, not a standard to conform to: the Unicode glossary has no entry for it, W3C’s internationalization materials carry no article on it, and Microsoft documents it as a methodology without citing any standards body. The techniques Microsoft describes are the ones most tooling implements, including replacing a letter with one of a set of accented variants, mapping digits to circled digits, expanding the string, and adding an identifier so the resource can be found again.
Expansion is the thing a pseudo-localized build is looking for, and it is not a flat percentage. W3C’s internationalization guidance, citing IBM, gives average translated length as a proportion of the English original, and that proportion falls as the string gets longer: 200 to 300 percent for strings of up to 10 characters, 180 to 200 percent for 11 to 20, 160 to 180 percent for 21 to 30, 140 to 160 percent for 31 to 50, and around 130 percent above 70 characters. Microsoft’s own pseudo-localization heuristic is to lengthen English text by 40 percent, with extreme cases at 200 to 400 percent, and Microsoft also notes that translations sometimes come back shorter. In a measured example in the same W3C article, one English one-word label ran 2.6 to 3 times as long in Portuguese, French and Italian. A page quoting a flat 30 to 35 percent is quoting a figure with no authoritative source behind it and getting the shape of the problem backwards: the short labels break first.
What Do You Get Back, and What Does It Cost?
You get the same files back, translated, revised and in the structure they arrived in, with their keys, placeholders and escaping unchanged. Every target language is written by a linguist who works into their own language and has at least five years of experience, and a second linguist then revises the translation against the source before delivery, which is the process ISO 17100:2015 sets out and which we are certified to as a translation service provider. The actual translation work is human translation throughout, done by professional translators drawn from more than 2,000 professional linguists, and the second pass by a different person is the part of translation quality no tool supplies. One project manager owns the work from the first file to the last.
Before translation starts we build a glossary of your product’s own terminology, the nouns in your navigation, your object names, your plan names and the verbs on your buttons, and we agree it with you. That glossary and the translation memories built from it are what keep the second release consistent with the first, and what stop you paying twice for a string that has not changed. Both stay yours, and they are also the cheapest way to manage translation across a product family, because a string approved once is approved everywhere.
Day to day the work runs on a standard translation management setup: CAT tools, translation memories, a term base, and automated quality assurance checks looking for an untranslated segment, a changed number, a missing placeholder, a broken tag, or a string that has grown past a length limit you gave us. Automation catches the mechanical faults; the second linguist catches the ones that simply read wrongly. Files move over secure transfer under a non-disclosure agreement, and access is limited to the linguists on your project. AI tools sit inside that translation process rather than in place of it: machine translation engines and other translation engines can pre-fill a batch where you ask for one, AI translation output is labelled as such, and no translation tool decides what ships.
Alongside the strings themselves, we translate the contracts, data-processing terms and policies that come with shipping a product in a new market, certify a translation where a filing needs one, and turn product video and screencast audio into text that can then be translated and subtitled.
Software localization is priced per word for the interface and the documentation, which is the unit the work is actually done in, and per page for a certified translation of a document. Standard work is $0.10 per word and delivered in 2 to 3 working days; a certified translation is $30 per page of up to 250 words in 24 to 48 hours; and 24-hour express is available on selected projects. The quote is itemized by file and by language pair, so you can see which market and which component is carrying the cost. It is free, and it reaches you within 1 hour.
| Service | Price | Delivery |
|---|---|---|
| Interface strings, resource files and product documentation | From $0.10 per word | 2 to 3 working days |
| Certified translation of contracts, policies and filings | From $30 per page of up to 250 words | 24 to 48 hours |
| Express work on a release that is already in flight | Quoted per project | 24 hours for selected projects |
| Quote | Free | Within 1 hour |
Which Other Language Services Share This Pipeline?
The same linguists, glossary and translation memories cover the website and store around the product, the marketing content that launches it in a new target market, and the recorded product walkthroughs that have to become text before they can be translated or subtitled, so one multilingual programme does not need four suppliers. Localization teams managing localization across more than one product use a single memory for all of them, so translated content stays consistent wherever it is published. Automation moves the files between those stages; people do the language.
How Does the Software Localization Process Work, Step by Step?
Four steps, and the first one decides the price. Send the resource files rather than a description of them, and the quote that comes back within 1 hour is the one you will be invoiced from.
Step 1: Send the Resource Files, Not Screenshots
Upload the files your build produces, whether that is .po and .pot, .xlf, strings.xml, an .xcstrings catalog, RESX, JSON or YAML, and tell us three things with them: which target languages you need, where in the product the strings appear, and when the release branch closes. Developer comments and context notes inside the files are worth more than anything else you can send. A string with a note saying it is a button label is translated once; the same string without one is translated twice.
Step 2: A Free Quote Within 1 Hour, and a Glossary Before Anyone Translates
A project manager counts the words that are genuinely new, separates the segments a translation memory already covers, prices each language pair and each file, and sends an itemized quote within 1 hour at no cost. On a first project we also propose a glossary and a style note, covering how the product addresses the user, whether your object names are translated or kept in English, and how plan and feature names are handled. Nothing is translated until you have agreed them.
Step 3: Translation, Self-Check and Second-Linguist Revision
A translator who writes into their own native language and knows software translates the strings in their resource format, leaving the placeholders, the plural categories and the markup exactly where they are, then checks their own work, which ISO 17100 treats as part of translating rather than as a separate opinion. A second linguist then revises the result against the source. Automated checks run alongside both passes, flagging an untranslated segment, a changed number, a lost placeholder, or a string that has grown past a limit you set.
Step 4: Delivery Back Into the Build, and the Next Release
Files come back in the format they arrived in, with the same keys and the same escaping, so they go straight into the repository: in practice a merge request against the branch your pipeline exported from, whether that lives in GitHub or anywhere else. Then you build it and we look at it, because a length problem and a context problem are both invisible in a file and obvious on a screen. Give us a staging URL or a build and the review comes back as an ordered list of strings to change with a reason for each. From the following release onwards only the changed strings come to us, and the memory and glossary carry forward, which is why a later batch costs less than the first.
Why Do UI Strings Break When Only the Words Are Translated?
Because a string is code as much as it is text, and four of its properties survive translation badly. Length is the first: translated text is usually longer, and longest of all on the shortest strings, so a button that fits in English clips in German or wraps onto a second line and pushes the layout down. Plural branching is the second: English needs two forms, Arabic has six categories, Korean effectively has one, and a sentence built as ‘You have ‘ plus a count plus ‘ messages’ cannot be branched at all once it has been split into three pieces. Formats are the third: a date written as a template in the code rather than requested from the platform reads as a different month depending on who is looking at it. Direction is the fourth: a right-to-left interface mirrors, and mixed-direction text follows UAX #9 rather than the order the characters were typed in.
What we do about it is practical rather than clever. We flag concatenated strings before translating them, because the repair belongs in the code. We ask for a character limit per key wherever the interface has one and write to it. We supply every plural category the target language uses rather than the two English needs. We return a note on any string whose meaning we had to guess. And we look at the running build rather than only the file. The language work is the same discipline as any other technical translation where terminology is the expensive part; the difference here is that the container has a width.
Which Problems Are Cheaper to Fix Before Translation Than After?
Five, roughly in order of what they cost if they are left. Text concatenated in code instead of formatted through a message, which no translator can repair in a resource file. Hard-coded date, number and currency formats. Keys with no context note, which come back as the wrong part of speech. One string reused in two places that mean different things, which forces one of the two translations to be wrong. And a fixed-width container with no allowance for a longer word. Run a pseudo-localized build and all five surface in an afternoon. Fixing them before a localization project starts is the difference between translating once and translating twice, and it is worth more than anything in the quote.
Which Related Language Services Work Alongside Localization?
Localization rarely arrives on its own, and one of the following is usually the right next page, whether the job is a contract that has to be filed, a website going out in the same release, or an audio track that needs a transcript first.
Certified Translation Services
Shipping into a new market usually means a document as well as a product: a reseller contract, a data-processing agreement, a filing for a local entity. Explore our Certified Translation Services, priced at $30 per page of up to 250 words and delivered in 24 to 48 hours.
Legal Translation Services
Terms of service, license agreements, privacy policies and anything a lawyer in the target market will read are a different discipline from interface copy. Visit our Legal Translation Services, and our sworn translation page if a destination outside the United States asks for one under that name.
Medical Translation Services
Health software, patient-facing apps and clinical documentation carry terminology where an agreed glossary costs less than a correction. See our Medical Translation Services.
Technical Translation Services
Manuals, API references, integration guides and the engineering documentation wrapped around a product are priced on repetition and file format. Learn more about our Technical Translation Services.
Digital Marketing Translation
The website, the store and the campaign that launch the localized product have to work in the target language rather than merely exist in it. Visit our Digital Marketing Translation page, and our website translation page for the pages around the app.
Transcription Services
Product demos, onboarding videos and recorded walkthroughs have to become text before anyone translates them. Explore our Transcription Services, and our subtitling service for the finished video.
2,000+
Linguists
ISO 17100
Certified quality standard
1 hour
Free quote
150+
Languages Supported
What Else Do Product Teams Ask About Software Localization Services?
What is software localization, and how is it different from software translation?
Software translation converts the words in your strings; software localization adapts the product those strings sit inside. Localization takes in the resource files themselves, the plural and gender branching inside each message, the date, number and currency formats drawn from locale data, the sort order of a list, the width of the control a label has to fit, the direction the layout runs in, and the help documentation, release notes and app-store listing around the product. Translation is one step within it, and professional localization therefore starts before the first string is translated. The practical difference shows up in what you send and what comes back: a translation project takes a document, and a localization project takes .po, .xlf, strings.xml or .xcstrings files and returns them with their identifiers, placeholders and plural categories intact.
What does software localization cost?
Interface strings and product documentation are priced per word, at $0.10 per word for standard work delivered in 2 to 3 working days, and a certified translation of a document is $30 per page of up to 250 words in 24 to 48 hours. Three things move the total more than the rate does: how many words are genuinely new rather than already held in a translation memory, how many target languages you are adding at once, and whether the strings arrive in their resource format or have to be rebuilt from screenshots. Express handling on a release already in flight is quoted per project. Send the files and an itemized quote reaches you free within 1 hour.
Which resource file formats can you work in?
GNU gettext .po, .pot and .mo; XLIFF 2.1; Android string resources in strings.xml, including string-array and plurals resources; Apple String Catalogs (.xcstrings) and the earlier .strings and .stringsdict pair; RESX; JSON; YAML; .properties; Markdown and HTML for documentation; and CSV or a bilingual table where nothing better can be extracted. We work in the format your toolchain already produces and return it with the same keys, escaping and structure, so a diff between the source and the delivery shows nothing but language. If your strings are locked inside compiled resources or a database, tell us at the quote stage and we will agree an extraction route before any words are counted.
How long does a software localization project take?
Standard work is delivered in 2 to 3 working days and 24-hour express is available on selected projects, with a certified document translation taking 24 to 48 hours. Those are the scheduling windows rather than a promise about your particular release: a first project in a new language also needs time for the glossary and style note to be agreed before anyone translates, and a build review in context adds a pass after delivery. From the second release onwards only the changed strings come to us, so an incremental batch is usually a day or two of work rather than a project. The honest answer is that the schedule is agreed with the quote, within 1 hour of your files arriving.
How much does text expand when it is translated?
It depends on how long the string is, and the relationship runs the opposite way to the flat percentage this industry usually quotes. W3C’s internationalization guidance, citing IBM, gives average translated length as a proportion of the English original: 200 to 300 percent for strings up to 10 characters, 180 to 200 percent for 11 to 20, 160 to 180 percent for 21 to 30, 140 to 160 percent for 31 to 50 and around 130 percent above 70 characters. Microsoft’s pseudo-localization guidance uses a heuristic of plus 40 percent with extremes of 200 to 400 percent, and notes that text can also come back shorter. So a one-word button label is where a layout breaks, not a paragraph of help text.
What is internationalization, and do we need it before localizing?
Internationalization is the engineering that makes a product localizable at all, and yes, it has to come first. In practice it means no user-facing text hard-coded in the source, every string reachable through a resource file with a stable key, locales identified by BCP 47 language tags, plural and gender logic expressed through a message format rather than by concatenation, and dates, numbers and currencies formatted from locale data rather than built by hand. Where a product is only partly internationalized we can still start, because most strings are usually extracted and a handful are not. What we will do is list the ones that are a code change, so you are not paying a linguist to work around something only a developer can fix.
Do you use AI or machine translation on software strings?
Every target language is written by a human linguist working into their own language and revised against the source by a second linguist, and that is the service you are buying. Machine translation has real uses inside a pipeline, for triage, for internal-only strings, and for a first pass where you ask for one, and where it is used we say so rather than describing it as something else. That distinction is not only ours: ISO 17100:2015 states in its own scope that the use of raw output from machine translation plus post-editing is outside the scope of the standard, so a supplier cannot both post-edit machine output and present the result as ISO 17100 translation. Automated checks for placeholders, numbers and untranslated segments run on every file regardless.
What is pseudo-localization?
It is a test you run before any translation is ordered. The source strings are mechanically replaced with accented or other-script characters, padded to make them longer, and wrapped in markers, then the product is built and inspected. What it finds is structural: truncated labels, clipped containers, missing glyphs in the font you shipped, text that was never externalized and so stayed in English, and strings being concatenated in code. It is an industry practice rather than a specification: the Unicode glossary has no entry for it, W3C’s internationalization materials carry no article on it, and Microsoft documents it as a methodology without citing a standards body. Treat it as a test to run, not a standard to comply with, and run it before you commission the first language.
Is XLIFF 2.1 or XLIFF 2.2 the current standard?
XLIFF 2.1 is the current OASIS Standard, approved on 13 February 2018. XLIFF 2.2 exists and is written to supersede it, but as of 2 November 2026 it had only reached Committee Specification, dated 13 March 2025: the OASIS document repository for version 2.2 holds committee-stage directories and no approved-standard directory, and the XLIFF Technical Committee page still lists 2.1 as the latest approved version. Both of the usual claims are therefore wrong, whether a page tells you 2.2 is the current standard or that 2.1 is the newest version in existence. We work in 2.1 by default because that is what the toolchains emit, and we will handle a 2.2 file where yours produces one.
Does ISO 17100 cover software localization?
No, and that is worth being precise about. ISO 17100:2015 sets requirements for the processes, resources and other aspects needed to deliver a quality translation service, and its scope says nothing about software localization at all: it governs how a translation is produced, by whom, and with what revision, and it expressly excludes interpreting and raw machine-translation output with post-editing. So Espresso Translations is certified to ISO 17100:2015 and that certified process applies to the translation work inside your localization project, while the engineering around it, the string extraction, the build testing and the release pipeline, is not something any ISO translation standard certifies. A supplier describing ISO 17100 as a localization standard is describing it wrongly.
How do you keep terminology consistent between releases?
With a glossary agreed before the first string is translated and a translation memory that carries forward, both held per account and both yours. The glossary fixes your product’s own nouns, the object names, plan names, navigation labels and the verbs on your buttons, plus the terms that deliberately stay in English. The memory stores every approved segment, so when a release reuses a string it comes back identical rather than re-translated, which also means you are not paying for it twice. Automated checks then flag a term used off-glossary before a file is delivered. Where the same English string genuinely means two different things on two screens, we ask for the key to be split rather than choosing which screen to get wrong.
Can you localize right-to-left and Asian-language interfaces?
Yes, across 150+ languages, including Arabic, Hebrew, Persian and Urdu on the right-to-left side and Japanese, Korean, Simplified and Traditional Chinese and Thai among the Asian languages. The right-to-left work has an engineering half and a linguistic half, and the dividing line is Unicode Standard Annex #9, the Unicode Bidirectional Algorithm, at Revision 52 within Unicode 18.0.0: mirroring the layout is your build’s job, and ordering mixed-direction text is the algorithm’s. What we do is translate the strings, report where a string mixes a Latin reference or a number into right-to-left text, and flag strings whose plural categories or line-breaking behaviour differ from English. For these languages in particular, a review on a device is worth more than a review in a file.
Does any law require us to offer our software in a local language?
Nothing we could verify from a primary source, and that answer is deliberately narrow. The instrument this market cites most is the EU’s accessibility directive, and what it imposes is accessibility rather than language: a software interface is not required to be offered in any given language. Past that we could not confirm a single national requirement by reading the statute itself, so we will not repeat the ones that circulate in this field. The commercial argument is the more useful one in any case. A buyer abandons a checkout they cannot read, support tickets arrive in the user’s language whether or not the product does, and a store listing competes in the language of the search. Treat it as a revenue decision, and take advice in the market itself if a filing turns on it.
How do you handle UI character limits?
Give us the limit as part of the file and we write to it. A character budget per key, carried in a developer comment or a column alongside the string, is the single most useful piece of metadata you can send, and it turns a length problem into a writing problem that gets solved before delivery instead of a layout bug found after. Where a target language cannot say it within the limit, we come back with the shortest faithful option and tell you what it gives up, or we propose changing the English, which is often the better fix. Automated checks flag any delivered string over its stated limit, and a pseudo-localized build run beforehand tells you which controls have no headroom at all.

