Getting started with internationalizing your app

In this tutorial, you'll learn how to do the following tasks:

• Externalize strings so that they're available for localization
• Format strings, including names and lists to support regional variation
• Translate strings and test your user interface (UI)

• You've created a Partner account and a development store.
• You understand how apps fit into Shopify and the different ways of distributing your app.

Translation is foundational to localization. The first step of translation involves externalizing any hard-coded strings from your app into translation files.

When your app renders its UI, it looks up the corresponding strings from the translation file that's associated with the requested locale.

The following example shows a hard-coded greeting string from an app:

The following example shows how to externalize the hard-coded greeting string in a translation file:

Text within graphics and images should also be externalized for translation.

Instead of having flat graphics that include text, externalize the text and overlay it on the graphic. Alternatively, you can generate flat graphics for each locale, and switch between them based on the requested locale.

Depending on the audience, the lookup of a translation string uses the preferred locale of either an app user or a buyer.

The mechanism for receiving the locale depends on the type of app or app extension being developed.

For example, embedded apps receive the app user's chosen locale in the locale request parameter in Shopify's GET requests to the app.

Refer to the documentation for your type of app extension for more information.

Beyond language translation, parts of your app's strings should adapt dynamically to different locales.

For example, dates and times, names, numbers, prices, and lists are elements that should be formatted differently based not on language, but on the user's region or preferences.

Remove these elements from your app's strings, use a localization library to generate the formatted versions, and inject the formatted versions dynamically using string interpolation. The following sections describe how to format the following parts of strings:

• Dates and times
• Numbers
• Prices
• Lists
• Names

The format of dates and times varies by region, not by language. As a result, dates and times, such as the following examples, don't belong in translation strings:

Use an API or library to format dates and times. For example, you can use Intl.DateTimeFormat and inject the formatted dates and times into your translations using string interpolation:

The format of numbers varies by region, not by language. As a result, numbers, such as the following examples, don't belong in translation strings:

Use an API or library to format numbers. For example, you can use Intl.NumberFormat and inject the formatted numbers into your translations using string interpolation:

The format of prices varies by currency and region, not by language. As a result, prices, such as the following examples, don't belong in translation strings:

Use an API or library to format prices. For example, you can use Intl.NumberFormat and inject the formatted prices into your translations using string interpolation:

The way that items are combined into lists varies by region, not by language. As a result, lists, such as the following examples, don't belong in translation strings:

Use an API or library to format lists of items. For example, you can use Intl.ListFormat and inject the formatted lists into your translations using string interpolation:

The way that you address a person varies by context and region.

For example, for a person with the given name "Quinn" and surname "Ishida" might be addressed in the following ways:

Don't encode the name formatting conventions of North American English. Instead, use an API or library to format a person's name based on the context, and inject the formatted name into your translations using string interpolation:

Translating strings involves accounting for text expansion in different languages, and providing your source strings to someone that can translate the content.

When interfaces are localized, the content often expands in length. In most languages, text is up to 50% longer on average than English. Some non-Latin languages, such as Japanese, take up more vertical space. For character-based languages, text wrapping and line breaking can’t always rely on spaces to separate words. Your interface needs to be flexible enough to accommodate language formatting and text expansion without changing its context of use.

The Polaris i18n documentation has more information about, and examples of, text expansion issues.

You can use pseudolocalization tools (example) to simulate text expansion before translation is completed. This enables you to test your app's UI for common text expansion issues. For example, you might want to test for overflowing strings or word wrapping.

The Shopify admin can be used in any of the supported languages.

Shopify also translates some buyer-facing strings (first-party themes, checkout, and system messages) into additional languages (for example, refer to the language list in the Dawn theme).

When deciding on which languages to translate into, consider starting with those most common in the regions or markets that your app supports.

Translating content involves providing your source strings to someone that can translate the content into each language.

There are several options for getting translations. The options vary on cost, turn-around time, and quality.

If you or an acquaintance knows another language, then translations for that language can be manually provided.

Machine translation, such as Google Translate, is artificial intelligence software that can generate translations on-demand.

Machine translation can be quick and cost-effective, but the quality of the translations can vary because strings are often translated without context about your app or business.

If your app already has a large community, then sometimes satisfied users are willing to contribute translations. There are tools to help you manage these crowdsourced translations.

The quality of these translations is higher than machine translations. Your users have an intimate knowledge of your app, so they have the context to pick the appropriate words for their language. However, different users might translate using different words, leading to inconsistent translations throughout the app.

Compared to machine translations, the cost and turn-around time are also higher. This method relies on managing and engaging your app's community in an ongoing manner, which can be time-consuming.

By definition, this method requires that you already have a large, satisfied community to engage. Depending on the diversity of your community, it might be difficult to find enough people with fluency in the languages that you're translating your content into.

The highest-quality, but also most costly, option is to engage a third-party translation service. For example, a Language Service Provider (LSP) can manage the work of providing translations for your app.

LSPs manage the relationships with the translators so that you can have confidence in the quality and turn-around time of the translations.

• Provide your translators with all the context that they need.
• Concatenate strings mindfully.

• Learn how to translate your app listing.