i18n libraries — Locize works with all of them
Locize is i18n-library-agnostic. Native integration with every major JavaScript i18n library — i18next, react-intl, next-intl, Vue-i18n, LinguiJS, Polyglot, ngx-translate, Transloco — plus platform-level support for the formats they use.
A JavaScript i18n library (sometimes called an i18n framework) handles the runtime translation logic in your application — looking up translation keys, formatting plurals, interpolating variables, switching languages. A translation management system (TMS) like Locize handles everything around the runtime: the translator UI, the workflow, the CDN delivery, the AI translation, the audit trail. The two work together: the i18n library reads translations at runtime; the TMS produces them.
Locize natively supports several i18n formats at the platform level — i18next JSON (v3 and v4), ICU MessageFormat, Fluent, vue-i18n, polyglot.js, i18n.js (Ruby), and Android. LinguiJS, react-intl, and FormatJS are supported via the ICU MessageFormat format (since that's what they use under the hood). For full code-level integration, see instrumenting your code.
i18next
i18next is the most-used JavaScript i18n library and has the deepest Locize integration: the i18next-locize-backend plugin handles loading translations, saveMissing pushes new strings automatically, and the in-context editor uses i18next-subliminal markers for exact key matching.
react-intl / FormatJS
react-intl (now part of the FormatJS project) is React's most-popular ICU MessageFormat library. Use the locizer client to load translations from Locize at runtime, with full ICU plural / select / number / date formatting handled by FormatJS.
next-intl
next-intl is the modern i18n library for Next.js App Router (also works on Pages Router). Pair it with Locize via the locizer client to feed translations into next-intl's getRequestConfig, with optional in-context editing via i18next-subliminal.
Vue-i18n
Vue-i18n is the de-facto i18n library for Vue 2 and Vue 3. Locize supports the vue-i18n message syntax natively at the platform level (plurals, named/list/index interpolation, linked messages). Use the locizer client to feed translations into Vue-i18n's createI18n.
LinguiJS
LinguiJS uses build-time macros (the t-tagged-template syntax for components, defineMessage for plain strings) and ICU MessageFormat at runtime. Locize supports the ICU format natively, so Lingui projects use Locize without format conversion — translations flow from your code's extraction pipeline into Locize.
Polyglot
Polyglot.js (Airbnb) is a small, ICU-free i18n library with built-in plural handling. Locize natively supports the polyglot.js syntax — load translations via the locizer client and hand them to a Polyglot instance.
ngx-translate
ngx-translate is the most-installed Angular i18n library. Connect it to Locize via the locizer client (or a custom loader) so translations come from your Locize project and CDN, with full Angular reactivity.
Transloco
Transloco is a newer Angular i18n library focused on developer ergonomics and lazy-loading. Connect it to Locize the same way you would ngx-translate — via a custom loader fed by locizer.
Formats Locize supports natively
At the i18n-format level (independent of which library you use), Locize handles these natively — with syntax highlighting, plural conversion where applicable, and grouping.
| i18n format | Used by | Locize support |
|---|---|---|
| i18next JSON v4 (CLDR plurals) | i18next family | Native — primary format |
| i18next JSON v3 | i18next pre-v21 projects | Native |
| ICU MessageFormat | react-intl, FormatJS, LinguiJS, next-intl | Native |
| Fluent (Mozilla) | Mozilla projects, projectfluent.org users | Native |
| vue-i18n | Vue-i18n (Vue 2 + Vue 3) | Native |
| polyglot.js | Polyglot (Airbnb) | Native |
| i18n.js (Ruby) | Ruby on Rails, fnando/i18n-js | Native |
| Android string resources | Native Android apps | Native |
See i18n formats documentation for the full feature matrix (syntax highlighting, plural conversion, grouping) and pluralization details per format.
Frequently asked questions
If your question is missing, email support@locize.com
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.
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.
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.
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.
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.
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).