Assign a different language to a specific app in Android

Are you multilingual and would you like each app on your Android phone to speak the language you want, without changing the entire system? More and more users want this. assign a different language to a specific appWhether it's to practice a language, better understand a complicated interface, or simply because the system isn't in their preferred language.

In the latest versions of Android, especially since Android 13 and with more regional adjustments in Android 14, Google has incorporated an official feature for choose the language for each app separatelyHowever, there are important nuances: not all apps are compatible, the menu path varies depending on the manufacturer, and on older Android versions, you have to resort to workarounds or third-party apps. Furthermore, if you're a developer, the system now offers APIs to centrally manage your app's language.

What is the per-app language feature in Android?

Android 13 introduced a key new feature informally called, “per-app language”Instead of all applications blindly following the system language, the user can manually choose which language each compatible application will use.

This function is displayed in a unified settings section, where the following are shown: all apps that support language selectionFrom there you can specify, for example, that the system is in Spanish, but a specific app works in English, another in French, and another in Chinese, as long as they have the translations included.

There are some important points about how these applications behave with the feature enabled:

When an app is configured as “use system language”Android uses the first supported language from your system language list as a reference.
In the “All languages” section within the app settings, only the following are listed: the languages that the application actually supportsIf a language is not there, you cannot force it from there.
Android 14 and later add advanced regional settings (date format, units, etc.), but these are separate parameters from the language function per app.

How do I change the language of a specific app on Android 13 and later?

On a phone with "pure" Android 13 (like the Pixel line), the process for changing an app's language is quite simple. Some menu names may vary slightly depending on the manufacturer's skin, but the idea is the same: enter a screen where compatible apps are listed and choose a specific language for each one.

The general steps in Android 13 would be something like this:

Open the application Settings from your Android device.
Scroll down to the section System and enter it (on some mobiles it might be in “Additional settings” or similar).
Accede to Languages and text input (or “Languages and Entries”).
Tap on Application languagesYou will see a list of apps that allow you to choose your language.
Select the specific application whose language you want to customize.
Choose language you want that app to use Among the available options: you can set a specific one or leave the system's default language option.

After doing this, the next time you open that app it should appear directly in the language you have selectedprovided the app includes a translation for that language. If you go back to Settings > System > App languages, you can see the status of each app (using the system language or a specific one).

Alternative routes from app settings

In addition to the main route through the System menu, on many devices with Android 13 or higher you can also change the language of an app by going directly into the System menu. from the application settingsThis is useful when you are already managing permissions, notifications, or other parameters of that specific app.

The typical path would be:

OPEN Settings > Apps.
Choose the application that interests you.
Among your options, look for Language (if the app supports separate languages and the manufacturer maintains this section).
Select the desired language for that app.

The result is the same: the application is configured to use a different language than the systemalways respecting the list of translations that it includes.

What to do if an app does not appear in the list of application languages?

One essential limitation is that not all apps are supported with the per-app language feature. If you don't see a specific app in the "App Languages" menu, it's because the developer hasn't enabled this feature or their app simply follows system preferences without exposing language selection in settings.

Some points to keep in mind if you don't find your app on the list:

Only apps whose developers are shown in the list have declared the supported languages and have enabled per-app language support in their manifest (via android:localeConfig or the automatic system).
In certain apps, the language can only be changed from the internal configuration of the application itself or from account parameters (for example, online services that associate the language with the user profile).
If an app seems "stuck" in a language that doesn't match your system settings (for example, it stays in Chinese even though the system is set to Spanish and English), sometimes it can help to delete app data to reset the language selection. Note: This may delete logins, save data, settings, etc.

On highly customized devices, such as some TV boxes or Android forks like YunOS, there may not even be an official per-app language selection section, so You will not be able to use the mechanism introduced in Android 13In such cases, the options are reduced to third-party apps, changing the system language, or more advanced solutions (rooting, firmware modifications, etc.), with the risks that this entails.

Common problems when changing an app's language and how to solve them

There may be situations where, even if you choose a language in the application settings, The interface doesn't change, or only changes partially.This is usually due to several causes, from the app itself to the internet connection or the general configuration of the device.

If you select a language for an app and it's not reflected correctly, you can try the following:

Restart the app: Close the app completely (force stop if necessary) and reopen it to reload language resources.
Check that You have a network connectionSome applications download language resources or additional packages from the server when you change the language. If there is no connection, the change may not take effect.
Add the language to the general system settings and try again:
1. Open Settings on your Android device.
2. Go to System > Languages and text input > Languages.
3. Add that language as a secondary language in the list (it doesn't have to be the primary one).
4. Wait a few minutes and return to the screen of Application languages.
5. Select the app again and choose your desired language.

If after these steps it still doesn't change, it's possible that the The list of languages declared by the app may not be correct. or that the translation support is incomplete. In that case, it's advisable to make sure you have it installed. the latest version of the appbecause developers usually correct these errors and expand the number of languages with updates.

Backward compatibility with Android and special cases

The native language function per app is designed to Android 13 (API level 33) and later versionsIn Android 11, Android 12, or highly modified systems (such as some Chinese forks or certain manufacturer skins), that settings section simply does not exist or is very limited.

For older devices or those with modified systems, situations like these may occur:

The app automatically changes language depending on the global system language, without the option of choosing a different one just for her.
The system only offers a few languages (for example, only Chinese and English), although the base ROM theoretically supports many more, as is the case with some TV boxes or devices running YunOS.
The application always displays the system language of the mobile phone it is synchronized with, as happens with some smart bracelets or wearables that depend on the language of the app on your linked mobile device.

In these cases, the alternatives are more limited.

Using third-party language-forcing applications (Language Enabler, App Locale, etc.) that attempt to force an app to use a specific languageTheir effectiveness depends on the Android version and, in many cases, they require root access.
Change the system's general language to a language compatible with the app or wearable, assuming the rest of the apps and menus are compatible. They will also change the language.
On devices with very closed ROMs (such as some Chinese TV boxes or custom YunOS), often the only realistic way to change the language of the entire environment is install an alternative ROM or look for firmware in another language, something reserved for advanced users and with a risk of bricking.

For example, if you have a YunOS TV box that only displays the system in Chinese, but you know that the KOGameBox TV app shows an English interface when the system is in English, you won't be able to tell the app to use English if the system remains in Chinese and there's no per-app language setting. And on a phone with Android 11, like a Xiaomi Redmi Note 8T, which doesn't include per-app language settings by default, you also won't be able to specify that a particular app uses English while the rest of the system is in Spanish, unless you use third-party methods and, very often, root access.

How to change the general system language on Android?

If what you want is that The entire mobile device changed language. (including all apps that follow the system language), the classic process for adjusting the system language remains valid in Android 13 and many earlier versions.

The usual steps would be:

Open the app Configuration or your mobile settings.
Sign in System or, in some models, in Additional adjustments.
Accede to Languages and inputs (or “Languages and text input”).
Tap on Languages.
Add or select the language you want to use as primary and place it in the first position of the list.

Once applied, the entire operating system, menu options, and the Most apps adapt to the system language They will be displayed in that language if it has been translated. This, for example, could be why a Xiaomi Smart Band 8, which only supports Chinese and English and gets its language from the mobile app, will display everything in English if you set your phone to English, even though you lose the Spanish language in the rest of the interface.

Language features per app for developers in Android 13

From a development standpoint, Android 13 takes an important step forward so that users can Configure the language of each app from Settings without the developer having to reinvent the wheel with custom logic. To achieve this, it introduces two pillars: a centralized system configuration section and a set of public APIs that synchronize with that configuration.

The main new features are:

System language settings per app: a unified Android screen where all the languages supported by each application are displayed, so the user can choose their preferred one.
APIs LocaleManagermethods such as setApplicationLocales() y getApplicationLocales() They allow the app to set or check its language at runtime, coordinating with what the user has chosen in Settings.
Backward compatibility support on AndroidXEquivalent APIs in AndroidX (for example, in AppCompat 1.6.0 or higher) make it easier to bring this behavior to earlier versions of Android as well, with some differences in context (they work with AppCompatActivity for Android 12 and earlier).

These APIs help reduce duplicate code, manage split APKs effectively, integrate with the backup system, and maintain a consistent user experienceIt doesn't matter if the user changes the language from Settings or from an internal app selector, the result is reflected in both places.

Enable automatic language support for apps (AGP 8.1 and Android Studio Giraffe)

Google recommends that developers enable the call whenever possible. “automatic language compatibility for apps”This function allows the build system itself to generate the language configuration file (LocaleConfig) based on existing resources, without the need to create and maintain that XML manually.

The key points of this automated system are:

It works from Android Studio Giraffe and Android Gradle Plugin 8.1provided that one has compileSdkVersion 33 or higher.
AGP inspects project resources (the folders res/values-* (from both the app module and dependent libraries) and generates a archive LocaleConfig with all supported regional configurations.
The final manifesto automatically adds a reference to that localeConfigTherefore, it is not necessary to include the attribute android:localeConfig manually.
If you add new language resources to your app, these are automatically included in the generated LocaleConfig, without you having to touch anything else.

To enable this automatic compatibility, the developer must:

Enable the function by adding the option generateLocaleConfig inside the block androidResources {} file build.gradle.kts (o build.gradle with Groovy) at the module level.
Specify a default locale using a file resources.properties in the folder res of the app module, setting the property unqualifiedResLocale with a valid region name (for example, unqualifiedResLocale=en-US).

AGP combines that default region with all other language resource folders (values-es, values-fretc.) and generates a consistent LocaleConfig. However, if the developer had already created a manual LocaleConfig file, they must delete it before activating this system, because If they coexist, the compilation will fail..

Manually define the languages supported by android:localeConfig

If for any reason you do not want to or cannot use automatic generation, you can manually define the supported languages using an XML file called locales_config.xml and the attribute android:localeConfig in the manifesto.

The manual procedure consists of:

Create the file res/xml/locales_config.xml listing all the languages that the app supports (including the final backup locale, which usually corresponds to the res/values/strings.xml basics). For example:
<?xml version="1.0" encoding="utf-8"?> <locale-config xmlns:android="http://schemas.android.com/apk/res/android"> <locale android:name="en-US" /> <locale android:name="en-GB" /> <locale android:name="fr" /> <locale android:name="ja" /> <locale android:name="zh-Hans-MO" /> <locale android:name="zh-Hant-MO" /> </locale-config>
At the AndroidManifest.xml, within the label <application>, add the attribute android:localeConfig="@xml/locales_config" to tell the system where the language settings are located:

<manifest> ... <application android:localeConfig="@xml/locales_config" ... > </application> </manifest>

Furthermore, the framework offers the possibility of dynamically update this setting to LocaleManager.setOverrideLocaleConfigso that the languages exposed can be customized by region, A/B experiments can be performed, or server-side localization can be integrated.

How to correctly form locale names?

For all of this to work, it is essential to use correct locale namesAndroid follows the convention of combining language code, optional script sequence, and region code, separated by hyphens:

Language: two-letter ISO 639-1 code (or, in some cases, three-letter ISO 639-2 code).
Script (optional): ISO 15924 code (e.g., “Hans” for Simplified Chinese, “Hant” for Traditional Chinese).
Region (optional): two-letter ISO 3166-1-alpha-2 code or three-digit UN M.49 code.

Some common examples of valid tags would be:

en-US – English (United States).
en-GB – English (United Kingdom).
es – Spanish without specifying country.
pt-BR – Brazilian Portuguese.
zh-Hans – Simplified Chinese.
zh-Hant – Traditional Chinese.

Google provides extensive examples in files locale_config.xml sample, including long lists of languages such as af (Afrikaans), ar (Arabic), de (German), es-US (US Spanish), fil (Filipino), fr-CA (French Canada), hi (Hindi), ja (Japanese), ru (Russian), vi (Vietnamese), up to cover dozens of standard locations.

Specify languages in Gradle using resourceConfigurations

Another relevant aspect on the development side is ownership resourceConfigurations at the build.gradle of module. This option allows you to specify which languages should actually be packaged in the APK or AAB, avoiding including unused translations and reducing the app's size.

The typical configuration would look something like this:

android { ... defaultConfig { resourceConfigurations += [ "en", "en-rGB", "fr", "ja", "b+zh+Hans+MO", "b+zh+Hant+MO" ] } }

When this property is defined, the build system only packages the resources of the listed languagesThis prevents translations from libraries that your app doesn't want exposed from being included. It is recommended to keep the languages specified in [the relevant section/program/etc/app ... resourceConfigurations with those defined in locales_config.xml or the generated LocaleConfig, to avoid inconsistencies.

It's important to remember that adding languages to an app doesn't magically generate translations: developers must manually locate all texts and resourcesThe per-app language feature only allows you to select which language to use from those already offered by the app.

Language selectors integrated into the app and use of AndroidX

Many apps already had one before Android 13. custom language selector in its settingsWith the new APIs, Google recommends that these internal selectors rely on the public language APIs per app, to avoid duplicating logic and to keep the configuration synchronized with the system.

If the app uses the AndroidX compatibility library (recommended), it can use methods such as AppCompatDelegate.setApplicationLocales() y AppCompatDelegate.getApplicationLocales() Starting with AppCompat 1.6.0. Some relevant details:

In Android 12 and earlier versions, backward compatible APIs work with the context of AppCompatActivitynot with the global context of application.
When calling setApplicationLocales(), the Activity is recreated, unless the app manages the regional configuration changes itself (which involves more work).
It is possible to tell AndroidX to automatically manage the storage of regional settings setting the value autoStoreLocales en true at the AndroidManifest for the service AppLocalesMetadataHolderService, and marking that service as not enabled or exported.

An example of a corresponding manifest entry would be:

<application ...> <service android:name="androidx.appcompat.app.AppLocalesMetadataHolderService" android:enabled="false" android:exported="false"> <meta-data android:name="autoStoreLocales" android:value="true" /> </service> </application>

If this configuration is used, AndroidX will handle reading and writing the language preference, although this can cause disk accesses on the main thread and trigger StrictMode violations if these operations are monitored. Therefore, for performance-sensitive projects, it's important to carefully consider whether to use this configuration. autoStoreLocales or a proprietary solution is maintained.

Direct use of the LocaleManager framework APIs

Another option for apps running on Android 13 and later is to use the framework's native APIs, specifically the class LocaleManagerIn this way, the app can modify and read your preferred language directly from the system, without going through AndroidX (although at the cost of losing some of the convenient backward compatibility).

To set a language from an internal selector, the typical flow would be:

// 1. El usuario elige una etiqueta de idioma, por ejemplo "xx-YY". LocaleManager lm = mContext.getSystemService(LocaleManager.class); lm.setApplicationLocales(new LocaleList(Locale.forLanguageTag("xx-YY"))); // 2. El sistema actualiza la configuración regional y reinicia la app. // 3. A partir de ahí, la UI se muestra en el idioma elegido.

To get the currently configured language for the app and display it in a selector:

LocaleManager lm = mContext.getSystemService(LocaleManager.class); LocaleList currentAppLocales = lm.getApplicationLocales(); // Usar currentAppLocales para marcar la opción activa en la UI.

With these calls, the language chosen by the user is perfectly synchronized between the app's internal selector and the Settings > App Languages screen.

Additional best practices regarding language per app

By integrating the language function per app, there are several interesting recommendations that help to refine the user experience and avoid surprises.

Some key tips would be:

Include the current language when you invoke other appsIf you launch intents whose behavior depends on the language (for example, speech recognition with EXTRA_LANGUAGE), try to adjust that value to the language the app is actually using, not just the system language.
Set Accept-Language header when you open web pages from the app (for example, in custom Chrome tabs) using Browser.EXTRA_HEADERS, so that the remote content is served in the language of the app's interface.
Si vas a delete per-app language support from the system (removing android:localeConfig (from the manifesto), consider restoring the app's language to the system language using LocaleListCompat.getEmptyLocaleList() o LocaleList.getEmptyLocaleList(), so as not to leave the user "stuck" in a language that is difficult to reverse.

Developers are also advised to consult official examples, technical blogs, and Google videos on localization, as these include practical examples, sample code, and sample configuration files (like an extensive locale_config.xml with dozens of standard AOSP languages).

With this entire ecosystem, Android 13 and 14 finally allow something that many users have been asking for for a long time: freely configure the language of each application without having to sacrifice the system's overall language. As long as the app is compatible and the device is up to date, simply go to the "App Languages" menu to have one app in English, another in Spanish, and another in Chinese, while the rest of the system remains in your usual language. On older or highly customized devices, the solution involves changing the global language, using third-party tools, or, when possible, having the developers themselves adopt these APIs to offer a more flexible and convenient experience.