@intlayer/docs 8.9.4 → 8.9.6-canary.0

package/docs/de/dictionary/content_file.md

@@ -1,6 +1,6 @@
 ---
 createdAt: 2025-02-07
-updatedAt: 2026-01-28
+updatedAt: 2026-05-12
 title: Inhaltsdatei
 description: Erfahren Sie, wie Sie die Erweiterungen für Ihre Inhaltsdeklarationsdateien anpassen können. Folgen Sie dieser Dokumentation, um Bedingungen effizient in Ihrem Projekt umzusetzen.
 keywords:
@@ -12,6 +12,9 @@ slugs:
   - concept
   - content
 history:
+  - version: 8.9.0
+    date: 2026-05-12
+    changes: "Inhaltstyp `plural` hinzufügen"
   - version: 8.0.0
     date: 2026-01-28
     changes: "Inhaltstyp-Knoten `html` hinzugefügt"
@@ -66,6 +69,7 @@ import { type ReactNode } from "react";
 import {
   t,
   enu,
+  plural,
   cond,
   nest,
   md,
@@ -84,7 +88,8 @@ interface Content {
     };
   };
   multilingualContent: string; // Mehrsprachiger Inhalt
-  quantityContent: string; // Mengeninhalt
+  quantityContent: string;
+  pluralContent: string; // Mengeninhalt
   conditionalContent: string; // Bedingter Inhalt
   markdownContent: never; // Markdown-Inhalt
   htmlContent: never; // HTML-Inhalt
@@ -121,6 +126,10 @@ export default {
       ">5": "Einige Autos",
       ">19": "Viele Autos",
     }),
+    pluralContent: plural({
+      one: "One car",
+      other: "{{count}} cars",
+    }),
     conditionalContent: cond({
       true: "Validierung ist aktiviert",
       false: "Validierung ist deaktiviert",
@@ -175,6 +184,13 @@ export default {
         ">5": "Einige Autos",
         ">19": "Viele Autos",
       },
+      "pluralContent": {
+        "nodeType": "plural",
+        "plural": {
+          "one": "One car",
+          "other": "{{count}} cars",
+        },
+      },
     },
     "conditionalContent": {
       "nodeType": "condition",
@@ -222,6 +238,7 @@ Inhaltsknoten sind die Bausteine des Wörterbuchinhalts. Sie können sein:
 - **Primitive Werte**: Zeichenketten, Zahlen, Booleans, null, undefined
 - **Typisierte Knoten**: Spezielle Inhaltstypen wie Übersetzungen, Bedingungen, Markdown usw.
 - **Funktionen**: Dynamische Inhalte, die zur Laufzeit ausgewertet werden können [siehe Funktionsabruf](https://github.com/aymericzip/intlayer/blob/main/docs/docs/de/dictionary/function_fetching.md)
+- **Plural-Inhalt**: Siehe Plural-Inhalt [Siehe Plural-Inhalt](https://github.com/aymericzip/intlayer/blob/main/docs/docs/de/dictionary/plural.md)
 - **Verschachtelte Inhalte**: Verweise auf andere Wörterbücher
 
 #### Inhaltstypen
@@ -540,6 +557,8 @@ multilingualContent: t({
 });
 ```
 
+> Siehe [Übersetzungsinhalt (`t`) Doc](https://github.com/aymericzip/intlayer/blob/main/docs/docs/de/dictionary/translation.md) für weitere Informationen.
+
 ### Bedingter Inhalt (`cond`)
 
 Inhalt, der sich basierend auf booleschen Bedingungen ändert:
@@ -553,6 +572,8 @@ conditionalContent: cond({
 });
 ```
 
+> Siehe [Bedingter Inhalt (`cond`) Doc](https://github.com/aymericzip/intlayer/blob/main/docs/docs/de/dictionary/condition.md) für weitere Informationen.
+
 ### Aufzählungsinhalt (`enu`)
 
 Inhalt, der auf aufgezählten Werten basiert und variiert:
@@ -567,6 +588,23 @@ statusContent: enu({
 });
 ```
 
+> Siehe [Aufzählungsinhalt (`enu`) Doc](https://github.com/aymericzip/intlayer/blob/main/docs/docs/de/dictionary/enumeration.md) für weitere Informationen.
+
+### Plural-Inhalt (`plural`)
+
+Inhalt, der je nach Pluralregeln variiert:
+
+```typescript
+import { plural } from "intlayer";
+
+pluralContent: plural({
+  one: "One car",
+  other: "{{count}} cars",
+});
+```
+
+> Siehe [Plural-Inhalt Doc](https://github.com/aymericzip/intlayer/blob/main/docs/docs/de/dictionary/plural.md) für weitere Informationen.
+
 ### Einfügeinhalt (`insert`)
 
 Inhalt, der in anderen Inhalt eingefügt werden kann:
@@ -577,6 +615,8 @@ import { insert } from "intlayer";
 insertionContent: insert("Dieser Text kann überall eingefügt werden");
 ```
 
+> Siehe [Einfügeinhalt (`insert`) Doc](https://github.com/aymericzip/intlayer/blob/main/docs/docs/de/dictionary/insertion.md) für weitere Informationen.
+
 ### Verschachtelter Inhalt (`nest`)
 
 Verweise auf andere Wörterbücher:
@@ -587,6 +627,8 @@ import { nest } from "intlayer";
 nestedContent: nest("about-page");
 ```
 
+> Siehe [Verschachtelter Inhalt (`nest`) Doc](https://github.com/aymericzip/intlayer/blob/main/docs/docs/de/dictionary/nesting.md) für weitere Informationen.
+
 ### Markdown-Inhalt (`md`)
 
 Rich-Text-Inhalt im Markdown-Format:
@@ -599,6 +641,8 @@ markdownContent: md(
 );
 ```
 
+> Siehe [Markdown-Inhalt (`md`) Doc](https://github.com/aymericzip/intlayer/blob/main/docs/docs/de/dictionary/markdown.md) für weitere Informationen.
+
 ### HTML-Inhalt (`html`)
 
 Rich-HTML-Inhalt, der Standard-Tags oder benutzerdefinierte Komponenten verwenden kann:
@@ -616,6 +660,8 @@ localizedHtmlContent: t({
 });
 ```
 
+> Siehe [HTML-Inhalt (`html`) Doc](https://github.com/aymericzip/intlayer/blob/main/docs/docs/de/dictionary/html.md) für weitere Informationen.
+
 ### Geschlechtsabhängiger Inhalt (`gender`)
 
 Inhalt, der sich je nach Geschlecht unterscheidet:
@@ -630,6 +676,8 @@ genderContent: gender({
 });
 ```
 
+> Siehe [Geschlechtsabhängiger Inhalt (`gender`) Doc](https://github.com/aymericzip/intlayer/blob/main/docs/docs/de/dictionary/gender.md) für weitere Informationen.
+
 ### Dateiinhalt (`file`)
 
 Verweise auf externe Dateien:
@@ -640,6 +688,8 @@ import { file } from "intlayer";
 fileContent: file("./path/to/content.txt");
 ```
 
+> Siehe [Dateiinhalt (`file`) Doc](https://github.com/aymericzip/intlayer/blob/main/docs/docs/de/dictionary/file.md) für weitere Informationen.
+
 ## Erstellen von Inhaltsdateien
 
 ### Grundstruktur einer Inhaltsdatei

package/docs/de/plugins/sync-po.md

@@ -160,28 +160,6 @@ syncPO({
   source: ({ key, locale }) => string, // erforderlich
   location?: string, // optionales Label, Standard: "sync-po::path/to/source"
   priority?: number, // optionale Priorität für die Konfliktlösung, Standard: 0
-  format?: 'icu' | 'i18next' | 'vue-i18n', // optional, nur erforderlich, wenn Ihre msgstr-Werte eine spezifische Interpolationssyntax verwenden
-});
-```
-
-#### `format` ('icu' | 'i18next' | 'vue-i18n')
-
-PO-Dateien sind immer Gettext Portable Object-Dateien – das ist festgelegt. Diese Option beschreibt nur die **Interpolationssyntax**, die innerhalb der `msgstr`-Werte verwendet wird, damit Intlayer sie zum Zeitpunkt des Parsens (über `formatDictionary`) in sein eigenes Format konvertieren und beim Schreiben der Ausgabe zurückkonvertieren kann.
-
-- `undefined` _(Standard)_: `msgstr`-Werte werden als einfache Zeichenfolgen behandelt – keine Transformation. Verwenden Sie dies für die meisten PO-Dateien.
-- `'icu'`: `msgstr`-Werte verwenden die ICU-Nachrichtensyntax (z. B. `{count, plural, one {# item} other {# items}}`).
-- `'i18next'`: `msgstr`-Werte verwenden die i18next-Interpolationssyntax (z. B. `{{variable}}`).
-- `'vue-i18n'`: `msgstr`-Werte verwenden die Vue I18n-Syntax.
-
-> Die Transformation wird beim Laden durch `formatDictionary` von `@intlayer/chokidar` angewendet und beim Schreiben mit `formatDictionaryOutput` umgekehrt. Bei komplexen Regeln wie ICU-Pluralen ist die Genauigkeit bei der Hin- und Rückkonvertierung nicht garantiert.
-
-**Beispiel – PO-Dateien enthalten Interpolation im i18next-Stil:**
-
-```ts
-syncPO({
-  source: ({ key, locale }) => `./locales/${locale}/${key}.po`,
-  format: "i18next",
-}),
 ```
 
 ### Mehrere PO-Quellen und Priorität

package/docs/en/benchmark/nextjs.md

@@ -61,6 +61,13 @@ Because the problem is hard, many solutions exist—some focused on DX, others o
 
 Intlayer tries to optimize across these dimensions.
 
+## TL;DR
+
+- **Intlayer** & **next-translate**: Top picks for Next.js performance, offering the smallest footprint and best static rendering support.
+- **next-intl**: Trendiest option but heavy and complex to optimize for large applications.
+- **next-i18next**: Popular and plugin-rich, but carries significant bundle weight (~3× Intlayer).
+- **Avoid**: **gt-next** and **lingo.dev** due to severe performance issues, vendor lock-in, and build-breaking bugs.
+
 ## Test your app
 
 To surface these issues, I built a free scanner you can try [here](https://intlayer.org/i18n-seo-scanner).
@@ -99,7 +106,7 @@ Finally, `Intlayer` applies a build-time optimization so `useIntlayer('my-key')`
 For this benchmark, we compared the following libraries:
 
 - `Base App` (No i18n library)
-- `next-intlayer` (v8.7.5)
+- `next-intlayer` (v8.7.12)
 - `next-i18next` (v16.0.5)
 - `next-intl` (v4.9.1)
 - `@lingui/core` (v5.3.0)
@@ -187,6 +194,8 @@ Personally I dislike having to regenerate JS files before every push, which crea
 Even if in theory the tree-shaking strategy works, it does include all locales in the bundle anyway. Paraglide offers no way to lazy-load the content. That means your page size grows in line with the number of locales you have.
 Finally, in comparison with other solutions, Paraglide does not use a store (e.g. React context) to retrieve the current locale to render the content. For each node parsed, it will request the locale from the localStorage / cookie etc. It leads to execution of unnecessary logic that impacts the component reactivity.
 
+> Note on paraglide: the solution inject code in your codebase to import, as a result the metric 'lib size' in the benchmark report is almost 0. Code gen is a good think, because the function used will include only the necessary logic (prefix all vs no prefix, cookie vs storage etc). In comparison Intlayer process to this filtering using env variables injections in the build to force the bundler to tree shake the content depending of the logic. Thanks to this, paraglide and intlayer end up being solution 6-10 times lighter than i18next or next-intl.
+
 ### 3 - Acceptable solutions
 
 **(Tolgee)** (`@tolgee/react@7.0.0`):
@@ -217,7 +226,7 @@ Message formats also differ: `next-intl` uses ICU MessageFormat, while `i18next`
 
 `next-translate` is my main recommendation if you like a `t()`-style API. It is elegant via `next-translate-plugin`, loading namespaces through `getStaticProps` with a Webpack / Turbopack loader. It is also the lightest option here (~2.5kb). For namespacing, defining namespaces per page or route in config is well thought out and easier to maintain than main alternatives like **next-intl** or **next-i18next**. In version `3.1.2`, I noted that static rendering did not work; Next.js fell back to dynamic rendering.
 
-**(Intlayer)** (`next-intlayer@8.7.5`):
+**(Intlayer)** (`next-intlayer@8.7.12`):
 
 I will not personally judge `next-intlayer` for objectivity’s sake, since it is my own solution.
 

package/docs/en/benchmark/solid.md

@@ -57,6 +57,13 @@ In practice, for the least optimized implementations, an internationalized page
 
 The other impact is on developer experience: how you declare content, types, namespace organization, dynamic loading, and reactivity when the locale changes.
 
+## TL;DR
+
+- **Intlayer**: Recommended choice for professional Solid applications needing advanced features and optimization (v8.7.12).
+- **@solid-primitives/i18n**: Excellent lightweight alternative for simple projects, though lacks advanced features like lazy loading.
+- **solid-i18next**: Standard but heavy option (~4.7× Intlayer) with same downsides as React i18next.
+- **Paraglide**: Innovative approach but complex DX and tree-shaking issues in some setups.
+
 ## Test your app
 
 To quickly spot i18n leakage issues, I set up a free scanner available [here](https://intlayer.org/i18n-seo-scanner).
@@ -88,8 +95,9 @@ For this benchmark, we compared the following libraries:
 
 - `Base App` (No i18n library)
 - `solid-intlayer` (v8.7.12)
-- `@solid-primitives/i18n` (v12.1.1)
+- `@solid-primitives/i18n` (v2.2.1)
 - `solid-i18next` (v17.0.2)
+- `@inlang/paraglide-js` (v2.17.0)
 
 The framework is `Solid` with a multilingual app of **10 pages** and **10 languages**.
 
@@ -133,19 +141,29 @@ I ran the same multilingual app in a real browser for every stack, then wrote do
 
 ### 1 - Solutions to avoid
 
+> No clear solution to avoid in solid ecosystem.
+
+### 2 - Acceptable solutions
+
 **(solid-i18next)** (`solid-i18next@17.0.2`):
 
 `solid-i18next` is probably the most popular option because it was among the first to serve JavaScript app i18n needs. It also has a wide set of community plugins for specific problems.
 
-Still, it shares the same major downsides as stacks built on `t('a.b.c')`: optimizations are possible but very time-consuming, and large projects risk bad practices (namespaces + dynamic loading + types).
+The package is heavy (~14.6kb, which is about 4.7× `solid-intlayer`).
 
-### 2 - Experimental solutions
+Still, it shares the same major downsides as stacks built on `t('a.b.c')`: optimizations are possible but very time-consuming, and large projects risk bad practices (namespaces + dynamic loading + types).
 
-**(@solid-primitives/i18n)** (`@solid-primitives/i18n@12.1.1`):
+**(@solid-primitives/i18n)** (`@solid-primitives/i18n@2.2.1`):
 
 Solid primitive is extremely light and efficient, I recommend that solution for light projects, but it can quickly become lacking features for professional solutions including cookie management, proxy redirection, formatters etc.
 It also misses lazy loading and scoping namespaces for page size optimization.
 
+**(Paraglide)** (`@inlang/paraglide-js@2.17.0`):
+
+`Paraglide` offers an innovative, well-thought-out approach. Even so, in this benchmark the tree-shaking their company advertises did not work for my implementation. The workflow and DX are also more complex than other options.
+Personally I dislike having to regenerate JS files before every push, which creates constant merge conflict risk via PRs.
+Finally, in comparison with other solutions, Paraglide does not use a store (e.g. Solid signal) to retrieve the current locale to render the content. For each node parsed, it will request the locale from the localStorage / cookie etc. It leads to execution of unnecessary logic that impacts the component reactivity.
+
 ### 3 - Recommendations
 
 **(Intlayer)** (`solid-intlayer@8.7.12`):

package/docs/en/benchmark/svelte.md

@@ -57,6 +57,12 @@ In practice, for the least optimized implementations, an internationalized page
 
 The other impact is on developer experience: how you declare content, types, namespace organization, dynamic loading, and reactivity when the locale changes.
 
+## TL;DR
+
+- **Intlayer**: The most performance-efficient choice (v8.7.12) with the smallest footprint.
+- **Paraglide**: Strong contender for tree-shaking but has a more complex developer experience and reactivity overhead.
+- **svelte-i18n**: Feature-complete and standard for Svelte, but carries a much larger bundle weight (~7× Intlayer).
+
 ## Test your app
 
 To quickly spot i18n leakage issues, I set up a free scanner available [here](https://intlayer.org/i18n-seo-scanner).
@@ -88,8 +94,8 @@ For this benchmark, we compared the following libraries:
 
 - `Base App` (No i18n library)
 - `svelte-intlayer` (v8.7.12)
-- `svelte-i18n` (v3.4.0)
-- `@inlang/paraglide-js` (v2.15.1)
+- `svelte-i18n` (v4.0.1)
+- `@inlang/paraglide-js` (v2.17.0)
 
 The framework is `Svelte` with a multilingual app of **10 pages** and **10 languages**.
 
@@ -133,7 +139,11 @@ I ran the same multilingual app in a real browser for every stack, then wrote do
 
 ### 1 - Solutions to avoid
 
-**(Paraglide)** (`@inlang/paraglide-js@2.15.1`):
+> No clear solution to avoid in svelte ecosystem.
+
+### 2 - Acceptable solutions
+
+**(Paraglide)** (`@inlang/paraglide-js@2.17.0`):
 
 `Paraglide` offers an innovative, well-thought-out approach. In the context of a Vite + Svelte app, the tree-shaking their company advertises works as expected, which is great.
 But in the case of a React + TanStack Start, the tree-shaking did not work as expected, same for Next.js. That said, I would be double-checking the usage of Paraglide in a Svelte and TanStack Start project.
@@ -141,11 +151,13 @@ The workflow and DX are also more complex than other options.
 Personally I dislike having to regenerate JS files before every push, which creates constant merge conflict risk via PRs. The tool also seems more focused on Vite than on Next.js.
 Finally, in comparison with other solutions, Paraglide does not use a store (e.g. Svelte store) to retrieve the current locale to render the content. For each node parsed, it will request the locale from the localStorage / cookie etc. It leads to execution of unnecessary logic that impacts the component reactivity.
 
+> Note on paraglide: the solution inject code in your codebase to import, as a result the metric 'lib size' in the benchmark report is almost 0. Code gen is a good think, because the function used will include only the necessary logic (prefix all vs no prefix, cookie vs storage etc). In comparison Intlayer process to this filtering using env variables injection during the build to force the bundler to tree shake the content depending of the logic. Thanks to this, paraglide and intlayer end up being solution 6-10 times lighter than i18next or next-intl.
+
 **(svelte-i18n)** (`svelte-i18n@3.4.0`):
 
-This solution answers all needs for i18n in a Svelte project. But as it's the case for i18next or other main i18n solutions it's a bit heavy (15kb gzip in comparison with 2.3kb for intlayer once the app bundled).
+This solution answers all needs for i18n in a Svelte project. But as it's the case for i18next or other main i18n solutions it's a bit heavy (~15.9kb, which is about 7× `svelte-intlayer`).
 
-### 2 - Recommendations
+### 3 - Recommendations
 
 **(Intlayer)** (`svelte-intlayer@8.7.12`):
 

package/docs/en/benchmark/tanstack.md

@@ -57,6 +57,13 @@ In practice, for the least optimized implementations, an internationalized page
 
 The other impact is on developer experience: how you declare content, types, namespace organization, dynamic loading, and reactivity when the locale changes.
 
+## TL;DR
+
+- **Intlayer**: Provides the best performance and smallest bundle size (v8.7.12) for TanStack Start.
+- **react-i18next** & **use-intl**: Mature alternatives with large ecosystems, but significantly heavier and more complex to optimize.
+- **Paraglide**: Innovative tree-shaking idea that does not work in practice. Complex DX and reactivity overhead in TanStack Start.
+- **Avoid**: **General Translation (GT)** and **Lingo.dev** due to severe performance issues, AI quota limits, and vendor lock-in.
+
 ## Test your app
 
 To quickly spot i18n leakage issues, I set up a free scanner available [here](https://intlayer.org/i18n-seo-scanner).
@@ -87,7 +94,7 @@ Syntaxes built around `const t = useTranslation()` + `t('a.b.c')` are very conve
 For this benchmark, we compared the following libraries:
 
 - `Base App` (No i18n library)
-- `react-intlayer` (v8.7.5-canary.0)
+- `react-intlayer` (v8.7.12)
 - `react-i18next` (v17.0.2)
 - `use-intl` (v4.9.1)
 - `@lingui/core` (v5.3.0)
@@ -146,7 +153,7 @@ Issues encountered:
 
 **(General Translation)** (`gt-react@latest`):
 
-- For an app around 110kb, `gt-react` can add more than 440kb extra (order of magnitude seen on the Next.js implementation in the same benchmark).
+- For an app around 110kb, `gt-react` can add more than 440kb extra (~439.8kb, which is about 93× `react-intlayer`). There is a serious quality issue from the developer experience side.
 - `Quota Exceeded, please upgrade your plan` on the very first build with General Translation.
 - Translations are not rendered; I get the error `Error: <T> used on the client-side outside of <GTProvider>`, which seems to be a bug in the library.
 - While implementing **gt-tanstack-start-react**, I also came across an [issue](https://github.com/generaltranslation/gt/issues/1210#event-24510646961) with the library: `does not provide an export named 'printAST' - @formatjs/icu-messageformat-parser`, which was making the application break. After reporting this issue, the maintainer fixed it within 24 hours.
@@ -174,15 +181,19 @@ The idea behind `Wuchale` is interesting but not yet a viable solution. I hit re
 Personally I dislike having to regenerate JS files before every push, which creates constant merge conflict risk via PRs. The tool also seems more focused on Vite than on Next.js.
 Finally, in comparison with other solutions, Paraglide does not use a store (e.g. React context) to retrieve the current locale to render the content. For each node parsed, it will request the locale from the localStorage / cookie etc. It leads to execution of unnecessary logic that impacts the component reactivity.
 
+> Note on paraglide: the solution inject code in your codebase to import, as a result the metric 'lib size' in the benchmark report is almost 0. Code gen is a good think, because the function used will include only the necessary logic (prefix all vs no prefix, cookie vs storage etc). In comparison Intlayer process to this filtering using env variables injections in the build to force the bundler to tree shake the content depending of the logic. Thanks to this, paraglide and intlayer end up being solution 6-10 times lighter than i18next or next-intl.
+
 **(Tolgee)** (`@tolgee/react@7.0.0`):
 
 `Tolgee` addresses many of the issues mentioned earlier. I found it harder to get started with than other tools with similar approaches. It does not provide type safety, which also makes catching missing keys at compile time much harder. I had to wrap Tolgee’s APIs with my own to add missing-key detection.
 
+The package is fairly heavy (~11.1kb, which is more than 2× `react-intlayer`).
+
 On TanStack Start I also had reactivity problems: on locale change I had to force the provider to rerender and subscribe to locale-change events so loading in another language behaved correctly.
 
 **(use-intl)** (`use-intl@4.9.1`):
 
-`use-intl` is the most fashionable “intl” piece in the React ecosystem (same family as `next-intl`) and is often pushed by AI agents, but in my view wrongly so in a performance-first setting. Getting started is fairly simple. In practice, the process to optimize and limit leakage is quite complex. Likewise, combining dynamic loading + namespacing + TypeScript types slows development a lot.
+`use-intl` is the most fashionable “intl” piece in the React ecosystem (same family as `next-intl`) and is often pushed by AI agents, but in my view wrongly so in a performance-first setting. Getting started is fairly simple. In practice, the process to optimize and limit leakage is quite complex. Likewise, combining dynamic loading + namespacing + TypeScript types slows development a lot. The package is also fairly heavy (~12.8kb, which is more than 2.5× `react-intlayer`).
 
 On TanStack Start you avoid Next.js-specific traps (`setRequestLocale`, static rendering), but the core issue is the same: without strict discipline, the bundle quickly carries too many messages and per-route namespace maintenance becomes painful.
 
@@ -192,6 +203,8 @@ On TanStack Start you avoid Next.js-specific traps (`setRequestLocale`, static r
 
 Still, it shares the same major downsides as stacks built on `t('a.b.c')`: optimizations are possible but very time-consuming, and large projects risk bad practices (namespaces + dynamic loading + types).
 
+The package is especially heavy (~17.3kb, which is about 3.5× `react-intlayer`).
+
 Message formats also diverge: `use-intl` uses ICU MessageFormat, while `i18next` uses its own format, which complicates tooling or migrations if you mix them.
 
 **(Lingui)** (`@lingui/core@5.3.0`):
@@ -202,6 +215,8 @@ Message formats also diverge: `use-intl` uses ICU MessageFormat, while `i18next`
 
 `react-intl` is a performant implementation from the Format.js team. The DX stays verbose: `const intl = useIntl()` + `intl.formatMessage({ id: "xx.xx" })` adds complexity, extra JavaScript work, and ties the global i18n instance to many nodes in the React tree.
 
+The package is also heavy (~14.4kb, which is about 3× `react-intlayer`).
+
 ### 4 - Recommendations
 
 This TanStack Start benchmark has no direct equivalent to `next-translate` (Next.js plugin + `getStaticProps`). For teams that really want a `t()` API with a mature ecosystem, `react-i18next` and `use-intl` remain “reasonable” choices, but expect to invest a lot of time optimizing to avoid leakage.

package/docs/en/benchmark/vue.md

@@ -57,6 +57,12 @@ In practice, for the least optimized implementations, an internationalized page
 
 The other impact is on developer experience: how you declare content, types, namespace organization, dynamic loading, and reactivity when the locale changes.
 
+## TL;DR
+
+- **Intlayer**: The most lightweight solution (v8.7.12) with built-in scoping and dynamic loading.
+- **vue-i18n**: The industry standard with a rich ecosystem but can be significantly heavier and harder to optimize for code-splitting in large applications.
+- **fluent-vue**: Innovative message organization but lacks type safety and is extremely heavy.
+
 ## Test your app
 
 To quickly spot i18n leakage issues, I set up a free scanner available [here](https://intlayer.org/i18n-seo-scanner).
@@ -88,8 +94,8 @@ For this benchmark, we compared the following libraries:
 
 - `Base App` (No i18n library)
 - `vue-intlayer` (v8.7.12)
-- `vue-i18n` (v11.1.1)
-- `fluent-vue` (v0.5.0)
+- `vue-i18n` (v11.4.0)
+- `fluent-vue` (v3.8.2)
 
 The framework is `Vue` with a multilingual app of **10 pages** and **10 languages**.
 
@@ -133,22 +139,22 @@ I ran the same multilingual app in a real browser for every stack, then wrote do
 
 ### 1 - Solutions to avoid
 
-**(vue-i18n)** (`vue-i18n@11.1.1`):
+> No clear solution to avoid in vue ecosystem.
+
+### 2 - Acceptable solutions
+
+**(vue-i18n)** (`vue-i18n@11.4.0`):
 
 - **vue-i18n** is without contestation the most used i18n library for vue, it has a lot of features and a huge ecosystem. but under the hood the solution is quite heavy. even if vue-i18n integrate lazy loading for messages, it miss a scoping feature. In the case of a classic Vue SPA app there is no issue, but for a nuxt app, using @nuxt/i18n, it leads to including the messages from all pages into a single one. For a big nuxt app including more than 10 pages, it can become really problematic.
 
+The package is very heavy (~24.3kb, which is about 9× `vue-intlayer`).
+
 **(fluent-vue)** (`fluent-vue@0.5.0`):
 
-- **fluent-vue** offer one inovation attempt thought the .ftl format. the message organization is great, easier to get started. but in practice, the lack of typesafty increase the risk of error and can quickly become time consuming to debug. Moreever, that solution load the messages using a vite plugin that force the loading of all the content in all languages into each page. Additionally this is an extreamly heavy solution (92kb gziped in comparison of 24kb gzipped for vue-i18n and 2.7kb gzipped for intlayer once the app bundled on a vue app)
+- **fluent-vue** offer one inovation attempt thought the .ftl format. the message organization is great, easier to get started. but in practice, the lack of typesafty increase the risk of error and can quickly become time consuming to debug. Moreever, that solution load the messages using a vite plugin that force the loading of all the content in all languages into each page. Additionally this is an extremely heavy solution (~92.7kb, which is about 34× `vue-intlayer`).
 
-### 2 - Recommendations
+### 3 - Recommendations
 
 **(Intlayer)** (`vue-intlayer@8.7.12`):
 
 I will not personally judge `vue-intlayer` for objectivity’s sake, since it is my own solution.
-
-### Personal note
-
-This note is personal and does not affect the benchmark results. Still, in the i18n world you often see consensus around a pattern like `const { t } = useI18n()` + `<>{t('xx.xx')}</>` for translated content.
-
-In Vue apps, injecting a function as a `VNode` is, in my view, an anti-pattern. It also adds avoidable complexity and JavaScript execution overhead (even if it is barely noticeable).

package/docs/en/configuration.md

@@ -1,6 +1,6 @@
 ---
 createdAt: 2024-08-13
-updatedAt: 2026-04-08
+updatedAt: 2026-05-12
 title: Configuration
 description: Learn how to configure Intlayer for your application. Understand the various settings and options available to customize Intlayer to your needs.
 keywords:
@@ -14,6 +14,9 @@ slugs:
   - concept
   - configuration
 history:
+  - version: 8.9.4
+    date: 2026-05-12
+    changes: "Add support for LM Studio provider"
   - version: 8.7.0
     date: 2026-04-08
     changes: "Add `prune` and `minify` options to the build configuration"
@@ -350,7 +353,7 @@ const config: IntlayerConfig = {
   ai: {
     /**
      * AI provider to use.
-     * Options: 'openai', 'anthropic', 'mistral', 'deepseek', 'gemini', 'ollama', 'openrouter', 'alibaba', 'fireworks', 'groq', 'huggingface', 'bedrock', 'googlevertex', 'togetherai'
+     * Options: 'openai', 'anthropic', 'mistral', 'deepseek', 'gemini', 'ollama', 'openrouter', 'alibaba', 'fireworks', 'groq', 'huggingface', 'bedrock', 'googlevertex', 'togetherai', 'lmstudio'
      * Default: 'openai'
      */
     provider: "openai",
@@ -937,17 +940,17 @@ Intlayer supports multiple AI providers for enhanced flexibility and choice. Cur
 - **Groq**
 - **Amazon Bedrock**
 - **Together.ai**
-- **ollama**
-
-| Field                | Description                                                                                                                         | Type                                                                                                                                                                                                                                                                                                                                                                                           | Default     | Example                                                       | Note                                                                                                                                                                                                    |
-| -------------------- | ----------------------------------------------------------------------------------------------------------------------------------- | ---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- | ----------- | ------------------------------------------------------------- | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
-| `provider`           | The provider to use for the AI features of Intlayer.                                                                                | `'openai'` &#124; <br/> `'anthropic'` &#124; <br/> `'mistral'` &#124; <br/> `'deepseek'` &#124; <br/> `'gemini'` &#124; <br/> `'ollama'` &#124; <br/> `'openrouter'` &#124; <br/> `'alibaba'` &#124; <br/> `'fireworks'` &#124; <br/> `'groq'` &#124; <br/> `'huggingface'` &#124; <br/> `'bedrock'` &#124; <br/> `'googleaistudio'` &#124; <br/> `'googlevertex'` &#124; <br/> `'togetherai'` | `undefined` | `'anthropic'`                                                 | Different providers require different API keys and have different pricing.                                                                                                                              |
-| `model`              | The model to use for AI features.                                                                                                   | `string`                                                                                                                                                                                                                                                                                                                                                                                       | None        | `'gpt-4o-2024-11-20'`                                         | Specific model varies by provider.                                                                                                                                                                      |
-| `temperature`        | Controls the randomness of AI responses.                                                                                            | `number`                                                                                                                                                                                                                                                                                                                                                                                       | None        | `0.1`                                                         | Higher temperature = more creative and less predictable.                                                                                                                                                |
-| `apiKey`             | Your API key for the selected provider.                                                                                             | `string`                                                                                                                                                                                                                                                                                                                                                                                       | None        | `process.env.OPENAI_API_KEY`                                  | Keep secret; store in environment variables.                                                                                                                                                            |
-| `applicationContext` | Additional context about your application to help the AI generate more accurate translations (domain, audience, tone, terminology). | `string`                                                                                                                                                                                                                                                                                                                                                                                       | None        | `'My application context'`                                    | Can be used to add rules (e.g. `"You should not transform urls"`).                                                                                                                                      |
-| `baseURL`            | The base URL for the AI API.                                                                                                        | `string`                                                                                                                                                                                                                                                                                                                                                                                       | None        | `'https://api.openai.com/v1'` <br/> `'http://localhost:5000'` | Can point to a local or custom AI API endpoint.                                                                                                                                                         |
-| `dataSerialization`  | Data serialization format for AI features.                                                                                          | `'json'` &#124; <br/> `'toon'`                                                                                                                                                                                                                                                                                                                                                                 | `undefined` | `'toon'`                                                      | • `'json'`: standard, reliable; uses more tokens.<br/>• `'toon'`: fewer tokens, less consistent.<br/>• Additional parameters are passed to the AI model as context (reasoning effort, verbosity, etc.). |
+- **LM Studio**
+
+| Field                | Description                                                                                                                         | Type                                                                                                                                                                                                                                                                                                                                                                                                                     | Default     | Example                                                       | Note                                                                                                                                                                                                    |
+| -------------------- | ----------------------------------------------------------------------------------------------------------------------------------- | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------ | ----------- | ------------------------------------------------------------- | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
+| `provider`           | The provider to use for the AI features of Intlayer.                                                                                | `'openai'` &#124; <br/> `'anthropic'` &#124; <br/> `'mistral'` &#124; <br/> `'deepseek'` &#124; <br/> `'gemini'` &#124; <br/> `'ollama'` &#124; <br/> `'openrouter'` &#124; <br/> `'alibaba'` &#124; <br/> `'fireworks'` &#124; <br/> `'groq'` &#124; <br/> `'huggingface'` &#124; <br/> `'bedrock'` &#124; <br/> `'googleaistudio'` &#124; <br/> `'googlevertex'` &#124; <br/> `'togetherai'` &#124; <br/> `'lmstudio'` | `undefined` | `'anthropic'`                                                 | Different providers require different API keys and have different pricing.                                                                                                                              |
+| `model`              | The model to use for AI features.                                                                                                   | `string`                                                                                                                                                                                                                                                                                                                                                                                                                 | None        | `'gpt-4o-2024-11-20'`                                         | Specific model varies by provider.                                                                                                                                                                      |
+| `temperature`        | Controls the randomness of AI responses.                                                                                            | `number`                                                                                                                                                                                                                                                                                                                                                                                                                 | None        | `0.1`                                                         | Higher temperature = more creative and less predictable.                                                                                                                                                |
+| `apiKey`             | Your API key for the selected provider.                                                                                             | `string`                                                                                                                                                                                                                                                                                                                                                                                                                 | None        | `process.env.OPENAI_API_KEY`                                  | Keep secret; store in environment variables.                                                                                                                                                            |
+| `applicationContext` | Additional context about your application to help the AI generate more accurate translations (domain, audience, tone, terminology). | `string`                                                                                                                                                                                                                                                                                                                                                                                                                 | None        | `'My application context'`                                    | Can be used to add rules (e.g. `"You should not transform urls"`).                                                                                                                                      |
+| `baseURL`            | The base URL for the AI API.                                                                                                        | `string`                                                                                                                                                                                                                                                                                                                                                                                                                 | None        | `'https://api.openai.com/v1'` <br/> `'http://localhost:5000'` | Can point to a local or custom AI API endpoint.                                                                                                                                                         |
+| `dataSerialization`  | Data serialization format for AI features.                                                                                          | `'json'` &#124; <br/> `'toon'`                                                                                                                                                                                                                                                                                                                                                                                           | `undefined` | `'toon'`                                                      | • `'json'`: standard, reliable; uses more tokens.<br/>• `'toon'`: fewer tokens, less consistent.<br/>• Additional parameters are passed to the AI model as context (reasoning effort, verbosity, etc.). |
 
 ### Build Configuration