Skip to content

Localizing Jetpack Compose Apps

Jetpack Compose, Localization, Android Development3 min read

Localizing mobile apps is crucial for reaching a wider audience and providing a user experience tailored to different languages and regions. In this article, we will explore the process of localizing Jetpack Compose apps, enabling you to create multilingual applications that resonate with users around the world.

Prepare Your App for Localization

Before diving into the localization process, it's essential to set up your app to support multiple languages. Start by adding the necessary resources and organizing them properly.

Resource Files

In Android development, resource files are used to store localized strings, images, layouts, and other assets. To prepare your app for localization, create separate resource directories for each supported language in the res folder. For example, you can have res/values/strings.xml for the default language (usually English) and res/values-es/strings.xml for Spanish.

String Resources

String resources contain the texts displayed in your app's user interface. Instead of hardcoding the strings directly in your code, extract them into resource files. For example, in Kotlin with Jetpack Compose, you can define string resources using the stringResource() function:


This allows you to replace the text based on the active locale.

Localizing Text Strings

Once your app is set up for localization, you can start translating text strings into different languages. Here's how you can handle localized strings in Jetpack Compose.

Define String Resources

As mentioned earlier, define your app's text strings in separate string resource files for each language. Inside these files, create string resources with unique names and provide the translated values. For example:

1<!-- Default (English) -->
2<string name="greeting">Hello!</string>
4<!-- Spanish -->
5<string name="greeting">¡Hola!</string>

Access Localized Strings

To access the localized strings in your Jetpack Compose app, use the stringResource() function along with the appropriate string resource ID. The function automatically selects the correct translation based on the user's device locale. Here's an example:


The stringResource() function retrieves the appropriate translation based on the device's locale.

Providing Locale-Specific Layouts

In some cases, you may need to adjust the layout of your app based on the language or region. For instance, languages read from right to left (RTL) may require a different UI arrangement. Jetpack Compose makes it easy to provide locale-specific layouts.

Create Resource Files for Layout Variants

Similar to string resources, you can create separate layout resource files for different locales. By default, Jetpack Compose looks for layout resources based on the device's locale settings.

To create a locale-specific layout variant, add the appropriate language identifier to the resource directory name. For example, res/layout can be res/layout-ar for Arabic layouts.

Customize Layouts for Different Languages

Inside the locale-specific layout files, you can customize the UI as necessary. Adjust text alignment, padding, or even rearrange the elements to accommodate the reading direction of the specific language. Jetpack Compose's declarative nature allows you to easily modify the UI based on locale requirements.

Testing and Previewing Localizations

To ensure your localized app works as intended, it's essential to test and preview different language variants during development. Jetpack Compose provides useful tools for testing localizations.

Set Device Locale in the Android Emulator

The Android Emulator allows you to simulate different device locales easily. By changing the system locale settings, you can test how your app behaves with different language translations.

Open the emulator's settings, navigate to "System" > "Languages & input" > "Languages," and add the desired language. This way, you can verify that your app correctly switches to the appropriate localization based on the device settings.

Preview Locales in Jetpack Compose

Jetpack Compose provides a preview function that allows you to see how your app looks with different language variants directly in Android Studio. By utilizing this feature, you can preview the user interface for each supported locale without deploying the app to a physical device or emulator.

To preview a specific locale, annotate your composable function or preview function with @Preview(locale = "es"), replacing "es" with the desired languagecode. For example:

1@Preview(locale = "es")
3fun MyAppPreview() {
4 MyApp()

This will generate a preview of your app with the specified locale, allowing you to verify the layout and text translations.

In Closing

Localizing Jetpack Compose apps is essential for creating user-friendly applications that cater to a global audience. By following the steps outlined in this article, you can prepare your app for localization, localize text strings, provide locale-specific layouts, and test different language variants. Embracing localization empowers you to reach a wider user base and deliver a personalized experience to users around the world.