Mobile app localization: A complete guide for iOS & Android

Mobile app localization is the process of adapting an app’s interface, text, and functionality to suit different languages and cultures. The goal of localization is to provide users with a seamless and culturally relevant experience by translating the app’s content, adjusting visuals, and accommodating regional conventions. This involves more than just translating text; it encompasses various elements, including language, images, date formats, currencies, and other culturally specific components.

Overview:

Types of mobile app localization
How to plan your app localization
App elements you need to localize
Android localization vs iOS localization
First things first: Internationalization
How to localize your mobile app
Common app localization challenges and how to solve them
Localize your app store listings
Benefits of localizing your mobile app
Mobile app localization best practices
Mobile app localization tools
Localize your app with POEditor

Types of mobile app localization

Mobile app localization can be categorized into three main types:

Minimum Viable Localization (MVL)
Full app localization
Hybrid localization

MVL is the most basic form of localization, where only the app’s essential features or content are localized. This is a good option for early-stage app startups that want to get their app to market quickly and cheaply.

Full app localization, on the other hand, is the most comprehensive form of localization, where all of the app’s content is localized, including text, images, dates, times, and units of measurement. This is a good option for app developers who want to reach a global audience and provide a native experience for all their users.

And then we have hybrid localization, which is a combination of MVL and full app localization. In a hybrid localization strategy, certain key elements of the app are localized in all languages, while other elements are only localized in the most important markets. This is a good option for app developers who want to balance cost with localization coverage.

How to plan your app localization

A localization plan saves you from translating the wrong things first, or from finding out at release time that a market needs more than translation. Answer these questions before the first string goes out for translation:

Which markets? Start with the countries where your app already gets downloads or sign-ups without being localized, and where users are likely to pay. App store and analytics data usually show them.
How much of the app? Choose between MVL, a hybrid approach, and full localization for each market. You can start small and expand where the results justify it.
What comes first? The store listing and the flows every user goes through: onboarding, sign-up, payment, notifications and error messages. Help content and rarely used settings can follow.
Who translates? AI or machine translation with human review, your own translators, a localization agency, or a mix, depending on the content and the market.
What’s the budget? Localization isn’t a one-off cost: every release adds new strings. Estimate both the first round and what each update will need.
How will you measure it? Decide in advance what success looks like in each market, for example downloads, conversion, ratings, retention or support tickets in that language.
How does it fit your releases? Localization should be part of every release, not a project that starts after the app is finished.

App elements you need to localize

Mobile app localization encompasses a comprehensive range of elements, such as:

Interface
Date and time formats
Currency
Legal texts
Units of measurement
Cultural references and expressions
Images and graphics
Voiceovers and video
Push notifications, widgets and voice assistant phrases

Improve your localization process

Discover an easy to use and affordable localization app.

Get started

Other key considerations:

Make sure the localized app is accessible to users with disabilities, considering features like screen reader compatibility, alternative text for images, and adjustable text sizes.
Adapt legal disclaimers, privacy policies, and other regulatory content to comply with the laws and regulations of the target locale.
Test the localized app thoroughly to ensure it performs smoothly and efficiently across different devices and network conditions in the target markets.
Conduct multilingual testing with native speakers of the target languages to identify and address any potential localization issues early on.

Android localization vs iOS localization

Overall, when localizing both Android and iOS, you need to follow pretty much the same steps. However, there are some differences – mostly technical – to consider when localizing apps for each platform.

	Android	iOS
Where strings live	strings.xml files in locale folders, such as res/values-fr	.strings files in each language’s .lproj folder, or a String Catalog (.xcstrings) in Xcode 15 and later
Plurals	<plurals> in strings.xml	.stringsdict files next to .strings, or a String Catalog
Exporting for translation	The XML resource files	The resource files, or XLIFF from Xcode’s Export Localizations
Right-to-left support	android:supportsRtl, with start and end attributes	Leading and trailing constraints

Step-by-step guides: How to translate an iOS app and How to localize Android apps

First things first: Internationalization

Internationalization (i18n) is the process of designing and preparing your software to be adaptable to different languages and regions without engineering changes. At its core, i18n involves designing the software to be language and region agnostic. This begins with adopting Unicode (UTF-8) for character encoding, ensuring compatibility with diverse linguistic characters.

Programming languages provide locale and language APIs, such as Java’s Locale class or Swift’s equivalent, enabling the identification of a user’s language and region. A fundamental practice in i18n is the organization of resources into locale-specific bundles. These bundles house string resources, images, and other assets, keeping content separate from the application logic.

Message formatting, date and time functions, and number formatting are essential considerations. Employing placeholders and formatting functions ensures dynamic content adapts to different languages and regions seamlessly.

Additionally, addressing pluralization rules is imperative, as languages often exhibit distinct plural forms. By incorporating these principles, developers establish a foundation for efficient adaptation to diverse linguistic and cultural contexts during the localization process.

Read more:

… consider pseudolocalization too

Pseudolocalization is a technique used to test the readiness of an app for localization by translating the app’s strings into placeholder languages before it is actually localized. It can help developers identify and fix potential localization issues before they are translated into real languages, saving time and money.

Some potential localization issues you can catch early on thanks to pseudolocalization include text overflow, incorrect formatting, and cultural faux pas. To use this technique effectively, make sure to define a set of criteria to ensure that all aspects of the app are pseudolocalized, such as text strings, labels, menus, and error messages.

Read more: What is pseudolocalization?

How to localize your mobile app

Mobile app localization is a complex process encompassing both technical and cultural considerations to ensure seamless user experience and avoid potential cultural faux pas. These steps can help you get acquainted with the process:

Use string resource files

On Android (using Java/Kotlin), you can store string resources in XML files within the res/values folder. On iOS (using Swift or Objective-C), you can use .strings files. These files will contain key-value pairs for each text element in your app.

Identify localizable content

Create a comprehensive list of all the content that needs to be localized, including text strings, images, date and time formats, and any other user interface elements. This ensures that nothing is overlooked during the localization process.

Decide who translates

Choose between in-house translators, professional localization services, AI or machine translation with human review, or a mix. A localization platform lets you combine them in one workflow.

Choose a localization library or API

Select a library or API that suits your platform and development language. For example, on Android, consider using Android’s built-in localization support or third-party libraries like LocalizationActivity. On iOS, use the NSLocalizedString API, and explore third-party libraries like SwiftGen if needed.

Handle plurals and gender variations

Many languages have specific rules for plurals and gender variations. Utilize platform-specific functions or methods to handle these variations dynamically. On Android, use in strings.xml. On iOS, use .stringsdict files or a String Catalog (.xcstrings), which apply each language’s plural rules automatically.

Use dynamic layouts

Account for dynamic content that may affect the layout, such as variable text lengths. Use dynamic layouts in your UI to accommodate varying content lengths gracefully. You may want to consider using constraints or layout guidelines to ensure a responsive design.

Use locale-specific resources

Dynamically load resources based on the user’s locale. Retrieve the current locale through platform-specific APIs, and load the appropriate set of resources accordingly. This ensures that users see content in their preferred language.

Keep translations in sync with your code

Store resource files in version control and connect them to your localization platform, so new strings reach translators automatically and translations come back into the build. This is continuous localization.

Handle RTL (Right-to-Left) languages

If your app supports RTL languages, ensure that your UI adapts accordingly. Use platform-specific tools to handle RTL layouts, adjusting the alignment of UI elements, text, and other components as needed. For RTL support, adapt your UI using platform-specific tools. In Android, set the android:supportsRtl attribute in the manifest, and use start and end attributes for layout direction. In iOS, use the leading and trailing constraints.

Localize all elements

Translate not only text but also images, icons, and multimedia elements. Ensure that images and media content are culturally relevant and appropriate for the target audience. Don’t forget to adjust date, time, and currency formats to match the conventions of the target locale. This ensures that your app is user-friendly and aligns with local customs.

Test localization

Rigorously test your app with different language settings to identify any issues related to layout, text truncation, or visual glitches. Test on devices with varying screen sizes and resolutions to ensure a consistent experience across different devices.

Common app localization challenges and how to solve them

Here are a few issues you may come across when localizing apps:

Localization falls behind your releases

If translation starts only after a feature is finished, every release waits for it, or ships untranslated. Connect your repository to your localization platform so new strings are sent for translation as soon as they’re added, and translations come back into the build automatically. In POEditor, the GitHub, GitLab, Bitbucket and Azure DevOps integrations do this, and workflows can translate new strings with AI as soon as they arrive.

Translators don’t know where a string appears

A word like “Open” or “Back” can be translated in several ways, and a string file doesn’t say which one fits. Give translators context: descriptive keys, a short comment for ambiguous strings, and screenshots of the screens. In POEditor, translators see comments and screenshots next to each string.

Text breaks the layout

Translations are often longer than the source text, and on small screens that means truncated buttons and overlapping labels. Use flexible layouts, run pseudolocalization before translation starts, and check the longest languages on real devices.

Plurals and placeholders go wrong

Plural rules differ from language to language, and a missing or changed placeholder can crash a screen. Use the platform’s plural support instead of building sentences in code, and check every translation for broken placeholders before release. POEditor shows a tab for each plural form of the target language, and its QA checks and placeholder validation catch broken variables.

Terminology drifts between platforms and releases

The same feature ends up with different names in the iOS and Android apps, or in different versions. Use the same keys on both platforms where you can, keep a glossary of product terms, and let translation memory suggest approved translations. In POEditor, you can keep iOS and Android strings in one project and tag them by platform.

Translation errors are found after release

Users notice mistranslations quickly, and they show up in reviews. Review translations before release, at least for the main flows, and test the app with native speakers. In POEditor, AI quality evaluation scores translations so reviewers know where to look first, and proofreading marks what has been checked.

Localize your app store listings

People decide whether to download your app on its store page, so localize it as carefully as the app itself, in both the App Store and Google Play.

Keywords

Research keywords in each language instead of translating the English ones: people in each market search with their own words. On the App Store, the name, the subtitle and the keyword field are what search uses, and the keyword field is limited to 100 characters for each localization, so every term counts.

Name, subtitle and description

The app name and the subtitle can each be up to 30 characters on the App Store, which leaves little room in languages where words are longer. Write them for each market, not word for word. On Google Play, the description also matters for search, so it needs the same keyword research.

Screenshots and preview videos

Screenshots should show the localized interface, with real translations, and any captions on them need translating too. The same goes for preview videos.

Icons and visuals

Check that icons, colors and gestures in your visuals mean the same thing in each market. A symbol that’s neutral in one country can be confusing or offensive in another.

Ratings and reviews

Read reviews in each language and reply in the user’s language. Reviews are also an early warning for translation problems the testing missed.

Benefits of localizing your mobile app

Localizing your app, making it available in multiple languages and locales, offers a range of benefits for app developers and users alike. Without a doubt, the main benefit is growing your user base. By offering your app in multiple languages, you can reach a broader audience around the world. Users are more likely to engage with an app that is available in their native language.

A localized app is more likely to be downloaded and used by users in different regions. This can lead to increased user acquisition and revenue, as users are more likely to pay for an app that is tailored to their language and cultural preferences. Furthermore, App stores often take localization into account when ranking apps.

In a global market, a localized app can also give you a competitive edge over apps that are only available in one language. Users are more likely to choose an app that speaks to them in their own language. They are also more likely to trust and remain loyal to an app that respects and understands their language and cultural preferences.

Recommended read:

Mobile app localization best practices

These practices are interconnected, so make sure to go through everything.

Build with localization in mind from day one

Consider localization from the beginning of the app development process. Externalize all user-facing text and keep it separate from the application code so that content can be translated without requiring technical changes. Developers should also account for text expansion, different character sets and language-specific grammatical rules.

Planning ahead also means supporting Unicode, right-to-left languages and proper pluralization. Avoiding hardcoded text and designing flexible layouts from the start makes it easier to introduce new languages, reduces development costs, and prevents problems later in the localization process.

Adapt to local UX patterns

A localized app also has the date and time formats, currencies, number separators, address fields, and phone number inputs adapted for the local market. Payment methods and input preferences also vary between markets.

Give translators context

Strings without context are the main source of mistranslations in apps. Use descriptive keys, add comments for ambiguous or short strings, and share screenshots of the screens where they appear.

Use locales, not just languages

French in France and French in Canada, or Portuguese in Portugal and in Brazil, differ in vocabulary, formats and sometimes tone. Where it matters for your users, localize for the locale, not only the language. Both platforms support it: on Android with resource folders such as values-fr-rCA, and on iOS with locale-specific folders such as fr-CA.lproj.

Keep text out of images

Text inside images can’t be translated without redrawing the image. Put text in the interface instead, and keep the source files of the images that still need localizing, so they can be updated for each market.

Localize push notifications and system integrations

Now look at every point where users interact with the product. Push notifications, for example, are often the first thing users see. Notifications should be translated naturally, taking into account character limits and how messages appear across different devices and operating systems. The same principle applies to widgets, voice assistant commands, email confirmations, SMS messages and system-related prompts.

Test on real devices in each language

How does the app work and look in each language? Text expansion can cause buttons and menus to overflow, special characters may not display correctly, and right-to-left languages can introduce alignment and navigation problems. It’s important you test on real devices, especially for Android applications where you have a variety of manufacturers, screen sizes and operating-system versions.

Treat localization as a continuous process

Localization does not end when an app launches in a new market. You still have to translate and test every update, new feature or interface change. Integrate localization into the development pipeline so that the new content is identified and sent for translation as part of the regular release process.

Translation management systems, translation memories and automated quality checks can make this process more efficient. These tools help teams manage content, maintain terminology consistency and identify missing translations. In addition, regular reviews by native speakers and feedback from local users will help keep the translations accurate and relevant as the product evolves.

Mobile app localization tools

Selecting the right combination of localization tools depends on the specific needs of your project, the size of your team, and your preferred workflows. However, some commonly used tools stand out as great options for businesses that want to localize their mobile apps:

Translation Management Systems (TMS). Offer centralized hubs for collaboration between developers and translators, handling tasks such as string extraction, translation memory management, and workflow automation.
Automated translation services. Leverage machine translation (MT) capabilities to generate initial translations swiftly. Developers often use APIs from providers like Google Cloud or Azure AI Translator to implement MT within their apps.
App store localization tools. Often integrated directly into app store developer consoles, they allow developers to input translations for each supported language and optimize their app’s visibility in different regions.
Localization file format converters. Support formats such as XML, JSON, or XLIFF and help maintain consistency across different versions of localized content.
Version control systems. Track changes to the source code and localization files, ensuring that everyone on the team is working with the latest versions. Platforms such as GitHub or Bitbucket are some of the most commonly used.
In-app localization testing. Assist in identifying issues related to text length, layout, and overall visual presentation, helping ensure a smooth user experience across different languages and regions.
Continuous Integration and Continuous Deployment (CI/CD) systems. Automate the testing and deployment of app updates, ensuring a smooth integration of localized content into the development pipeline.

Localize your app with POEditor

If you’re looking for a tool to manage multilingual content for application, you may want to consider POEditor. You’ll benefit from a centralized and user-friendly mobile app localization platform that streamlines the translation process, encourages collaboration, and ensures the consistency and accuracy of localized content across multiple languages.

POEditor supports common iOS and Android localization formats like Android XML, iOS .strings, .stringsdict, String Catalogs (.xcstrings) and iOS XLIFF. The platform supports language-specific plural forms. It’s also possible to manage iOS and Android translations within the same project.

You can order translation services from one of our partners or collaborate with your in-house team by inviting them to work on the project. Alternatively, you can choose AI translation and machine translation: your own OpenAI, Anthropic (Claude), Google (Gemini), Azure AI or Amazon Bedrock account, or Google Translate, DeepL and Azure AI Translator.

Some of the other features you can enjoy with POEditor include integrations with various code repositories and services, Translation Memory, History module, glossaries, automated QA checks, tags, comments, webhooks, and more. Plus, our system supports more than 20 localization formats.

Ready to power up localization?

Subscribe to the POEditor platform today!

See pricing

Frequently asked questions

What is mobile app localization?

Adapting an app’s interface, content and store listing for other languages and markets, so it feels native to users there.

How long does it take to localize an app?

It depends on the number of strings and languages. With strings in resource files and a localization platform connected to your repository, new languages can be added in days and kept up to date with every release.

Do I need to localize my app store listing?

Yes. The store page is where people decide to download, and localized titles, keywords and screenshots help your app show up in local searches.

Can I localize iOS and Android apps together?

Yes, if both apps use the same keys. You can keep both in one POEditor project and tag strings by platform.