@intlayer/docs 9.5.2 → 9.5.4-canary.0

package/blog/en/vue-i18n_vs_intlayer_benchmark.md

@@ -0,0 +1,361 @@
+---
+createdAt: 2026-09-13
+updatedAt: 2026-09-13
+title: "vue-i18n vs Intlayer: 2026 Benchmark"
+description: vue-i18n and Intlayer measured on the same Vite + Vue 3 app. Library size, per-page JavaScript, content leakage, component size and locale-switch reactivity, with the numbers explained.
+keywords:
+  - vue-i18n
+  - Intlayer
+  - Internationalization
+  - i18n
+  - Benchmark
+  - Bundle size
+  - Blog
+  - Vue
+  - Nuxt
+  - Vite
+  - JavaScript
+slugs:
+  - blog
+  - vue-i18n-vs-intlayer-benchmark
+author: aymericzip
+---
+
+# vue-i18n VS Intlayer | Vue Internationalization (i18n) Benchmark
+
+`vue-i18n` is the reference i18n library for Vue. Intlayer is a compiler-based, component-scoped alternative with a Vue integration (`vue-intlayer`). We already compared their [features and developer experience](https://intlayer.org/blog/vue-i18n-vs-intlayer). This article looks at what each one costs once the app is built.
+
+The data comes from [Benchmark Bloom](https://github.com/intlayer-org/benchmark-bloom), an open-source suite that builds the same application with each library and records what the browser actually downloads and executes.
+
+<TOC/>
+
+> **tl;dr**: On the same Vite + Vue 3 app, `vue-i18n` ships **134.9 KB** of gzipped JavaScript per page against **41.3 KB** for the app without i18n. Intlayer ships **57.1 KB**. The `vue-i18n` runtime alone weighs **24.3 KB gzip** (6x Intlayer's 3.9 KB), every page carries **90% of foreign-page strings**, and a component compiled in isolation drags in **196 KB** because it is bound to the global message tree. The `@intlayer/vue-i18n` adapter keeps the `vue-i18n` API and measured **47.0 KB** per page.
+
+## In short
+
+- **vue-i18n** - The de-facto i18n library for Vue 2 / Vue 3 and the core of `@nuxtjs/i18n`. ICU-style messages, SFC `<i18n>` blocks, `v-t` directive, `d()` / `n()` formatters, large ecosystem. Messages are registered on a global instance at `createI18n()`; lazy loading per locale is a manual `setLocaleMessage()` pattern, and per-route splitting is yours to build.
+- **Intlayer** - Component-centric content model. `.content.ts` dictionaries sit next to the component they serve, a build-time compiler (`vite-intlayer`) tree-shakes and lazy-loads them per component and per locale, strict TypeScript types are generated from your content, and missing translations fail at build time. Ships router / SEO helpers, a Visual Editor / CMS and AI-assisted translation.
+
+| Library               | GitHub Stars                                                                                                                                                                   | Total Commits                                                                                                                                                                      | Last Commit                                                                                                                                         | First Version | NPM Version                                                                                                 | NPM Downloads                                                                                                          |
+| --------------------- | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------ | ---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- | --------------------------------------------------------------------------------------------------------------------------------------------------- | ------------- | ----------------------------------------------------------------------------------------------------------- | ---------------------------------------------------------------------------------------------------------------------- |
+| `aymericzip/intlayer` | [![GitHub Repo stars](https://img.shields.io/github/stars/aymericzip/intlayer?style=for-the-badge&label=%E2%AD%90%20stars)](https://github.com/aymericzip/intlayer/stargazers) | [![GitHub commit activity](https://img.shields.io/github/commit-activity/t/aymericzip/intlayer?style=for-the-badge&label=commits)](https://github.com/aymericzip/intlayer/commits) | [![Last Commit](https://img.shields.io/github/last-commit/aymericzip/intlayer?style=for-the-badge)](https://github.com/aymericzip/intlayer/commits) | April 2024    | [![npm](https://img.shields.io/npm/v/intlayer?style=for-the-badge)](https://www.npmjs.com/package/intlayer) | [![npm downloads](https://img.shields.io/npm/dm/intlayer?style=for-the-badge)](https://www.npmjs.com/package/intlayer) |
+| `intlify/vue-i18n`    | [![GitHub Repo stars](https://img.shields.io/github/stars/intlify/vue-i18n?style=for-the-badge&label=%E2%AD%90%20stars)](https://github.com/intlify/vue-i18n/stargazers)       | [![GitHub commit activity](https://img.shields.io/github/commit-activity/t/intlify/vue-i18n?style=for-the-badge&label=commits)](https://github.com/intlify/vue-i18n/commits)       | [![Last Commit](https://img.shields.io/github/last-commit/intlify/vue-i18n?style=for-the-badge)](https://github.com/intlify/vue-i18n/commits)       | Dec 2016      | [![npm](https://img.shields.io/npm/v/vue-i18n?style=for-the-badge)](https://www.npmjs.com/package/vue-i18n) | [![npm downloads](https://img.shields.io/npm/dm/vue-i18n?style=for-the-badge)](https://www.npmjs.com/package/vue-i18n) |
+
+> Badges update automatically. Snapshots will vary over time.
+
+## Side-by-side feature comparison
+
+| Feature                                     | `vue-intlayer` (Intlayer)                               | `vue-i18n`                                                                  |
+| ------------------------------------------- | ------------------------------------------------------- | --------------------------------------------------------------------------- |
+| **Translations near components**            | ✅ Yes, `.content.ts` collocated with each component    | ✅ Via SFC `<i18n>` blocks (optional); global catalogs are the common setup |
+| **TypeScript integration**                  | ✅ Strict types auto-generated from content             | ✅ Good typings; strict key safety needs schema typing and discipline       |
+| **Missing translation detection**           | ✅ TypeScript error + build-time error/warning          | ⚠️ Runtime fallback + console warning                                       |
+| **Rich content (components / Markdown)**    | ✅ Direct support                                       | ⚠️ `<i18n-t>` component interpolation; Markdown via external plugins        |
+| **ICU support**                             | ⚠️ WIP                                                  | ✅ Yes                                                                      |
+| **Formatting (dates, numbers, currencies)** | ✅ Intl-based formatters                                | ✅ `d()` / `n()` with `datetimeFormats` / `numberFormats`                   |
+| **Localized routing**                       | ✅ Helpers for Vue Router / Nuxt, `getMultilingualUrls` | ⚠️ Not core (`@nuxtjs/i18n` or custom router setup)                         |
+| **SEO helpers (hreflang, sitemap, robots)** | ✅ Built-in helpers                                     | ❌ Not core                                                                 |
+| **Tree-shaking (ship only used content)**   | ✅ Per component, per locale, automated by the compiler | ⚠️ Manual: split catalogs, `setLocaleMessage()` per route                   |
+| **Lazy loading**                            | ✅ `importMode: 'dynamic'` (one line of config)         | ✅ Manual `import()` + `setLocaleMessage()`                                 |
+| **Purge unused content**                    | ✅ Dead dictionaries are dropped at build time          | ❌ Not built-in                                                             |
+| **Testing missing translations (CLI / CI)** | ✅ `npx intlayer content test`                          | ⚠️ Third-party (`vue-i18n-extract`)                                         |
+| **AI-powered translation**                  | ✅ Built-in, uses your own provider keys                | ❌ No                                                                       |
+| **Visual Editor / CMS**                     | ✅ Free Visual Editor + optional CMS                    | ❌ No (external localization platforms)                                     |
+| **MCP server & Agent Skills**               | ✅ Yes                                                  | ❌ No                                                                       |
+| **Ecosystem / community**                   | ⚠️ Smaller but growing fast                             | ✅ Large and mature in the Vue ecosystem                                    |
+
+## The benchmark
+
+### What was measured
+
+The [Benchmark Bloom](https://github.com/intlayer-org/benchmark-bloom) suite builds **the same Vite + Vue 3 application** with each library: **10 pages** (home, about, blog, careers, contact, FAQ, pricing, products, settings, team), **10 locales** (`en`, `fr`, `es`, `de`, `it`, `pt`, `zh`, `ja`, `ko`, `ru`), identical components and identical content. Pages are measured in `en` and `fr`.
+
+Both libraries were tested in the **static** configuration, the one most Vue projects ship: for `vue-i18n`, every locale's JSON imported and passed to `createI18n({ messages })`; for Intlayer, the default `importMode: 'static'`. In that mode Intlayer bundles every locale too, but the compiler still scopes content **per component**, so a page only carries the dictionaries of the components it renders.
+
+For each build, the suite records:
+
+- **Lib size**: gzip size of an empty component that only imports the i18n library. The fixed cost of the runtime.
+- **Page JS**: gzip JavaScript downloaded per page, averaged over all pages and locales.
+- **Locale leak %**: share of translated strings found in the downloaded JS that belong to a locale the user is **not** viewing (fingerprinted on `en` and `fr`, so 50% means "the other measured locale is fully present"; with 10 locales bundled, the real waste is higher).
+- **Page leak %**: share of translated strings found in the downloaded JS that belong to a page the user is **not** on.
+- **Component avg**: average gzip size of each component compiled in isolation. Shows how much i18n runtime and catalog a single component drags in.
+- **E2E reactivity**: wall-clock time between selecting a new locale and `html[lang]` updating in the DOM (Playwright, 5 iterations).
+- **Page load**: `PerformanceNavigationTiming.duration`.
+
+> Numbers below come from the run dated **2026-09-12** with `vue-i18n` 11.4.0 and `intlayer` 9.5.0 / 9.5.1. The test application is deliberately small (a few dozen strings per locale), so leakage percentages describe a **pattern**: they grow with your content while the runtime cost stays fixed.
+
+### Results on Vite + Vue 3
+
+| Library                       | Strategy | Lib size (gz) | Lib size (min) | Page JS avg (gz) | Locale leak | Page leak | Component avg (gz) | E2E reactivity | Page load |
+| ----------------------------- | -------- | ------------: | -------------: | ---------------: | ----------: | --------: | -----------------: | -------------: | --------: |
+| **base** (no i18n)            | -        |        0.0 KB |         0.0 KB |          41.3 KB |        0.0% |         - |             1.1 KB |         1.8 ms |   10.8 ms |
+| `vue-i18n`                    | static   |       24.3 KB |        83.2 KB |         134.9 KB |       50.0% |     90.0% |           196.0 KB |         2.8 ms |   13.6 ms |
+| **`vue-intlayer`**            | static   |    **3.9 KB** |    **11.1 KB** |      **57.1 KB** |       56.8% |  **0.0%** |         **7.7 KB** |     **4.5 ms** |   13.8 ms |
+| `@intlayer/vue-i18n` (compat) | static   |        7.9 KB |        23.2 KB |          47.0 KB |       15.0% |      0.0% |             8.4 KB |         1.5 ms |    9.3 ms |
+
+> The base app's page-leak column is left blank: with no i18n library, the fingerprinting picks up hard-coded strings in shared chunks and the number is not meaningful.
+
+**How to read it**
+
+- **Runtime cost.** `vue-i18n` is one of the heaviest runtimes in the whole benchmark: **24.3 KB gzip / 83.2 KB minified** for an empty component that only imports it. `vue-intlayer` costs 3.9 KB gzip. That gap is paid on every page regardless of how many strings you have.
+- **Per-page JavaScript.** The app without i18n weighs 41.3 KB. `vue-i18n` more than triples it to **134.9 KB**; Intlayer lands at **57.1 KB**, +15.8 KB, most of which is the ten bundled locales (see the next point).
+- **Leakage.** With `createI18n({ messages: { en, fr, ... } })`, every page ships every locale and every page's strings: **50% locale leakage** (on the two fingerprinted locales) and **90% page leakage**. Intlayer's `static` mode also bundles every locale (hence the comparable locale-leak figure) but has **0% page leakage**: a page only pulls the dictionaries of the components it renders. Switching to `importMode: 'dynamic'` removes the locale leakage as well; that configuration was not part of this Vue run.
+- **Component size is where the architecture shows.** A component calling `useI18n()` compiles to **196 KB** on average, because `t()` is bound to the global instance that holds every message of every locale. The same component with `useIntlayer()` compiles to **7.7 KB**: it only reaches its own dictionary.
+- **Reactivity** is a non-issue for both (2-5 ms). Vue's reactivity system makes locale switching cheap once the messages are in memory.
+- **`@intlayer/vue-i18n`**, the drop-in adapter, keeps the `vue-i18n` API and measured **47.0 KB per page** and **8.4 KB per component**, with the application code untouched.
+
+> For reference, the same run measured `fluent-vue` at 171.8 KB per page, 29.7 KB of runtime and 217 KB per component.
+
+## Why the gap? Global instance vs. compiled dictionaries
+
+`vue-i18n` is a runtime. `createI18n()` builds a global instance holding a message tree per locale; `useI18n()` binds each component to it; `t("footer.github")` looks the key up at render time. This is what makes SFC `<i18n>` blocks, `v-t`, and runtime message loading possible, and it is also why every component's dependency graph includes the whole tree:
+
+```bash
+.
+├── locales
+│   ├── en.json
+│   ├── fr.json
+│   └── ...                        # one file per locale, all pages inside
+└── src
+    ├── i18n.ts                    # createI18n({ messages: { en, fr, ... } })
+    ├── main.ts
+    └── components
+        └── Footer.vue             # const { t } = useI18n(); t("footer.github")
+```
+
+Optimizing means **you** split `en.json` into per-route files, **you** call `setLocaleMessage()` in a router guard, and **you** keep the route-to-file map correct as components move. The runtime can't do it for you because it has no idea which keys a component will ask for.
+
+Intlayer moves that knowledge to the build. Content is declared next to the component, and `vite-intlayer` resolves which component imports which dictionary:
+
+```bash
+.
+├── intlayer.config.ts
+└── src
+    ├── main.ts                    # createApp(App).use(intlayer)
+    └── components
+        └── Footer
+            ├── Footer.vue         # useIntlayer("footer")
+            └── Footer.content.ts
+```
+
+The compiler emits, per dictionary and per locale, exactly the JSON that component needs, and drops dictionaries nothing imports. Per-route scoping is a consequence of per-component scoping, not a task.
+
+> To also drop the unused locales, set `dictionary.importMode: 'dynamic'` in `intlayer.config.ts`. See the [bundle optimization doc](https://intlayer.org/doc/concept/bundle-optimization).
+
+## Developer experience
+
+### Setup
+
+**vue-i18n**
+
+```ts fileName="src/i18n.ts"
+import { createI18n } from "vue-i18n";
+import en from "../locales/en.json";
+import fr from "../locales/fr.json";
+
+export const i18n = createI18n({
+  legacy: false,
+  locale: "en",
+  fallbackLocale: "en",
+  messages: { en, fr },
+});
+```
+
+```ts fileName="src/main.ts"
+import { createApp } from "vue";
+import App from "./App.vue";
+import router from "./router";
+import { i18n } from "./i18n";
+
+createApp(App).use(router).use(i18n).mount("#app");
+```
+
+**Intlayer**
+
+```ts fileName="intlayer.config.ts"
+import { type IntlayerConfig, Locales } from "intlayer";
+
+const config: IntlayerConfig = {
+  internationalization: {
+    locales: [Locales.ENGLISH, Locales.FRENCH],
+    defaultLocale: Locales.ENGLISH,
+  },
+};
+
+export default config;
+```
+
+```ts fileName="vite.config.ts"
+import { defineConfig } from "vite";
+import vue from "@vitejs/plugin-vue";
+import { intlayer } from "vite-intlayer";
+
+export default defineConfig({
+  plugins: [intlayer(), vue()],
+});
+```
+
+```ts fileName="src/main.ts"
+import { createApp } from "vue";
+import { intlayer } from "vue-intlayer";
+import App from "./App.vue";
+import router from "./router";
+
+createApp(App).use(intlayer).use(router).mount("#app");
+```
+
+### Component
+
+**vue-i18n**
+
+```json fileName="locales/en.json"
+{
+  "counter": {
+    "label": "Counter",
+    "increment": "Increment"
+  }
+}
+```
+
+```vue fileName="src/components/Counter.vue"
+<script setup lang="ts">
+import { ref } from "vue";
+import { useI18n } from "vue-i18n";
+
+const { t, n } = useI18n();
+const count = ref(0);
+</script>
+
+<template>
+  <div>
+    <p>{{ n(count) }}</p>
+    <button :aria-label="t('counter.label')" @click="count++">
+      {{ t("counter.increment") }}
+    </button>
+  </div>
+</template>
+```
+
+`t('counter.label')` is a string until you type the message schema yourself; a typo renders the key.
+
+**Intlayer**
+
+```ts fileName="src/components/Counter/Counter.content.ts"
+import { t, type Dictionary } from "intlayer";
+
+const counterContent = {
+  key: "counter",
+  content: {
+    label: t({ en: "Counter", fr: "Compteur" }),
+    increment: t({ en: "Increment", fr: "Incrémenter" }),
+  },
+} satisfies Dictionary;
+
+export default counterContent;
+```
+
+```vue fileName="src/components/Counter/Counter.vue"
+<script setup lang="ts">
+import { ref } from "vue";
+import { useIntlayer } from "vue-intlayer";
+import { useNumber } from "vue-intlayer/format";
+
+const { label, increment } = useIntlayer("counter");
+const number = useNumber();
+const count = ref(0);
+</script>
+
+<template>
+  <div>
+    <p>{{ number.value(count) }}</p>
+    <button :aria-label="label" @click="count++">
+      {{ increment }}
+    </button>
+  </div>
+</template>
+```
+
+`label` and `increment` are typed; a typo is a TypeScript error, a missing French value is a build error.
+
+### Lazy loading per locale
+
+**vue-i18n**
+
+```ts fileName="src/i18n.ts"
+import { nextTick } from "vue";
+import { createI18n } from "vue-i18n";
+
+export const i18n = createI18n({
+  legacy: false,
+  locale: "en",
+  fallbackLocale: "en",
+});
+
+export const loadLocaleMessages = async (locale: string) => {
+  const messages = await import(`../locales/${locale}.json`);
+  i18n.global.setLocaleMessage(locale, messages.default);
+  await nextTick();
+  i18n.global.locale.value = locale;
+};
+```
+
+Then call `loadLocaleMessages()` from a router guard, and split `locales/{locale}.json` by route yourself if you want per-page scoping.
+
+**Intlayer**
+
+```ts fileName="intlayer.config.ts"
+const config: IntlayerConfig = {
+  // ...
+  dictionary: {
+    importMode: "dynamic",
+  },
+};
+```
+
+## Keep the vue-i18n API, get Intlayer's output
+
+`@intlayer/vue-i18n` is a drop-in adapter: `useI18n()`, `t()`, `d()`, `n()`, `{name}` and `{0}` interpolation, pipe plurals (`"car | cars"`), `v-t` and `i18n.global.locale` keep working, served from Intlayer dictionaries compiled by `vite-intlayer`.
+
+```ts fileName="vite.config.ts"
+import { defineConfig } from "vite";
+import vue from "@vitejs/plugin-vue";
+import vueI18nVitePlugin from "@intlayer/vue-i18n/plugin";
+
+export default defineConfig({
+  plugins: [vue(), vueI18nVitePlugin()],
+});
+```
+
+In the benchmark, the compat build of the same app went from **134.9 KB to 47.0 KB** per page and from **196 KB to 8.4 KB** per component, with the components untouched. Your existing `locales/{locale}.json` can stay the source of truth through the JSON sync plugin.
+
+See the [vue-i18n migration guide](https://intlayer.org/doc/migration/vue-i18n) and the [compatibility doc](https://intlayer.org/doc/compatibility/vue-i18n). Nuxt users have the same path through [`@nuxtjs/i18n` compatibility](https://intlayer.org/doc/compatibility/nuxtjs-i18n).
+
+## When to choose which?
+
+- **Choose vue-i18n** if you want the standard Vue approach, you rely on ICU messages or SFC `<i18n>` blocks, you already use `@nuxtjs/i18n`, or a translation platform expects centralized JSON. Budget the time to split catalogs and lazy-load per route if bundle size matters.
+- **Choose Intlayer** if you want **component-scoped content**, **strict TypeScript**, **build-time missing-key errors**, **zero-effort tree-shaking and lazy loading**, and built-in editorial tooling (Visual Editor, CMS, AI translation, MCP server). Especially relevant for large, modular Vue / Nuxt codebases and design systems.
+- **Choose `@intlayer/vue-i18n`** if you are already on `vue-i18n` and want the bundle gains without a rewrite.
+
+## Related comparisons
+
+- [next-intl vs Intlayer](https://intlayer.org/blog/next-intl-vs-intlayer) (same benchmark)
+- [i18next vs Intlayer](https://intlayer.org/blog/i18next-vs-intlayer) (same benchmark)
+- [Lingui vs Intlayer](https://intlayer.org/blog/lingui-vs-intlayer) (same benchmark)
+- [vue-i18n vs Intlayer (features & DX)](https://intlayer.org/blog/vue-i18n-vs-intlayer)
+- [Is vue-i18n outdated?](https://intlayer.org/blog/is-vue-i18n-outdated)
+
+## GitHub STARs
+
+GitHub stars are a strong indicator of a project's popularity, community trust, and long-term relevance. While not a direct measure of technical quality, they reflect how many developers find the project useful, follow its progress, and are likely to adopt it.
+
+[![Star History Chart](https://api.star-history.com/chart?repos=intlify%2Fvue-i18n%2Caymericzip%2Fintlayer&type=date&legend=top-left)](https://star-history.com/#intlify/vue-i18n&aymericzip/intlayer)
+
+## Conclusion
+
+`vue-i18n` is mature, flexible and deeply integrated with Vue. The benchmark shows what its runtime-first design costs on a Vite build: a **24 KB gzip runtime**, **134.9 KB per page** for an app that weighs 41 KB without i18n, **90% foreign-page content** on every page, and components that each reach **196 KB** because they hang off the global message tree.
+
+Intlayer moves the work into the compiler. Per-component dictionaries and dead-content purging are build outputs, not conventions. On the same app: **3.9 KB runtime**, **57.1 KB per page**, **0% page leakage**, components **25x smaller**. And if a rewrite isn't on the table, `@intlayer/vue-i18n` gets most of the way there with the components untouched.
+
+All the raw data, the test apps and the scripts are in the [Benchmark Bloom repository](https://github.com/intlayer-org/benchmark-bloom). Run it yourself.
+
+Refer to the ['Why Intlayer?' doc](https://intlayer.org/doc/why) for more details.

package/blog/en-GB/history_of_i18n.md

@@ -49,7 +49,7 @@ The solutions have evolved substantially. We progressed from global objects and
 
 This article reviews that evolution from roughly 2011 to 2026: the objectives of each tooling generation, what succeeded, what fell short, and how frontend architectural changes continue to define how we handle i18n today.
 
-![JavaScript Internationalisation Library Ecosystem](https://github.com/aymericzip/intlayer/blob/main/docs/assets/cloud_i18n_logo.png?raw=true)
+![JavaScript Internationalisation Library Ecosystem](https://github.com/aymericzip/intlayer/blob/main/docs/assets/cloud_i18n_logo.webp?raw=true)
 
 ## Table of Contents
 
@@ -149,87 +149,87 @@ The tabs below detail how each ecosystem addressed these challenges, highlightin
 
 <Tab label="Core JavaScript" value="javascript">
 
-| First Release | Library                              | What It Set Out to Solve                                                                                                                                         | Key Innovation                                                                                                                                                             |
-| ------------- | ------------------------------------ | ---------------------------------------------------------------------------------------------------------------------------------------------------------------- | -------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
-| January 2012  | `i18next`                            | Standardise runtime dictionary lookups for browser and Node.js without framework lock-in.                                                                        | Pluggable runtime architecture separating core translation from loaders, detectors, and caching.                                                                           |
-| February 2021 | `typesafe-i18n`                      | Prevent silent runtime errors and broken interpolations caused by untyped string keys.                                                                           | Fully typed translation functions generated directly from translation objects with zero runtime dependencies.                                                              |
-| October 2023  | `paraglide` (`@inlang/paraglide-js`) | Eliminate runtime dictionary lookups, heavy parsers, and bundle bloat.                                                                                           | Compiles messages into tree-shakable ECMAScript modules and plain JS functions.                                                                                            |
-| April 2024    | `intlayer`                           | Replace unmaintainable namespaces, avoid cross-page content leakage, reduce git merge conflicts, and solve the lack of native type safety in the TypeScript era. | Collocates `.content` files directly where functions are called to split code cleanly, auto-generates TypeScript types, and provides built-in visual CMS and AI CLI tools. |
-| June 2025     | `wuchale`                            | Remove the friction of manually extracting text strings and inventing translation keys during development.                                                       | AST-level preprocessing that detects inline text and compiles it into zero-wrapper localised functions at build time.                                                      |
+| First Release | Library                              | Author                                                       | What It Set Out to Solve                                                                                                                                         | Key Innovation                                                                                                                                                             |
+| ------------- | ------------------------------------ | ------------------------------------------------------------ | ---------------------------------------------------------------------------------------------------------------------------------------------------------------- | -------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
+| January 2012  | `i18next`                            | Jan Mühlemann (`@jamuhl`)                                    | Standardise runtime dictionary lookups for browser and Node.js without framework lock-in.                                                                        | Pluggable runtime architecture separating core translation from loaders, detectors, and caching.                                                                           |
+| February 2021 | `typesafe-i18n`                      | Ivan Hofer (`@ivanhofer`)                                    | Prevent silent runtime errors and broken interpolations caused by untyped string keys.                                                                           | Fully typed translation functions generated directly from translation objects with zero runtime dependencies.                                                              |
+| October 2023  | `paraglide` (`@inlang/paraglide-js`) | Samuel Stroschein (`@samuelstroschein`) / Inlang (`@inlang`) | Eliminate runtime dictionary lookups, heavy parsers, and bundle bloat.                                                                                           | Compiles messages into tree-shakable ECMAScript modules and plain JS functions.                                                                                            |
+| August 2024   | `intlayer`                           | Aymeric Pineau (`@aymericzip`)                               | Replace unmaintainable namespaces, avoid cross-page content leakage, reduce git merge conflicts, and solve the lack of native type safety in the TypeScript era. | Collocates `.content` files directly where functions are called to split code cleanly, auto-generates TypeScript types, and provides built-in visual CMS and AI CLI tools. |
+| June 2025     | `wuchale`                            | Kidus Adugna (`@K1DV5`)                                      | Remove the friction of manually extracting text strings and inventing translation keys during development.                                                       | AST-level preprocessing that detects inline text and compiles it into zero-wrapper localised functions at build time.                                                      |
 
 </Tab>
 
 <Tab label="React" value="react">
 
-| First Release | Library          | What It Set Out to Solve                                                                                                                                                               | Key Innovation                                                                                                                                                  |
-| ------------- | ---------------- | -------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- | --------------------------------------------------------------------------------------------------------------------------------------------------------------- |
-| June 2014     | `react-intl`     | Standardise formatting for numbers, dates, currencies, and complex plurals in React.                                                                                                   | Declarative components (`<FormattedMessage>`, `<FormattedDate>`) implementing ICU MessageFormat and ECMA-402 standards.                                         |
-| December 2015 | `react-i18next`  | Provide an idiomatic React binding for `i18next` with reactive re-rendering.                                                                                                           | Evolved with React from Higher-Order Components to `<Trans>` JSX interpolation and the `useTranslation` hook.                                                   |
-| January 2018  | `@lingui/react`  | Reduce JavaScript bundle size penalties caused by runtime ICU parsers.                                                                                                                 | Compile-time Babel/SWC macros compiling `<Trans>` and `t` into compact indexed arrays at build time.                                                            |
-| December 2020 | `use-intl`       | Deliver a lightweight, hook-first, type-safe alternative to legacy React i18n libraries.                                                                                               | Ergonomic `useTranslations` and `useFormatter` hooks with deep TypeScript integration.                                                                          |
-| February 2021 | `@tolgee/react`  | Eliminate the slow feedback loop between developers, translators, and designers.                                                                                                       | In-context browser editing allowing users to Alt-click text, edit translations in place, and capture screenshots.                                               |
-| April 2024    | `react-intlayer` | Deliver a high-performance React implementation of Intlayer tailored specifically for the React component lifecycle, eliminating centralized JSON files and unmaintainable namespaces. | High-performance `useIntlayer` hook tailored for React rendering, auto-generated TypeScript types, per-component bundle tree-shaking, and live visual CMS sync. |
-| July 2024     | `gt-react`       | Automate manual file exports, translator handoffs, and translation maintenance.                                                                                                        | Cloud-native automated AI localisation directly inside React components with machine translation pipelines.                                                     |
-| August 2025   | `@wuchale/jsx`   | Eliminate manual key naming and boilerplate translation hooks in React JSX authoring.                                                                                                  | AST transformation that automatically extracts raw JSX text nodes and compiles them into localised equivalents.                                                 |
+| First Release | Library          | Author                         | What It Set Out to Solve                                                                                                                                                               | Key Innovation                                                                                                                                                  |
+| ------------- | ---------------- | ------------------------------ | -------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- | --------------------------------------------------------------------------------------------------------------------------------------------------------------- |
+| June 2014     | `react-intl`     | Yahoo! / FormatJS              | Standardise formatting for numbers, dates, currencies, and complex plurals in React.                                                                                                   | Declarative components (`<FormattedMessage>`, `<FormattedDate>`) implementing ICU MessageFormat and ECMA-402 standards.                                         |
+| December 2015 | `react-i18next`  | Jan Mühlemann (`@jamuhl`)      | Provide an idiomatic React binding for `i18next` with reactive re-rendering.                                                                                                           | Evolved with React from Higher-Order Components to `<Trans>` JSX interpolation and the `useTranslation` hook.                                                   |
+| January 2018  | `@lingui/react`  | Tomáš Ehrlich (`@tricoder42`)  | Reduce JavaScript bundle size penalties caused by runtime ICU parsers.                                                                                                                 | Compile-time Babel/SWC macros compiling `<Trans>` and `t` into compact indexed arrays at build time.                                                            |
+| December 2020 | `use-intl`       | Jan Amann (`@amannn`)          | Deliver a lightweight, hook-first, type-safe alternative to legacy React i18n libraries.                                                                                               | Ergonomic `useTranslations` and `useFormatter` hooks with deep TypeScript integration.                                                                          |
+| February 2021 | `@tolgee/react`  | Jan Cizmar (`@jcizmar`)        | Eliminate the slow feedback loop between developers, translators, and designers.                                                                                                       | In-context browser editing allowing users to Alt-click text, edit translations in place, and capture screenshots.                                               |
+| August 2024   | `react-intlayer` | Aymeric Pineau (`@aymericzip`) | Deliver a high-performance React implementation of Intlayer tailored specifically for the React component lifecycle, eliminating centralized JSON files and unmaintainable namespaces. | High-performance `useIntlayer` hook tailored for React rendering, auto-generated TypeScript types, per-component bundle tree-shaking, and live visual CMS sync. |
+| July 2024     | `gt-react`       | Ernest McCarter (`@eoinest`)   | Automate manual file exports, translator handoffs, and translation maintenance.                                                                                                        | Cloud-native automated AI localisation directly inside React components with machine translation pipelines.                                                     |
+| June 2025     | `@wuchale/jsx`   | Kidus Adugna (`@K1DV5`)        | Eliminate manual key naming and boilerplate translation hooks in React JSX authoring.                                                                                                  | AST transformation that automatically extracts raw JSX text nodes and compiles them into localised equivalents.                                                 |
 
 </Tab>
 
 <Tab label="Next.js" value="nextjs">
 
-| First Release  | Library                                     | What It Set Out to Solve                                                                                                                                            | Key Innovation                                                                                                                                                                                                        |
-| -------------- | ------------------------------------------- | ------------------------------------------------------------------------------------------------------------------------------------------------------------------- | --------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
-| November 2018  | `next-i18next`                              | Support SSR and SSG with `i18next` in Next.js Pages Router without client waterfalls.                                                                               | `serverSideTranslations` and `appWithTranslation` passing localised namespaces to page props.                                                                                                                         |
-| December 2019  | `next-translate`                            | Simplify configuration and reduce bundle weight in Next.js Pages Router apps.                                                                                       | Webpack loader plugin automatically injecting only the necessary translation namespaces per page.                                                                                                                     |
-| November 2020  | `next-intl`                                 | Re-architect Next.js internationalisation for App Router, React Server Components (RSC), and streaming SSR.                                                         | Native integration with Next.js App Router middleware, Server Actions, and asynchronous Server Components without client JS.                                                                                          |
-| July 2022      | `next-international`                        | Maximise TypeScript type safety with minimal client bundle overhead for Next.js.                                                                                    | Strict type generation for scoped translation keys with lightweight App Router and Pages Router adapters.                                                                                                             |
-| April 2024     | `paraglide-next` (`@inlang/paraglide-next`) | Bring zero-runtime compiled messages to Next.js App Router and Pages Router.                                                                                        | Middleware routing paired with tree-shakable message functions avoiding runtime JSON parsing in RSC and client bundles.                                                                                               |
-| April 2024     | `next-intlayer`                             | Deliver a high-performance Server Component adapter for Next.js App Router and Pages Router, eliminating the need to pass `t()` functions or dictionaries as props. | Native Server Component adapter allowing `useIntlayer` to be called directly in synchronous Server Components without prop-drilling, paired with zero-waterfall server rendering and live visual CMS synchronisation. |
-| September 2024 | `gt-next`                                   | Automate multilingual content generation and dynamic localised routing in Next.js using AI translation.                                                             | App Router integration pairing cloud-based machine translation with Next.js edge middleware and caching layers.                                                                                                       |
+| First Release | Library                                     | Author                                                       | What It Set Out to Solve                                                                                                                                            | Key Innovation                                                                                                                                                                                                        |
+| ------------- | ------------------------------------------- | ------------------------------------------------------------ | ------------------------------------------------------------------------------------------------------------------------------------------------------------------- | --------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
+| November 2018 | `next-i18next`                              | Isaac Hinman (`@isaachinman`)                                | Support SSR and SSG with `i18next` in Next.js Pages Router without client waterfalls.                                                                               | `serverSideTranslations` and `appWithTranslation` passing localised namespaces to page props.                                                                                                                         |
+| December 2020 | `next-translate`                            | Arvin Wiyono (`@arvinn`) / Vinissimus (`@vinissimus`)        | Simplify configuration and reduce bundle weight in Next.js Pages Router apps.                                                                                       | Webpack loader plugin automatically injecting only the necessary translation namespaces per page.                                                                                                                     |
+| December 2020 | `next-intl`                                 | Jan Amann (`@amannn`)                                        | Re-architect Next.js internationalisation for App Router, React Server Components (RSC), and streaming SSR.                                                         | Native integration with Next.js App Router middleware, Server Actions, and asynchronous Server Components without client JS.                                                                                          |
+| July 2022     | `next-international`                        | Tom Dussaix (`@tom-dussaix`)                                 | Maximise TypeScript type safety with minimal client bundle overhead for Next.js.                                                                                    | Strict type generation for scoped translation keys with lightweight App Router and Pages Router adapters.                                                                                                             |
+| October 2023  | `paraglide-next` (`@inlang/paraglide-next`) | Samuel Stroschein (`@samuelstroschein`) / Inlang (`@inlang`) | Bring zero-runtime compiled messages to Next.js App Router and Pages Router.                                                                                        | Middleware routing paired with tree-shakable message functions avoiding runtime JSON parsing in RSC and client bundles.                                                                                               |
+| August 2024   | `next-intlayer`                             | Aymeric Pineau (`@aymericzip`)                               | Deliver a high-performance Server Component adapter for Next.js App Router and Pages Router, eliminating the need to pass `t()` functions or dictionaries as props. | Native Server Component adapter allowing `useIntlayer` to be called directly in synchronous Server Components without prop-drilling, paired with zero-waterfall server rendering and live visual CMS synchronisation. |
+| July 2024     | `gt-next`                                   | Ernest McCarter (`@eoinest`)                                 | Automate multilingual content generation and dynamic localised routing in Next.js using AI translation.                                                             | App Router integration pairing cloud-based machine translation with Next.js edge middleware and caching layers.                                                                                                       |
 
 </Tab>
 
 <Tab label="Vue & Nuxt" value="vue">
 
-| First Release | Library        | What It Set Out to Solve                                                                                                                               | Key Innovation                                                                                                                                      |
-| ------------- | -------------- | ------------------------------------------------------------------------------------------------------------------------------------------------------ | --------------------------------------------------------------------------------------------------------------------------------------------------- |
-| May 2014      | `vue-i18n`     | Provide idiomatic, reactive internationalisation for Vue applications.                                                                                 | Deep reactivity integration, template directives (`v-t`), `$t` helpers, and single-file component `<i18n>` custom blocks.                           |
-| November 2017 | `@nuxt/i18n`   | Handle localised URL routing, SEO hreflang tags, and SSR hydration in Nuxt.                                                                            | Full-stack routing module generating localised routes (prefix, domain), SEO meta headers, and lazy chunk loading.                                   |
-| August 2019   | `fluent-vue`   | Handle complex grammatical gender, cases, and asymmetric language structures in Vue.                                                                   | Vue integration for Mozilla Project Fluent syntax, avoiding complex conditional code for linguistic variations.                                     |
-| April 2025    | `vue-intlayer` | Deliver a high-performance Vue implementation of Intlayer engineered natively for Vue 3 Composition API and Nuxt, avoiding global namespace pollution. | High-performance `useIntlayer` composable tailored for Vue 3 reactive dependency tracking, direct component scoping, and visual editor integration. |
+| First Release | Library        | Author                                      | What It Set Out to Solve                                                                                                                               | Key Innovation                                                                                                                                      |
+| ------------- | -------------- | ------------------------------------------- | ------------------------------------------------------------------------------------------------------------------------------------------------------ | --------------------------------------------------------------------------------------------------------------------------------------------------- |
+| May 2014      | `vue-i18n`     | Kazupon (`@kazupon`)                        | Provide idiomatic, reactive internationalisation for Vue applications.                                                                                 | Deep reactivity integration, template directives (`v-t`), `$t` helpers, and single-file component `<i18n>` custom blocks.                           |
+| November 2017 | `@nuxt/i18n`   | Nuxt Community                              | Handle localised URL routing, SEO hreflang tags, and SSR hydration in Nuxt.                                                                            | Full-stack routing module generating localised routes (prefix, domain), SEO meta headers, and lazy chunk loading.                                   |
+| August 2020   | `fluent-vue`   | Mozilla (`@mozilla`) / Demivan (`@demivan`) | Handle complex grammatical gender, cases, and asymmetric language structures in Vue.                                                                   | Vue integration for Mozilla Project Fluent syntax, avoiding complex conditional code for linguistic variations.                                     |
+| January 2025  | `vue-intlayer` | Aymeric Pineau (`@aymericzip`)              | Deliver a high-performance Vue implementation of Intlayer engineered natively for Vue 3 Composition API and Nuxt, avoiding global namespace pollution. | High-performance `useIntlayer` composable tailored for Vue 3 reactive dependency tracking, direct component scoping, and visual editor integration. |
 
 </Tab>
 
 <Tab label="Angular" value="angular">
 
-| First Release  | Library             | What It Set Out to Solve                                                                                                                        | Key Innovation                                                                                                                                    |
-| -------------- | ------------------- | ----------------------------------------------------------------------------------------------------------------------------------------------- | ------------------------------------------------------------------------------------------------------------------------------------------------- |
-| February 2017  | `ngx-translate`     | Provide dynamic runtime translation in Angular without deploying separate bundles per locale.                                                   | `TranslateService` and `translate` pipe enabling dynamic translation loading and runtime language toggling.                                       |
-| July 2019      | `@ngneat/transloco` | Resolve performance bottlenecks, lack of scoping, and missing features in older Angular libraries.                                              | Structural directive (`*transloco`), scoped translations for lazy-loaded feature modules, SSR support, and extraction CLI.                        |
-| September 2019 | `@angular/localize` | Modernise Angular built-in compile-time i18n to avoid recompiling TypeScript for each language.                                                 | Tagged template literals with `$localize` injected as a fast post-build step in the Ivy compiler engine.                                          |
-| February 2021  | `@tolgee/ngx`       | Integrate collaborative in-context translation and screenshot capturing into Angular workflows.                                                 | Angular pipes and directives connected directly to Tolgee for live in-browser localisation.                                                       |
-| April 2025     | `angular-intlayer`  | Deliver a high-performance Angular implementation of Intlayer engineered natively for modern Angular (Signals, standalone components, and SSR). | High-performance Signal-based reactive content integration tailored for modern Angular change detection, standalone DI, and live visual CMS sync. |
+| First Release  | Library             | Author                                                       | What It Set Out to Solve                                                                                                                        | Key Innovation                                                                                                                                    |
+| -------------- | ------------------- | ------------------------------------------------------------ | ----------------------------------------------------------------------------------------------------------------------------------------------- | ------------------------------------------------------------------------------------------------------------------------------------------------- |
+| February 2017  | `ngx-translate`     | Olivier Combe (`@ocombe`)                                    | Provide dynamic runtime translation in Angular without deploying separate bundles per locale.                                                   | `TranslateService` and `translate` pipe enabling dynamic translation loading and runtime language toggling.                                       |
+| July 2019      | `@ngneat/transloco` | Netanel Basal (`@NetanelBasal`) & Shahar Kazaz (`@shahar_k`) | Resolve performance bottlenecks, lack of scoping, and missing features in older Angular libraries.                                              | Structural directive (`*transloco`), scoped translations for lazy-loaded feature modules, SSR support, and extraction CLI.                        |
+| September 2019 | `@angular/localize` | Angular Team (@angular)                                      | Modernise Angular built-in compile-time i18n to avoid recompiling TypeScript for each language.                                                 | Tagged template literals with `$localize` injected as a fast post-build step in the Ivy compiler engine.                                          |
+| February 2021  | `@tolgee/ngx`       | Jan Cizmar (`@jcizmar`)                                      | Integrate collaborative in-context translation and screenshot capturing into Angular workflows.                                                 | Angular pipes and directives connected directly to Tolgee for live in-browser localisation.                                                       |
+| March 2026     | `angular-intlayer`  | Aymeric Pineau (`@aymericzip`)                               | Deliver a high-performance Angular implementation of Intlayer engineered natively for modern Angular (Signals, standalone components, and SSR). | High-performance Signal-based reactive content integration tailored for modern Angular change detection, standalone DI, and live visual CMS sync. |
 
 </Tab>
 
 <Tab label="Svelte & SvelteKit" value="svelte">
 
-| First Release | Library           | What It Set Out to Solve                                                                                     | Key Innovation                                                                                                                               |
-| ------------- | ----------------- | ------------------------------------------------------------------------------------------------------------ | -------------------------------------------------------------------------------------------------------------------------------------------- |
-| July 2018     | `svelte-i18n`     | Provide an idiomatic, reactive internationalisation library tailored to Svelte reactive stores.              | Store-backed `$t` lookup ensuring fine-grained reactive DOM updates when the locale changes.                                                 |
-| December 2021 | `sveltekit-i18n`  | Handle SSR and route-based translation loading cleanly in SvelteKit applications.                            | Modular loader architecture fetching only the translations and formatters needed for the active SvelteKit route.                             |
-| November 2021 | `@tolgee/svelte`  | Enable in-context localisation in Svelte applications.                                                       | Svelte store bindings integrating with the Tolgee in-context translation overlay and automated screenshot generation.                        |
-| April 2025    | `svelte-intlayer` | Deliver a high-performance Svelte implementation of Intlayer engineered natively for Svelte 5 and SvelteKit. | High-performance reactive content bindings tailored for Svelte 5 Runes (`$state`), component-scoped `.content` declarations, and visual CMS. |
-| July 2025     | `@wuchale/svelte` | Remove boilerplate of declaring dictionaries and importing `$t` functions in Svelte components.              | Svelte preprocessor parsing templates at build time and compiling text nodes into zero-wrapper localised outputs.                            |
+| First Release | Library           | Author                         | What It Set Out to Solve                                                                                     | Key Innovation                                                                                                                               |
+| ------------- | ----------------- | ------------------------------ | ------------------------------------------------------------------------------------------------------------ | -------------------------------------------------------------------------------------------------------------------------------------------- |
+| July 2018     | `svelte-i18n`     | Kaisermann (`@kaisermann`)     | Provide an idiomatic, reactive internationalisation library tailored to Svelte reactive stores.              | Store-backed `$t` lookup ensuring fine-grained reactive DOM updates when the locale changes.                                                 |
+| December 2021 | `sveltekit-i18n`  | Ivan Fevrier (`@ivanfevrier`)  | Handle SSR and route-based translation loading cleanly in SvelteKit applications.                            | Modular loader architecture fetching only the translations and formatters needed for the active SvelteKit route.                             |
+| November 2021 | `@tolgee/svelte`  | Jan Cizmar (`@jcizmar`)        | Enable in-context localisation in Svelte applications.                                                       | Svelte store bindings integrating with the Tolgee in-context translation overlay and automated screenshot generation.                        |
+| October 2025  | `svelte-intlayer` | Aymeric Pineau (`@aymericzip`) | Deliver a high-performance Svelte implementation of Intlayer engineered natively for Svelte 5 and SvelteKit. | High-performance reactive content bindings tailored for Svelte 5 Runes (`$state`), component-scoped `.content` declarations, and visual CMS. |
+| July 2025     | `@wuchale/svelte` | Kidus Adugna (`@K1DV5`)        | Remove boilerplate of declaring dictionaries and importing `$t` functions in Svelte components.              | Svelte preprocessor parsing templates at build time and compiling text nodes into zero-wrapper localised outputs.                            |
 
 </Tab>
 
 <Tab label="SolidJS" value="solid">
 
-| First Release  | Library                  | What It Set Out to Solve                                                                                      | Key Innovation                                                                                                                                                          |
-| -------------- | ------------------------ | ------------------------------------------------------------------------------------------------------------- | ----------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
-| September 2021 | `@solid-primitives/i18n` | Provide an idiomatic i18n primitive matching SolidJS fine-grained reactivity.                                 | Signal-based reactive translation resolver updating DOM nodes without a virtual DOM or unnecessary re-renders.                                                          |
-| April 2025     | `solid-intlayer`         | Deliver a high-performance SolidJS implementation of Intlayer engineered natively for SolidJS and SolidStart. | High-performance Signal-aware content bindings tailored for Solid fine-grained reactive primitives without Virtual DOM overhead, full TypeScript schema autocompletion. |
-| June 2026      | `@lingui/solid`          | Extend compile-time macro extraction and ICU MessageFormat support to SolidJS.                                | Macro transformations adapted to Solid fine-grained reactivity, compiling messages into compact runtime structures.                                                     |
+| First Release  | Library                  | Author                         | What It Set Out to Solve                                                                                      | Key Innovation                                                                                                                                                          |
+| -------------- | ------------------------ | ------------------------------ | ------------------------------------------------------------------------------------------------------------- | ----------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
+| September 2021 | `@solid-primitives/i18n` | SolidJS Community              | Provide an idiomatic i18n primitive matching SolidJS fine-grained reactivity.                                 | Signal-based reactive translation resolver updating DOM nodes without a virtual DOM or unnecessary re-renders.                                                          |
+| July 2025      | `solid-intlayer`         | Aymeric Pineau (`@aymericzip`) | Deliver a high-performance SolidJS implementation of Intlayer engineered natively for SolidJS and SolidStart. | High-performance Signal-aware content bindings tailored for Solid fine-grained reactive primitives without Virtual DOM overhead, full TypeScript schema autocompletion. |
+| June 2026      | `@lingui/solid`          | Tomáš Ehrlich (`@tricoder42`)  | Extend compile-time macro extraction and ICU MessageFormat support to SolidJS.                                | Macro transformations adapted to Solid fine-grained reactivity, compiling messages into compact runtime structures.                                                     |
 
 </Tab>
 
@@ -237,7 +237,7 @@ The tabs below detail how each ecosystem addressed these challenges, highlightin
 
 ## The Four Architectural Eras of JavaScript i18n
 
-![The History of JavaScript i18n Libraries](https://github.com/aymericzip/intlayer/blob/main/docs/assets/history_i18n.png?raw=true)
+![The History of JavaScript i18n Libraries](https://github.com/aymericzip/intlayer/blob/main/docs/assets/history_i18n.webp?raw=true)
 
 Looking across fifteen years of development, we can categorise the history of JavaScript internationalisation into four distinct architectural eras:
 
@@ -287,7 +287,7 @@ For over a decade, commercial translation suites built recurring revenue around
 
 As modern Large Language Models lowered translation costs to fractions of a cent while increasing linguistic accuracy, a new generation of commercial tools emerged to capture this market:
 
-- Platforms such as Paraglide with **linguo.dev** or **General Translation** (`gt-react`, `gt-next`) have introduced proprietary subscription tiers and intermediated cloud pipelines.
+- Platforms such as **lingo.dev** or **General Translation** (`gt-react`, `gt-next`) have introduced proprietary subscription tiers and intermediated cloud pipelines.
 - In contrast, **Intlayer** provides automated AI translation directly out of the box through its CLI, allowing teams to connect their own API keys (such as OpenAI, Anthropic, Mistral, or Google Gemini). There are no markups, commissions, or vendor lock-in, running strictly at the direct, raw cost of your chosen AI provider.
 
 ### More Than i18n: A Complete Multilingual Content System