
Localizing your product is a great way to reach new markets and generate more revenue. However, it will only be beneficial if you avoid the most common problems with localization.
There are some simple and easy-to-follow tips that you can utilize to make sure that your localization process is successful. 

## Give your texts enough space

If you have tight layouts, a rough rule of thumb is to double the English text and make sure it fits. 
Then you will usually have enough space for translations. 
Russian and German tend to have the longest translations, and the longest words. Get familiar with the shy-hyphen `&shy;` character. You put it in the word's HTML, and it will only break the word/show the hyphen when necessary. 
You can also Google: "[online hyphenation tool](https://www.google.com/search?q=online+hyphenation+tool)" 
so you know the appropriate places to break the word. Here are some example applications:

- [ushuaia.pl](https://www.ushuaia.pl/hyphen/?ln=en)
- [hyphenation24.com](https://www.hyphenation24.com/)
- [hyphenator.net](https://www.hyphenator.net/)
- [juiciobrennan.com/hyphenator](https://juiciobrennan.com/hyphenator/)

![number translations](/blog/number-translations-problem.jpg)

## Number translations

You need to translate numbers with decimals and commas because they are reversed in some languages.
For example: period appears as a comma, comma as a period.

If you are a JavaScript developer, then you can simply use 
[Number object](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Number/toLocaleString) 
to format numbers. See example below:

```js
var exampleNumber = 123456.789;

exampleNumber.toLocaleString('pl-PL');
// output: 123.456,789

number.toLocaleString('ar-EG');
// output: ١٢٣٤٥٦٫٧٨٩
```

## Percent sign problem

The same goes for percent signs. Sometimes the % shows before the number, and not after also there might be a space between the number and percentage sign.
English style guides recommend writing the percent sign (%) following the number with no space between (e.g., 50%) however this might differ for different languages.
- In Turkish and some other Turkic languages, the % sign precedes rather than follows the number without an intervening space.
- In Persian the % sign may appear before or after the numeric value, in either case without a space.
- In Arabic, the % sign is to the left of numbers, as numbers are written from right-to-left. This means that the % sign is to the left of a number. Usually, there will not be a space between this % sign and the number.

## Watch out for Greek question marks
The Greek question mark (;) is often mistaken for a semicolon (;). 
The former marks the end of a sentence or phrase, while the latter is used to separate clauses in the same sentence.

![greek question makr](/blog/greek-question-mark-intelij-idea.png)

## Keep datetime in UTC 
- Always keep datetime in database in UTC. 
- Always return datetime from backend in UTC. 
- Adjust datetime on UI layer using timezone information from user or web browser. 
- Accept datetime in backend with any timezone.

You don't need any special library to format time from UTC to local for users. You can
use standard [JavaScript Date object](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Date) like below:

```js
new Date('2010-10-04T09:48:11.000000Z').toLocaleString('en-US', {
  timeZone: 'Asia/Calcutta'
});
```

The main benefit to that is that the time is always guaranteed to be consistent. 
However, if you would like to reproduce some bug for a user in different timezone, it might be more challenging.
You will be forced to change timezone in your web browser to get the same data as your users sees. 


Localization: Tips & Tricks


## Background

In this article, I will show you how to create a multi-language landing page in GatsbyJS.
I assume you already set up a Gatsby project, and we will start right from adding multi-language pages.

> Check our [template repository on GitHub](https://github.com/simplelocalize/multi-language-gatsby-example). 

## Install dependencies

I will use FormatJS library as it's one of [the most popular React library for internationalization](/blog/posts/the-most-popular-react-localization-libraries), and it plays nice 
with Gatsby plugin system.

```bash
# Npm users
npm install --save react-intl

# Yarn users
yarn add react react-intl
```

## Create i18n configuration file

Create a `i18n.js` file in your `src` directory to keep all i18n configuration in one place.

```jsx
const languages = ['en', 'pl', 'es'];
const defaultLanguage = 'en';

exports.defaultLanguage = defaultLanguage;
exports.languages = languages;
```

## Add utility functions

Create a new file with utility functions. I named it `linkUtils.js` and I put this next to `i18n.js` file in the `src` directory.

```jsx
import {defaultLanguage, languages} from "./i18n";

const getTranslatedPath = (pathname, to) => {
  const currentPageLanguage = getCurrentPageLanguage(pathname);

  let languagePath = '';
  const isDefaultLanguage = defaultLanguage === currentPageLanguage;
  if (!isDefaultLanguage) {
    languagePath = '/' + currentPageLanguage
  }


  let outputPath = `${languagePath}${to}`;

  const hasTrailingSlash = outputPath.endsWith("/");
  if (!hasTrailingSlash) {
    outputPath += "/";
  }

  return outputPath;
}

const getCurrentPageLanguage = (pathname) => {
  const pathElements = pathname.split("/");
  for (let element of pathElements) {
    for (let language of languages) {
      if (element === language) {
        return language;
      }
    }
  }
  return defaultLanguage;
};

export {getTranslatedPath, getCurrentPageLanguage};
```

- `getTranslatedPath` Function returns a route to a page with the same language as the current page.
- `getCurrentPageLanguage` Function returns language from current page path. 

## Create custom link component

To give a user to navigate through our website and keep the page language, we need to create a custom `<a/>` element.

```jsx
import React from "react";
import {Location} from '@reach/router';
import {getCurrentPageLanguage, getTranslatedPath} from "./linkUtils";

const LinkTranslated = ({children = [], className = "", href = "/"}) => {
  return (
    <Location>
      {locationProps => {
        const {pathname = ""} = locationProps.location;
        return <a className={className}
                  href={getTranslatedPath(pathname, href)}
                  hrefLang={getCurrentPageLanguage(pathname)}
        >
          {children}
        </a>;
      }}
    </Location>
  );
};

export default LinkTranslated;
```

Now we can use `LinkTranslated` same as a regular `<a/>` tag from HTML.
We can pass a `href` property with base link to some page, and it will be converted into a translated link.

Learn more about [hrefLang attribute](/blog/posts/what-is-hreflang/).

> I used `Location` component from `@reach/router`, to get access to the `location` object. 

## Add a wrapper for `IntlProvider`

```jsx
import React from "react";
import {IntlProvider} from "react-intl";

function SimpleLocalize(props) {
  const language = props.pageContext.language;
  const messages = props.pageContext.messages;
  return (
    <IntlProvider
      locale={language}
      messages={messages}>
      {props.children}
    </IntlProvider>
  );
}

export default SimpleLocalize;
```

The main role of this component is to simplify a usage of `<IntlProvider/>` on every page.

## Add translations

Create a `i18n-translations.json` file with translations for all languages.

```json
{
  "en" : {
    "welcome-on-our-website" : "Welcome on our multi-language website",
    "hello-world" : "Hello World!",
    "about-us" : "About us",
    "learn-more-about-us" : "Learn more about us",
    "homepage" : "Homepage"
  },
  "pl" : {
    "welcome-on-our-website" : "Witamy na naszej wielojęzycznej stronie internetowej",
    "hello-world" : "Witaj Świecie!",
    "about-us" : "O nas",
    "learn-more-about-us" : "Dowiedz się więcej o nas",
    "homepage" : "Strona główna"
  },
  "es" : {
    "welcome-on-our-website" : "Bienvenido a nuestro sitio web multilingüe",
    "hello-world" : "Hola, mundo.",
    "about-us" : "Sobre nosotros",
    "learn-more-about-us" : "Más información sobre nosotros",
    "homepage" : "Página web"
  }
}
```

Managing a big JSON file like this might be hard and done only by a software team. This is the reason we created 
[SimpleLocalize](/) where you can manage JSON files like this with ease, automatically upload and download them and use 
Google Translate or DeepL to auto-translate the texts. [Try it for free for 7 days!](/register)

## Configure multi-language page generation

Now, edit your `gatsby-node.js` configuration file and override `onCreatePage` function like below.

```jsx
const messages = require("./i18n-translations.json")
const {languages, defaultLanguage} = require("./src/i18n");

exports.onCreatePage = async ({page, actions}) => {
  const {createPage, deletePage} = actions;
  return new Promise((resolve) => {
    let path = page.path;
    deletePage(page);

    for (let language of languages) {
      const isDefaultLanguage = language === defaultLanguage;
      if (!isDefaultLanguage) {
        path = '/' + language + page.path;
      }

      const pageForLanguage = Object.assign({}, page, {
        originalPath: page.path,
        path: path,
        context: {
          language,
          messages: messages[language]
        }
      });
      createPage(pageForLanguage)
    }
    resolve()
  })
};
```

Many things are happening here, right? Let start from the beginning.

- First of all, import `translations.json` file from root directory
- Use `deletePage` to remove default page created by Gatsby
- Iterate over all `languages` from `i18n.js` 
- Add `/{language}` to path if the language is not the default one
- Get translations for given `language` from `messages` object
- Add language and messages to a page context
- Use `createPage` to recreate a page with a new path and translations



## Create a first multi-language page

Create `index.js` in `/src/pages` directory and paste code below:

```jsx
import React from "react";
import {FormattedMessage} from "react-intl";
import LinkTranslated from "../LinkTranslated";
import SimpleLocalize from "../SimpleLocalize";

function IndexPage(props) {
  return (
    <SimpleLocalize {...props}>
      <h1>
        <FormattedMessage
          id="hello-world"
          defaultMessage="Hello World!"
        />
      </h1>

      <p>
        <FormattedMessage
          id="welcome-on-our-website"
          defaultMessage="Welcome on our multi-language website"
        />
      </p>

      <LinkTranslated
        className="btn btn-link"
        href="/about"
      >
        <FormattedMessage
          id="learn-more-about-us"
          defaultMessage="Learn more about us"
        />
      </LinkTranslated>
      <ul>
        <li><a href="/">English (Default)</a></li>
        <li><a href="/pl/">Polish</a></li>
        <li><a href="/es/">Spanish</a></li>
      </ul>

    </SimpleLocalize>
  );
}
export default IndexPage
```

`SimpleLocalize` Component will provide a `<IntlProvider/>` and `intl` object for `<FormattedMessage/>` components.

## Create second multi-language page 

Create file `about.js` in `/src/pages` directory and paste code like below:

```jsx
import React from "react";
import SimpleLocalize from "../SimpleLocalize";
import {FormattedMessage} from "react-intl";
import LinkTranslated from "../LinkTranslated";

function AboutPage(props) {
  return (
    <SimpleLocalize {...props}>
      <h1>
        <FormattedMessage
          id="about-us"
          defaultMessage="About us"
        />
      </h1>

      <LinkTranslated
        className="btn btn-link"
        href="/"
      >
        <FormattedMessage
          id="homepage"
          defaultMessage="Homepage"
        />
      </LinkTranslated>
    </SimpleLocalize>
  );
}
export default AboutPage;
```


## Result

Now, start your project with `npm run develop` and you should see 

![Multi-language Gatsby project example](/blog/gatsby-multi-language-project.png)


## Code repository

Full code can be found on GitHub.

[https://github.com/simplelocalize/multi-language-gatsby-example](https://github.com/simplelocalize/multi-language-gatsby-example)



### Message extraction

![Uploading extracted translation keys to translation editor](/blog/uploading-extracted-translation-keys-in-json-file.jpg)

In the repository, you will also find [additional scripts in `package.json`](https://github.com/simplelocalize/multi-language-gatsby-example/blob/master/package.json).

I installed `@formatjs/cli` as a `devDependency` to extract all translations and IDs from `<FormattedMessage/>` components.

```
## npm
npm install --save-dev @formatjs/cli

## yarn
yarn add -D @formatjs/cli
```

I used [simplelocalize-cli](/docs/cli/get-started/) to upload found IDs and download ready to use translations.

Scripts explanation:
- `npm run extract` script will extract translations to i18n-extracted.json
- `npm run sync` script will upload found translation keys from i18n-extracted.json and download the latest translations from the server to i18n-translations.json


> Once you change a translation in JSON file, you need to restart GatsbyJS to see the effect. Sometimes you might not see a changed translation, then you need to run `npm run clean` before `npm run develop`. 

### Editing translations in SimpleLocalize

Below you see a screenshot from a sample project which I [pushed on GitHub](https://github.com/simplelocalize/multi-language-gatsby-example). Now, I can manage all translations from one place, add more languages and use DeepL or Google Translate to automatically translate them and use in my Gatsby page. 


![Multi-language Gatsby project in SimpleLocalize](/blog/simplelocalize-gatsby-project.png)
Multi-language content with [properly used `hrefLang` attributes](/blog/posts/what-is-hreflang/) will score much higher in SEO results.

Did you notice the small gray icons next to translated texts? I used DeepL integration to auto-translate those texts. 😄


How to create a multi-language website in GatsbyJS?



The **translation** is the process of converting a text or message from one language to another. When it comes to translation, locale and language are two terms that are often used interchangeably. But what does locale mean? And how does it differ from the language in terms of translating texts and adjusting them to regional needs in each country?

This article will answer these questions and explore the uses for locale and language when translating apps and software into different languages around the world.

## How is Language different from Locale?

The question of how to translate from one language to another is not as simple as it may seem. Two primary factors must be addressed to create a complete translation: the language and the locale. 

The first factor, the language, is self-explanatory; this is what will actually be translated. However, there's more than meets the eye with the second factor - locale. 

Locale refers to regional settings such as currency symbols or date formats. One cannot simply translate a word for word without considering these additional parameters that make up an entire culture's way of life and understanding of their world around them.

![World](/blog/world-image.jpg)

## What is a locale?

In an era where digital globalization is on the rise, one of the most important aspects to consider when translating a product or app into another language is locale. What exactly does this mean? 

Locale involves cultural adaptation and tailoring your content for specific audiences in other countries. It means going beyond literal translations that might sound funny to native speakers of that region; instead, you need to get acquainted with their customs and habits to convey meaning without sounding too strange appropriately.

## How to deal with Locale?

Translating software and apps is a challenging task, as different languages have different rules. For example, the word "locale" can be translated to "Lokalität" in German or "locação" in Portuguese, but it cannot be translated into Russian because there is no equivalent word for this concept. 

When starting adjusting each app to local needs, consider those questions:

- How are measurements like currency, date, and time handled there?
- Are there any differences in the way documents are created?
- Does this region have any words/sayings that might mean something else for them than for you?

## Technical side of locale

In the code of an application or page, we write locale identifier as the language code (country) and region where the language variation is used. For example, the English language differs in different parts of the world, so to best adapt the text to the audience, we use words and phrases used in a given region. Thus, English, generally designated as *en*, may adapt in translation the forms for local variations of the language, e.g., *en-GB* for the UK, *en-AU* for Australia or *en-US* for the United States. 

![Locale translations for Spanish](/blog/locale-translations.png)

The format of the locale, the separator, depends on the environment used in the project. Standard separator is "-", but there as some exceptions. "-" will not work for Java which uses *_* instead, whereas *_* won’t work for Windows

```
language-REGION
es-ES
es-CL

language_REGION
es_ES
es_CL
```


## Conclusion

The process of translating apps and software for a global audience can be tricky. When you translate a product for one culture without taking the time to understand their culture as well, there will be some serious problems along the way—and nobody wants that. Understanding the role of locale is vital in the translating process and creating valuable content for your audience.


Language vs Locale: What's the difference?


## Start with FormatJS library (originally react-intl)

Today, I will show you how to localize React application using formatjs.io library (originally yahoo/react-intl). 
It is worth mentioning that this is not the only popular library for React app localization. Second popular library is [i18next](https://github.com/i18next/i18next) which supports many more frameworks than FormatJS. 
If you are interested in i18next integration, you can [check our tutorial here](/blog/posts/i18next-reactjs-localization/).

> **March 2021:** Read [FormatJS CLI integration guide](/docs/integrations/format-js-cli) and extract translation messages directly to the file.

## Create a sample project

I will start with something simple. I will create a new project using [create-react-app](https://github.com/facebook/create-react-app)

```bash
yarn create react-app simplelocalize-react-intl-example
```

## Install dependencies
Add `react-intl` library to your newly created project.
```bash
# Using NPM
npm i -S react react-intl

# Using yarn
yarn add react react-intl
```

## Add Language Context
In this project, I will use `Context` to keep translations and option to change language in real-time. 

```jsx
import React from 'react';

const LanguageContext = React.createContext("en");

export default LanguageContext;
```

Read more about [React Context API](https://reactjs.org/docs/context.html)

## react-intl configuration
Let's create main configuration 

```jsx
import React from "react";
import {IntlProvider} from 'react-intl'
import LanguageContext from "./LanguageContext";

class SimpleLocalize extends React.Component {

  constructor(props) {
    super(props);
    this.state = {
      messages: undefined,
      language: "en"
    };
  }

  componentDidMount() {
    this.setupLanguageMessages(this.state.language);
  }

  setupLanguageMessages = (language) => {
    const projectToken = "5e13e3019cff4dc6abe36009445f0883";
    const translationsUrl = `https://cdn.simplelocalize.io/${projectToken}/_latest/${language}`;
    return fetch(translationsUrl)
      .then((data) => data.json())
      .then((messages) => this.setState({language, messages}));
  };

  render() {
    return (
      <LanguageContext.Provider
        value={{
          changeLanguage: (language) => this.setupLanguageMessages(language)
        }}>
        <IntlProvider
          locale={this.state.language}
          messages={this.state.messages}>
          {this.state.messages ? this.props.children : null}
        </IntlProvider>
      </LanguageContext.Provider>
    )
  }
}

export default SimpleLocalize;
```

This wrapper will keep translations in our `LanguageContext` and it will also provide a function to change language in fly.

## Create project

Create a [SimpleLocalize.io](https://simplelocalize.io) project to get your unique `messages` variable. For this demo project, you can use the `messages` from the example above!

## Wrap your application

Now let's use our newly created `SimpleLocalize` wrapper to provide translations for React application

```jsx
import React from 'react';
import ReactDOM from 'react-dom';
import './index.css';
import App from './App';
import SimpleLocalize from "./SimpleLocalize";

ReactDOM.render(
    <SimpleLocalize>
      <App/>
    </SimpleLocalize>,
  document.getElementById('root')
);
```

Done! React will now fetch translations from SimpleLocalize CDN and provide them to your app. 
Let's check how to use it in the source code.

## Using translations in the app

Now, let's use translations, and create a very simple web page. 

## Usage

Learn how to use it.

```jsx
import React from 'react';
import logo from './logo.svg';
import './App.css';
import {FormattedMessage} from "react-intl";
import LanguageContext from "./LanguageContext";

function App() {

  return (
    <LanguageContext.Consumer>
      {context => (<div className="App">
        <header className="App-header">
          <div>
            <p>
              <FormattedMessage id="USE_BUTTONS_BELOW"/>
            </p>
            <button onClick={() => context.changeLanguage("en")}>English</button>
            <button onClick={() => context.changeLanguage("es")}>Spanish</button>
            <button onClick={() => context.changeLanguage("pl")}>Polish</button>
            <hr/>
          </div>

          <img src={logo} className="App-logo" alt="logo"/>
          <p>
            <FormattedMessage id="DESCRIPTION"/>
          </p>

          <a
            className="App-link"
            href="https://simplelocalize.io"
            target="_blank"
            rel="noopener noreferrer"
          >
            <FormattedMessage id="LEARN_MORE"/>
          </a>
        </header>
      </div>)}
    </LanguageContext.Consumer>
  );
}

export default App;

```


## FormattedMessage component

`<FormattedMessage/>` usage is very easy:
```jsx
<FormattedMessage id="YOUR_TRANSLATION_KEY"/>
```

React will convert `FormattedMessage` tag into `span` tag and put concrete translation into it. You can also use `<FormattedHTMLMessage id="TRANSLATION_WITH_CSS"/>` which will also produce a message with HTML inside `span` tag.
A sample translation key could look like the following:
```shell
TRANSLATION_WITH_CSS = This is my <strong>text</strong>
```

## Switch between languages

In the presented example, I used `LanguageContext.Consumer` to provide function. This function can trigger language change and fetch proper messages from the CDN.

```jsx
 <LanguageContext.Consumer>
      {context => (<div className="App">
        <header className="App-header">
          <div>
            <p>
              <FormattedMessage id="USE_BUTTONS_BELOW"/>
            </p>
            <button onClick={() => context.changeLanguage("en")}>English</button>
            <button onClick={() => context.changeLanguage("es")}>Spanish</button>
            <button onClick={() => context.changeLanguage("pl")}>Polish</button>
            <hr/>
          </div>
          //...
        </header>
      </div>)}
    </LanguageContext.Consumer>
```

You need `Language.Consumer` tag only in places where you would like to change the language. It's not needed for `<FormattedMessages/>` tags.

## Let's check it!

Notice that translation is done in real-time! How cool is that? Very cool!

![React Localization with formatjs](/blog/formatjs_and_react_app_localization.gif)

[see live version](https://react-intl.simplelocalize.io)

Project code is available on [GitHub](https://github.com/simplelocalize/simplelocalize-react-intl).


Translation Hosting

SimpleLocalize CLI

REST API

Auto-translation

Customer-specific translations

I18n

Localization: Tips & Tricks

How to create a multi-language website in GatsbyJS?

Language vs Locale: What's the difference?

FormatJS and React application localization