Which JavaScript i18n libraries does Locize support?

Locize works with every major JavaScript i18n library: i18next (the deepest integration, built by the same team), react-intl / FormatJS, next-intl, next-i18next, Vue-i18n (Vue 2 and Vue 3), LinguiJS, Polyglot.js, ngx-translate (Angular), Transloco (Angular), svelte-i18n, and any library that loads JSON translations. At the format layer, Locize natively supports i18next JSON (v3 and v4, with and without context), ICU MessageFormat, Fluent, vue-i18n, polyglot.js, i18n.js (Ruby), and Android string resources.

Do I have to use i18next to use Locize?

No. Although i18next has the deepest integration (because Locize was built by the i18next team), Locize is i18n-library-agnostic. You can use Locize with react-intl, next-intl, Vue-i18n, LinguiJS, Polyglot, or any library that loads JSON translations at runtime. The `locizer` client is a small JavaScript module that loads translations from Locize and hands them to your i18n library — works with React, Vue, Angular, vanilla JavaScript, and any framework that can consume JSON.

What i18n formats does Locize natively support?

Locize natively supports the following i18n formats at the platform level — with syntax highlighting, plural conversion (where applicable), and grouping: i18next / locizify (v3 and v4, with or without context), ICU MessageFormat, Fluent (Mozilla), vue-i18n, i18n.js (Ruby), polyglot.js, and Android string resources. LinguiJS, react-intl, and FormatJS are supported via the ICU MessageFormat format. For the full feature matrix, see the i18n formats documentation.

How does Locize compare on i18n library compatibility vs Lokalise, Crowdin, Phrase?

All major TMS platforms support common file formats (JSON, XLIFF, .po, .strings, .resx). The deeper difference is in runtime library integration: Locize has native, first-class integration with i18next via the i18next-locize-backend plugin, including `saveMissing` (auto-capture of new strings at runtime), the in-context editor via subliminal markers, and direct CDN delivery. Lokalise, Crowdin, and Phrase all have JavaScript SDKs but none has the same library-team-built-the-TMS coupling as i18next + Locize. For non-i18next libraries (react-intl, Vue-i18n, LinguiJS, etc.), Locize is competitive on parity but does not have the same depth advantage.

Does Locize support React, Vue, Angular, and Next.js localization?

Yes — all four. For React: use react-i18next (most common), react-intl / FormatJS, or LinguiJS — each documented with code examples and an example repo. For Vue: Vue-i18n (Vue 2 and Vue 3), with format-vue-i18n native support. For Angular: ngx-translate or Transloco, both with example repos. For Next.js: next-i18next, next-intl (App Router), or pure i18next — pick based on your routing style. Each framework has a dedicated sub-page under /i18n-libraries with code snippets.

Does Locize support Ruby on Rails, Android, or Mozilla Fluent?

Yes — at the format layer, Locize natively supports Ruby i18n.js (via the i18n-js Ruby format), Android string resources (Android XML format), and Mozilla Fluent (.ftl files). For Ruby on Rails, the typical workflow is to export translations from Locize as JSON or YAML and load them into your Rails app — or use a CI step to sync at build time. For Android, Locize handles plurals, contexts, and string-array resources. For Fluent, plural logic is handled directly within the format (no separate `_one` / `_other` keys needed).

Polyglot.js + Locize

Lightweight, framework-agnostic JavaScript i18n with built-in plural handling — paired with Locize for cloud translation management, AI translation, and CDN delivery.

Polyglot.js (developed and open-sourced by Airbnb) is a small, framework-agnostic JavaScript internationalization library. It supports interpolation (%{name} syntax), pluralization via its own pipe-separated forms (1 cat ||| %{smart_count} cats), and per-language plural rules — all without depending on ICU MessageFormat or any specific frontend framework.

Locize natively supports the polyglot.js format at the platform level — translators see Polyglot's plural-form syntax in the editor, plural rules are enforced per language, and you do not need to convert formats. The integration uses the locizer client to load translations from your Locize project and CDN, then pass them to a Polyglot instance.

Key facts

Format: polyglot.js (handled by Locize's format-polyglot package — native platform support)
Runtime: Very small (~3–4 KB minified) — Polyglot's main appeal
Plurals: Pipe-separated forms in a single key value, with Polyglot's own per-language plural rules
Framework support: Framework-agnostic — works with React, Vue, Angular, vanilla JavaScript, Node.js
Example repo: locize-polyglot-example
Best for: Small-to-medium apps that want minimal i18n runtime and do not need ICU MessageFormat

How Polyglot works in your code

Basic interpolation and plural usage. Polyglot's smart_count automatically picks the right plural form based on the active locale.

import Polyglot from 'node-polyglot'

const polyglot = new Polyglot({
  phrases: {
    greeting: 'Hello, %{name}!'
  },
  locale: 'en'
})

polyglot.t('greeting', { name: 'World' })
// => "Hello, World!"

polyglot.extend({
  num_cats: '1 cat |||| %{smart_count} cats'
})

polyglot.t('num_cats', { smart_count: 1 })
// => "1 cat"

polyglot.t('num_cats', { smart_count: 5 })
// => "5 cats"

Connecting Polyglot to Locize

The standard pattern: initialize locizer with your Locize project, load translations from the CDN, then pass them into a new Polyglot instance.

// Load translations from Locize CDN into Polyglot
// <script src="https://unpkg.com/locizer/locizer.min.js"></script>
locizer
  .init({
    fallbackLng: 'en',
    projectId: '[your project id]',
    cdnType: 'standard'
  })
  .load('translation', function (err, translations, lng) {
    const polyglot = new Polyglot({ phrases: translations, locale: lng })
    console.log(polyglot.t('some key'))
  })

Translation updates ship from Locize to your running app via the CDN — no rebuild required for translation changes. This is the same continuous localization model used by i18next + Locize, just plugged into Polyglot's API instead.

Full working example. For more on Polyglot's freedom-vs-features tradeoff against i18next and FormatJS, see The freedom of choice: i18next, polyglot, or FormatJS.

Frequently asked questions

What is Polyglot.js?

Polyglot.js (developed and open-sourced by Airbnb) is a small, framework-agnostic JavaScript internationalization library. It supports interpolation, pluralization (with its own pluralization rules per language), and key-based lookups — without depending on the heavier ICU MessageFormat or any specific frontend framework. Polyglot is a good fit for projects that need lightweight i18n with minimal runtime overhead, especially when ICU MessageFormat is overkill.

Does Locize support Polyglot.js?

Yes. Locize natively supports the polyglot.js format at the platform level — pluralization is handled within the format (single key with pipe-separated forms), and translators see the format-specific syntax in the editor. The integration uses the locizer client: a small JavaScript module that loads translations from your Locize project and CDN, then passes them to a Polyglot instance.

How do I connect Polyglot to Locize?

Include the locizer script (or install the npm package), call `locizer.init({ projectId, cdnType })`, then `locizer.load('namespace', callback)` to fetch translations. Inside the callback, create a `new Polyglot({ phrases: translations, locale: lng })` and use it like any other Polyglot instance. Translation updates ship from Locize to your running app via the CDN — no rebuild required for translation changes. Full working example: github.com/locize/locize-polyglot-example.

How does Polyglot handle plurals with Locize?

Polyglot uses its own pluralization syntax — multiple forms in a single string value, separated by `||||`, e.g. `"1 cat" + "||||" + "%{smart_count} cats"`. Locize's polyglot.js format support handles this natively: translators see the plural forms as separate input fields, but the stored value follows Polyglot's pipe-separated convention so your runtime code does not need to change. The right number of forms per language is enforced based on Polyglot's plural rules.

When should I pick Polyglot over i18next, react-intl, or LinguiJS?

Pick Polyglot when you want the smallest runtime, the simplest API, and do not need ICU MessageFormat. It is a good fit for: small-to-medium apps that do not need React-specific i18n hooks, projects where bundle size matters more than feature richness, and codebases that prefer one minimal library over a framework. Pick i18next when you want the richest feature set + deepest Locize integration. Pick react-intl or LinguiJS when you want ICU MessageFormat and React-specific tooling.