@intlayer/docs 8.9.4 → 8.9.6-canary.0

package/docs/es/benchmark/solid.md

@@ -0,0 +1,155 @@
+---
+createdAt: 2026-04-20
+updatedAt: 2026-04-21
+title: La mejor solución i18n para Solid en 2026 - Informe de Benchmark
+description: Compara bibliotecas de internacionalización (i18n) para Solid como solid-primitives, solid-i18next e Intlayer. Informe de rendimiento detallado sobre el tamaño del paquete, fugas y reactividad.
+keywords:
+  - benchmark
+  - i18n
+  - intl
+  - solid
+  - rendimiento
+  - intlayer
+slugs:
+  - doc
+  - benchmark
+  - solid
+author: Aymeric PINEAU
+applicationTemplate: https://github.com/intlayer-org/benchmark-i18n-solid-template
+history:
+  - version: 8.7.12
+    date: 2026-01-06
+    changes: "Inicialización del benchmark"
+---
+
+# Bibliotecas i18n para Solid — Informe de Benchmark 2026
+
+Esta página es un informe de benchmark para soluciones de i18n en Solid.
+
+## Tabla de Contenidos
+
+<Toc/>
+
+## Benchmark Interactivo
+
+<I18nBenchmark framework="vite-solid" vertical/>
+
+## Referencia de resultados:
+
+<iframe 
+  src="https://intlayer.org/markdown?url=https%3A%2F%2Fraw.githubusercontent.com%2Fintlayer-org%2Fbenchmark-i18n%2Fmain%2Freport%2Fscripts%2Fsummarize-vite_solid.md" 
+  width="100%" 
+  height="600px"
+  style="border:none;">
+</iframe>
+
+> https://intlayer.org/markdown?url=https%3A%2F%2Fraw.githubusercontent.com%2Fintlayer-org%2Fbenchmark-i18n%2Fmain%2Freport%2Fscripts%2Fsummarize-vite_solid.md
+
+Vea el repositorio completo del benchmark [aquí](https://github.com/intlayer-org/benchmark-i18n/tree/main).
+
+## Introducción
+
+Las soluciones de internacionalización se encuentran entre las dependencias más pesadas en una aplicación Solid. El riesgo principal es enviar contenido innecesario: traducciones para otras páginas y otros idiomas en el paquete de una sola ruta.
+
+A medida que su aplicación crece, ese problema puede aumentar rápidamente el JavaScript enviado al cliente y ralentizar la navegación.
+
+En la práctica, para las implementaciones menos optimizadas, una página internacionalizada puede terminar siendo varias veces más pesada que la versión sin i18n.
+
+El otro impacto es en la experiencia del desarrollador (DX): cómo se declara el contenido, los tipos, la organización de los namespaces, la carga dinámica y la reactividad cuando cambia el idioma.
+
+## TL;DR
+
+- **Intlayer**: Opción recomendada para aplicaciones Solid profesionales que necesitan características avanzadas y optimización (v8.7.12).
+- **@solid-primitives/i18n**: Excelente alternativa ligera para proyectos simples, aunque carece de características avanzadas como la carga diferida (lazy loading).
+- **solid-i18next**: Opción estándar pero pesada (~4.7× Intlayer) con los mismos inconvenientes que React i18next.
+- **Paraglide**: Enfoque innovador pero DX compleja y problemas de tree-shaking en algunas configuraciones.
+
+## Pruebe su aplicación
+
+Para detectar rápidamente problemas de fugas de i18n, he configurado un escáner gratuito disponible [aquí](https://intlayer.org/i18n-seo-scanner).
+
+<iframe src="https://intlayer.org/i18n-seo-scanner" width="100%" height="600px" style="border:none;"/>
+
+## El problema
+
+Dos palancas son esenciales para limitar el costo de una aplicación multilingüe:
+
+- Dividir el contenido por página / namespace para no cargar diccionarios completos cuando no se necesitan.
+- Cargar el idioma correcto dinámicamente, solo cuando sea necesario.
+
+Comprender las limitaciones técnicas de estos enfoques:
+
+**Carga dinámica**
+
+Sin carga dinámica, la mayoría de las soluciones mantienen los mensajes en memoria desde el primer renderizado, lo que añade una sobrecarga significativa para aplicaciones con muchas rutas e idiomas.
+
+Con la carga dinámica, se acepta un compromiso: menos JS inicial, pero a veces una solicitud adicional al cambiar de idioma.
+
+**División de contenido (Splitting)**
+
+Las sintaxis construidas en torno a `t('a.b.c')` son muy convenientes pero a menudo fomentan el mantenimiento de grandes objetos JSON en tiempo de ejecución. Ese modelo dificulta el tree-shaking a menos que la biblioteca ofrezca una estrategia real de división por página.
+
+## Metodología
+
+Para este benchmark, comparamos las siguientes bibliotecas:
+
+- `Base App` (Sin biblioteca i18n)
+- `solid-intlayer` (v8.7.12)
+- `@solid-primitives/i18n` (v2.2.1)
+- `solid-i18next` (v17.0.2)
+- `@inlang/paraglide-js` (v2.17.0)
+
+El framework es `Solid` con una aplicación multilingüe de **10 páginas** y **10 idiomas**.
+
+Comparamos **quatro estrategias de carga**:
+
+| Estrategia         | Sin namespaces (global)                     | Con namespaces (scoped)                                            |
+| :----------------- | :------------------------------------------ | :----------------------------------------------------------------- |
+| **Carga estática** | **Static**: Todo en memoria al inicio.      | **Scoped static**: Dividido por namespace; todo cargado al inicio. |
+| **Carga dinámica** | **Dynamic**: Carga bajo demanda por idioma. | **Scoped dynamic**: Carga granular por namespace e idioma.         |
+
+## Resumen de estrategias
+
+- **Static**: Simple; sin latencia de red después de la carga inicial. Desventaja: gran tamaño del paquete.
+- **Dynamic**: Reduce el peso inicial (lazy-loading). Ideal cuando se tienen muchos idiomas.
+- **Scoped static**: Mantiene el código organizado (separación lógica) sin solicitudes de red adicionales complejas.
+- **Scoped dynamic**: El mejor enfoque para el _code splitting_ y el rendimiento. Minimiza la memoria cargando solo lo que la vista actual y el idioma activo necesitan.
+
+## Resultados detallados
+
+### 1 — Soluciones a evitar
+
+> No hay una solución clara a evitar en el ecosistema de Solid.
+
+### 2 — Soluciones aceptables
+
+**(solid-i18next)** (`solid-i18next@17.0.2`):
+
+`solid-i18next` es probablemente la opción más popular porque fue una de las primeras en satisfacer las necesidades de i18n de las aplicaciones de JavaScript. También cuenta con un amplio conjunto de complementos de la comunidad para problemas específicos.
+
+El paquete es pesado (~14.6kb, aproximadamente 4.7 veces `solid-intlayer`).
+
+Aun así, comparte las mismas desventajas principales que las pilas construidas sobre `t('a.b.c')`: las optimizaciones son posibles pero requieren mucho tiempo, y los proyectos grandes corren el riesgo de malas prácticas (namespaces + carga dinámica + tipos).
+
+**(@solid-primitives/i18n)** (`@solid-primitives/i18n@2.2.1`):
+
+Solid primitive es extremadamente ligero y eficiente. Recomiendo esa solución para proyectos ligeros, pero puede carecer rápidamente de características para soluciones profesionales que incluyan gestión de cookies, redirección de proxy, formateadores, etc.
+También carece de carga diferida (lazy loading) y segmentación de namespaces para la optimización del tamaño de la página.
+
+**(Paraglide)** (`@inlang/paraglide-js@2.17.0`):
+
+`Paraglide` ofrece un enfoque innovador y bien pensado. Aun así, en este benchmark, el tree-shaking que su empresa publicita no funcionó para mi implementación. El flujo de trabajo y la DX también son más complejos que en otras opciones.
+Personalmente, no me gusta tener que regenerar archivos JS antes de cada push, lo que genera un riesgo constante de conflictos de fusión a través de los PR.
+Finalmente, en comparación con otras soluciones, Paraglide no utiliza un almacén (ej. Solid signal) para recuperar el idioma actual para renderizar el contenido. Para cada nodo analizado, solicitará el idioma al localStorage / cookie, etc. Esto conduce a la ejecución de lógica innecesaria que impacta la reactividad del componente.
+
+### 3 — Recomendaciones
+
+**(Intlayer)** (`solid-intlayer@8.7.12`):
+
+No juzgaré personalmente `solid-intlayer` por objetividad, ya que es mi propia solución.
+
+### Nota personal
+
+Esta nota es personal y no afecta los resultados del benchmark. Aun así, en el mundo del i18n a menudo se ve consenso en torno a un patrón como `const t = useTranslation('xx')` + `<>{t('xx.xx')}</>` para el contenido traducido.
+
+En las aplicaciones Solid, inyectar una función como un `JSX.Element` es, en mi opinión, un antipatrón. También añade complejidad evitable y sobrecarga de ejecución de JavaScript (aunque sea apenas perceptible).

package/docs/es/benchmark/svelte.md

@@ -0,0 +1,148 @@
+---
+createdAt: 2026-04-20
+updatedAt: 2026-04-21
+title: La mejor solución i18n para Svelte en 2026 - Informe de Benchmark
+description: Compara bibliotecas de internacionalización (i18n) para Svelte como svelte-i18n, Paraglide e Intlayer. Informe de rendimiento detallado sobre el tamaño del paquete, fugas y reactividad.
+keywords:
+  - benchmark
+  - i18n
+  - intl
+  - svelte
+  - rendimiento
+  - intlayer
+slugs:
+  - doc
+  - benchmark
+  - svelte
+author: Aymeric PINEAU
+applicationTemplate: https://github.com/intlayer-org/benchmark-i18n-svelte-template
+history:
+  - version: 8.7.12
+    date: 2026-01-06
+    changes: "Inicialización del benchmark"
+---
+
+# Bibliotecas i18n para Svelte — Informe de Benchmark 2026
+
+Esta página es un informe de benchmark para soluciones de i18n en Svelte.
+
+## Tabla de Contenidos
+
+<Toc/>
+
+## Benchmark Interactivo
+
+<I18nBenchmark framework="vite-svelte" vertical/>
+
+## Referencia de resultados:
+
+<iframe 
+  src="https://intlayer.org/markdown?url=https%3A%2F%2Fraw.githubusercontent.com%2Fintlayer-org%2Fbenchmark-i18n%2Fmain%2Freport%2Fscripts%2Fsummarize-vite_svelte.md" 
+  width="100%" 
+  height="600px"
+  style="border:none;">
+</iframe>
+
+> https://intlayer.org/markdown?url=https%3A%2F%2Fraw.githubusercontent.com%2Fintlayer-org%2Fbenchmark-i18n%2Fmain%2Freport%2Fscripts%2Fsummarize-vite_svelte.md
+
+Vea el repositorio completo del benchmark [aquí](https://github.com/intlayer-org/benchmark-i18n/tree/main).
+
+## Introducción
+
+Las soluciones de internacionalización se encuentran entre las dependencias más pesadas en una aplicación Svelte. El riesgo principal es enviar contenido innecesario: traducciones para otras páginas y otros idiomas en el paquete de una sola ruta.
+
+A medida que su aplicación crece, ese problema puede aumentar rápidamente el JavaScript enviado al cliente y ralentizar la navegación.
+
+En la práctica, para las implementaciones menos optimizadas, una página internacionalizada puede terminar siendo varias veces más pesada que la versión sin i18n.
+
+El otro impacto es en la experiencia del desarrollador (DX): cómo se declara el contenido, los tipos, la organización de los namespaces, la carga dinámica y la reactividad cuando cambia el idioma.
+
+## TL;DR
+
+- **Intlayer**: La opción más eficiente en cuanto a rendimiento (v8.7.12) con la menor huella.
+- **Paraglide**: Candidato fuerte para el tree-shaking pero tiene una experiencia de desarrollador más compleja y sobrecarga de reactividad.
+- **svelte-i18n**: Completo y estándar para Svelte, pero conlleva un peso de paquete mucho mayor (~7 veces Intlayer).
+
+## Pruebe su aplicación
+
+Para detectar rápidamente problemas de fugas de i18n, he configurado un escáner gratuito disponible [aquí](https://intlayer.org/i18n-seo-scanner).
+
+<iframe src="https://intlayer.org/i18n-seo-scanner" width="100%" height="600px" style="border:none;"/>
+
+## El problema
+
+Dos palancas son esenciales para limitar el costo de una aplicación multilingüe:
+
+- Dividir el contenido por página / namespace para no cargar diccionarios completos cuando no se necesitan.
+- Cargar el idioma correcto dinámicamente, solo cuando sea necesario.
+
+Comprender las limitaciones técnicas de estos enfoques:
+
+**Carga dinámica**
+
+Sin carga dinámica, la mayoría de las soluciones mantienen los mensajes en memoria desde el primer renderizado, lo que añade una sobrecarga significativa para aplicaciones con muchas rutas e idiomas.
+
+Con la carga dinámica, se acepta un compromiso: menos JS inicial, pero a veces una solicitud adicional al cambiar de idioma.
+
+**División de contenido (Splitting)**
+
+Las sintaxis construidas en torno a `t('a.b.c')` son muy convenientes pero a menudo fomentan el mantenimiento de grandes objetos JSON en tiempo de ejecución. Ese modelo dificulta el tree-shaking a menos que la biblioteca ofrezca una estrategia real de división por página.
+
+## Metodología
+
+Para este benchmark, comparamos las siguientes bibliotecas:
+
+- `Base App` (Sin biblioteca i18n)
+- `svelte-intlayer` (v8.7.12)
+- `svelte-i18n` (v4.0.1)
+- `@inlang/paraglide-js` (v2.17.0)
+
+El framework es `Svelte` con una aplicación multilingüe de **10 páginas** y **10 idiomas**.
+
+Comparamos **quatro estrategias de carga**:
+
+| Estrategia         | Sin namespaces (global)                     | Con namespaces (scoped)                                            |
+| :----------------- | :------------------------------------------ | :----------------------------------------------------------------- |
+| **Carga estática** | **Static**: Todo en memoria al inicio.      | **Scoped static**: Dividido por namespace; todo cargado al inicio. |
+| **Carga dinámica** | **Dynamic**: Carga bajo demanda por idioma. | **Scoped dynamic**: Carga granular por namespace e idioma.         |
+
+## Resumen de estrategias
+
+- **Static**: Simple; sin latencia de red después de la carga inicial. Desventaja: gran tamaño del paquete.
+- **Dynamic**: Reduce el peso inicial (lazy-loading). Ideal cuando se tienen muchos idiomas.
+- **Scoped static**: Mantiene el código organizado (separación lógica) sin solicitudes de red adicionales complejas.
+- **Scoped dynamic**: El mejor enfoque para el _code splitting_ y el rendimiento. Minimiza la memoria cargando solo lo que la vista actual y el idioma activo necesitan.
+
+## Resultados detallados
+
+### 1 — Soluciones a evitar
+
+> No hay una solución clara a evitar en el ecosistema de Svelte.
+
+### 2 — Soluciones aceptables
+
+**(Paraglide)** (`@inlang/paraglide-js@2.17.0`):
+
+`Paraglide` ofrece un enfoque innovador y bien pensado. En el contexto de una aplicación Vite + Svelte, el tree-shaking que su empresa publicita funcionó como se esperaba, lo cual es excelente.
+Pero en el caso de React + TanStack Start, el tree-shaking no funcionó como se esperaba, lo mismo para Next.js. Dicho esto, valdría la pena volver a verificar el uso de Paraglide en un proyecto Svelte y TanStack Start.
+El flujo de trabajo y la DX también son más complejos que en otras opciones.
+Personalmente, no me gusta tener que regenerar archivos JS antes de cada push, lo que genera un riesgo constante de conflictos de fusión a través de los PR. La herramienta también parece estar más centrada en Vite que en Next.js.
+Finalmente, en comparación con otras soluciones, Paraglide no utiliza un almacén (ej. Svelte store) para recuperar el idioma actual para renderizar el contenido. Para cada nodo analizado, solicitará el idioma al localStorage / cookie, etc. Esto conduce a la ejecución de lógica innecesaria que impacta la reactividad del componente.
+
+> Nota sobre paraglide: la solución inyecta código en su base de código para las importaciones; como resultado, la métrica 'lib size' en el informe de benchmark es casi 0. La generación de código es algo bueno, porque la función utilizada incluirá solo la lógica necesaria (prefijo en todas partes vs sin prefijo, cookie vs almacenamiento, etc.). En comparación, Intlayer realiza este filtrado mediante inyecciones de variables de entorno durante la compilación para obligar al bundler a realizar tree-shaking del contenido según la lógica. Gracias a esto, paraglide e intlayer terminan siendo soluciones de 6 a 10 veces más ligeras que i18next o next-intl.
+
+**(svelte-i18n)** (`svelte-i18n@3.4.0`):
+
+Esta solución satisface todas las necesidades de i18n en un proyecto Svelte. Pero como es el caso de i18next u otras soluciones importantes, es un poco pesada (~15.9kb, aproximadamente 7 veces `svelte-intlayer`).
+
+### 3 — Recomendaciones
+
+**(Intlayer)** (`svelte-intlayer@8.7.12`):
+
+No juzgaré personalmente `svelte-intlayer` por objetividad, ya que es mi propia solución.
+
+### Nota personal
+
+Esta nota es personal y no afecta los resultados del benchmark. Aun así, en el mundo del i18n a menudo se ve consenso en torno a un patrón como `const t = useTranslation('xx')` + `<>{t('xx.xx')}</>` para el contenido traducido.
+
+En las aplicaciones Svelte, inyectar una función como un `Slot` es, en mi opinión, un antipatrón. También añade complejidad evitable y sobrecarga de ejecución de JavaScript (aunque sea apenas perceptible).

package/docs/es/benchmark/tanstack.md

@@ -57,6 +57,13 @@ En la práctica, en las implementaciones menos optimizadas, una página internac
 
 El otro impacto es en la experiencia del desarrollador: cómo declaras el contenido, los tipos, la organización de los namespaces, la carga dinámica y la reactividad cuando cambia el idioma.
 
+## TL;DR
+
+- **Intlayer**: Proporciona el mejor rendimiento y el tamaño de bundle más pequeño (v8.7.12) para TanStack Start.
+- **react-i18next** & **use-intl**: Alternativas maduras con grandes ecosistemas, mas significativamente más pesadas y complejas de optimizar.
+- **Paraglide**: Idea innovadora de tree-shaking que no funciona en la práctica. DX compleja y sobrecarga de reactividad en TanStack Start.
+- **Evitar**: **General Translation (GT)** y **Lingo.dev** debido a graves problemas de rendimiento, límites de cuota de IA y bloqueo del proveedor (vendor lock-in).
+
 ## Pon a prueba tu aplicación
 
 Para detectar rápidamente problemas de fuga de i18n, he configurado un escáner gratuito disponible [aquí](https://intlayer.org/i18n-seo-scanner).
@@ -87,12 +94,12 @@ Las sintaxis basadas en `const t = useTranslation()` + `t('a.b.c')` son muy cóm
 Para este benchmark, comparamos las siguientes librerías:
 
 - `Base App` (Sin librería i18n)
-- `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)
 - `@inlang/paraglide-js` (v2.15.1)
-- `tolgee` (v7.0.0)
+- `@tolgee/react` (v7.0.0)
 - `react-intl` (v10.1.1)
 - `wuchale` (v0.22.11)
 - `gt-react` (vlatest)
@@ -150,7 +157,9 @@ La idea detrás de `Wuchale` es interesante pero todavía no es una solución vi
 
 `Paraglide` ofrece un enfoque innovador y bien pensado. Aun así, en este benchmark, el tree-shaking que su empresa publicita no funcionó para mi implementación en Next.js ni para TanStack Start. El flujo de trabajo y la DX también son más complejos que otras opciones. Personalmente, no soy fan de tener que regenerar archivos JS antes de cada push, lo que crea un riesgo constante de conflictos de fusión para los desarrolladores a través de las PR.
 
-**(Tolgee)** (`tolgee@7.0.0`):
+> Nota sobre paraglide: la solución inyecta código en tu base de código para las importaciones, como resultado, la métrica 'lib size' en el informe del benchmark es casi 0. La generación de código es algo bueno, porque la función utilizada incluirá solo la lógica necesaria (prefijo para todo vs sin prefijo, cookie vs almacenamiento, etc.). En comparación, Intlayer realiza este filtrado mediante inyecciones de variables de entorno en la compilación para forzar al bundler a realizar tree-shake del contenido dependiendo de la lógica. Gracias a esto, paraglide e intlayer terminan siendo soluciones entre 6 y 10 veces más ligeras que i18next o next-intl.
+
+**(Tolgee)** (`@tolgee/react@7.0.0`):
 
 `Tolgee` aborda muchos de los problemas mencionados anteriormente. Me resultó más difícil empezar con ella que con otras herramientas con enfoques similares. No proporciona seguridad de tipos, lo que también dificulta mucho detectar claves faltantes en tiempo de compilación. Tuve que envolver las API de Tolgee con las mías propias para añadir la detección de claves faltantes.
 

package/docs/es/benchmark/vue.md

@@ -0,0 +1,160 @@
+---
+createdAt: 2026-04-20
+updatedAt: 2026-04-21
+title: La mejor solución i18n para Vue en 2026 - Informe de Benchmark
+description: Compara bibliotecas de internacionalización (i18n) para Vue como vue-i18n, fluent-vue e Intlayer. Informe de rendimiento detallado sobre el tamaño del paquete, fugas y reactividad.
+keywords:
+  - benchmark
+  - i18n
+  - intl
+  - vue
+  - rendimiento
+  - intlayer
+slugs:
+  - doc
+  - benchmark
+  - vue
+author: Aymeric PINEAU
+applicationTemplate: https://github.com/intlayer-org/benchmark-i18n-vue-template
+history:
+  - version: 8.7.12
+    date: 2026-01-06
+    changes: "Inicialización del benchmark"
+---
+
+# Bibliotecas i18n para Vue — Informe de Benchmark 2026
+
+Esta página es un informe de benchmark para soluciones de i18n en Vue.
+
+## Tabla de Contenidos
+
+<Toc/>
+
+## Benchmark Interactivo
+
+<I18nBenchmark framework="vite-vue" vertical/>
+
+## Referencia de resultados:
+
+<iframe 
+  src="https://intlayer.org/markdown?url=https%3A%2F%2Fraw.githubusercontent.com%2Fintlayer-org%2Fbenchmark-i18n%2Fmain%2Freport%2Fscripts%2Fsummarize-vite_vue.md" 
+  width="100%" 
+  height="600px"
+  style="border:none;">
+</iframe>
+
+> https://intlayer.org/markdown?url=https%3A%2F%2Fraw.githubusercontent.com%2Fintlayer-org%2Fbenchmark-i18n%2Fmain%2Freport%2Fscripts%2Fsummarize-vite_vue.md
+
+Vea el repositorio completo del benchmark [aquí](https://github.com/intlayer-org/benchmark-i18n/tree/main).
+
+## Introducción
+
+Las soluciones de internacionalización se encuentran entre las dependencias más pesadas en una aplicación Vue. El riesgo principal es enviar contenido innecesario: traducciones para otras páginas y otros idiomas en el paquete de una sola ruta.
+
+A medida que su aplicación crece, ese problema puede aumentar rápidamente el JavaScript enviado al cliente y ralentizar la navegación.
+
+En la práctica, para las implementaciones menos optimizadas, una página internacionalizada puede terminar siendo varias veces más pesada que la versión sin i18n.
+
+El otro impacto es en la experiencia del desarrollador (DX): cómo se declara el contenido, los tipos, la organización de los namespaces, la carga dinámica y la reactividad cuando cambia el idioma.
+
+## TL;DR
+
+- **Intlayer**: La solución más ligera (v8.7.12) con segmentación (scoping) y carga dinámica nativas.
+- **vue-i18n**: El estándar de la industria con un ecosistema rico, pero puede ser significativamente más pesado y difícil de optimizar para el code-splitting en aplicaciones grandes.
+- **fluent-vue**: Organización innovadora de mensajes pero carece de seguridad de tipos y resulta ser una solución extremadamente pesada.
+
+## Pruebe su aplicación
+
+Para detectar rápidamente problemas de fugas de i18n, he configurado un escáner gratuito disponible [aquí](https://intlayer.org/i18n-seo-scanner).
+
+<iframe src="https://intlayer.org/i18n-seo-scanner" width="100%" height="600px" style="border:none;"/>
+
+## El problema
+
+Dos palancas son esenciales para limitar el costo de una aplicación multilingüe:
+
+- Dividir el contenido por página / namespace para no cargar diccionarios completos cuando no se necesitan.
+- Cargar el idioma correcto dinámicamente, solo cuando sea necesario.
+
+Comprender las limitaciones técnicas de estos enfoques:
+
+**Carga dinámica**
+
+Sin carga dinámica, la mayoría de las soluciones mantienen los mensajes en memoria desde el primer renderizado, lo que añade una sobrecarga significativa para aplicaciones con muchas rutas e idiomas.
+
+Con la carga dinámica, se acepta un compromiso: menos JS inicial, pero a veces una solicitud adicional al cambiar de idioma.
+
+**División de contenido (Splitting)**
+
+Las sintaxis construidas en torno a `const { t } = useI18n()` + `t('a.b.c')` son muy convenientes pero a menudo fomentan el mantenimiento de grandes objetos JSON en tiempo de ejecución. Ese modelo dificulta el tree-shaking a menos que la biblioteca ofrezca una estrategia real de división por página.
+
+## Metodología
+
+Para este benchmark, comparamos las siguientes bibliotecas:
+
+- `Base App` (Sin biblioteca i18n)
+- `vue-intlayer` (v8.7.12)
+- `vue-i18n` (v11.4.0)
+- `fluent-vue` (v3.8.2)
+
+El framework es `Vue` con una aplicación multilingüe de **10 páginas** y **10 idiomas**.
+
+Comparamos **cuatro estrategias de carga**:
+
+| Estrategia         | Sin namespaces (global)                     | Con namespaces (scoped)                                            |
+| :----------------- | :------------------------------------------ | :----------------------------------------------------------------- |
+| **Carga estática** | **Static**: Todo en memoria al inicio.      | **Scoped static**: Dividido por namespace; todo cargado al inicio. |
+| **Carga dinámica** | **Dynamic**: Carga bajo demanda por idioma. | **Scoped dynamic**: Carga granular por namespace e idioma.         |
+
+## Resumen de estrategias
+
+- **Static**: Simple; sin latencia de red después de la carga inicial. Desventaja: gran tamaño del paquete.
+- **Dynamic**: Reduce el peso inicial (lazy-loading). Ideal cuando se tienen muchos idiomas.
+- **Scoped static**: Mantiene el código organizado (separación lógica) sin solicitudes de red adicionales complejas.
+- **Scoped dynamic**: El mejor enfoque para el _code splitting_ y el rendimiento. Minimiza la memoria cargando solo lo que la vista actual y el idioma activo necesitan.
+
+### Lo que medí:
+
+Ejecuté la misma aplicación multilingüe en un navegador real para cada stack y luego anoté lo que realmente pasó por la red y cuánto tiempo tomó. Los tamaños se informan **después de la compresión web normal**, ya que eso es más cercano a lo que la gente realmente descarga.
+
+- **Tamaño de la biblioteca de internacionalización**: Después de la agrupación, tree-shaking y minificación, el tamaño de la biblioteca i18n es el tamaño del código de los providers + composables en un componente vacío. No incluye la carga de archivos de traducción. Responde a cuán "cara" es la biblioteca antes de que entre el contenido.
+
+- **JavaScript por página**: Para cada ruta del benchmark, cuánto script extrae el navegador para esa visita, promediado entre las páginas de la suite (y entre idiomas). Las páginas pesadas son páginas lentas.
+
+- **Fuga de otros idiomas (Leakage)**: Es el contenido de la misma página pero en otro idioma que se cargaría por error en la página auditada. Este contenido es innecesario y debe evitarse (ej. contenido de la página `/fr/about` en el paquete de la página `/en/about`).
+
+- **Fuga de otras rutas**: La misma idea para **otras pantallas** de la aplicación: si sus textos se cargan cuando solo se abrió una página (ej. contenido de la página `/en/about` en el paquete de la página `/en/contact`). Una puntuación alta indica una división débil o paquetes demasiado amplios.
+
+- **Tamaño promedio del paquete del componente**: Los elementos de interfaz comunes se miden **uno a la vez**, en lugar de ocultarse dentro de una cifra gigante de la aplicación. Muestra si la internacionalización infla silenciosamente los componentes cotidianos. Por ejemplo, si su componente se vuelve a renderizar, cargará todos esos datos desde la memoria. Adjuntar un JSON gigante a cualquier componente es como conectar un gran almacén de datos no utilizados que ralentizará el rendimiento de sus componentes.
+
+- **Capacidad de respuesta al cambio de idioma**: Cambio el idioma utilizando el propio control de la aplicación y mido cuánto tiempo pasa hasta que la página ha cambiado claramente, lo que un visitante notaría.
+
+- **Trabajo de renderizado tras un cambio de idioma**: Un seguimiento más detallado: cuánto esfuerzo le costó a la interfaz volver a dibujarse para el nuevo idioma una vez iniciado el cambio. Útil cuando el tiempo "percibido" y el costo del framework divergen.
+
+- **Tiempo de carga inicial de la página**: Desde la navegación hasta que el navegador considera que la página está completamente cargada para los escenarios probados. Bueno para comparar arranques en frío.
+
+- **Tiempo de hidratación (Hydration)**: Tiempo que pasa el cliente convirtiendo el HTML del servidor en una interfaz interactiva. Un guion en las tablas significa que esa implementación no proporcionó una cifra de hidratación fiable en este benchmark.
+
+## Resultados en detalle
+
+### 1 — Soluciones a evitar
+
+> No hay una solución clara a evitar en el ecosistema de Vue.
+
+### 2 — Soluciones aceptables
+
+**(vue-i18n)** (`vue-i18n@11.4.0`):
+
+- **vue-i18n** es sin duda la biblioteca de i18n más utilizada para Vue, tiene muchas características y un ecosistema enorme. Pero bajo el capó la solución es bastante pesada. Aunque vue-i18n integra carga diferida para los mensajes, carece de una función de segmentación (scoping). En el caso de una aplicación Vue SPA clásica no hay problema, pero para una aplicación Nuxt que utiliza @nuxt/i18n, esto lleva a incluir los mensajes de todas las páginas en una sola. Para una aplicación Nuxt grande con más de 10 páginas, puede volverse realmente problemático.
+
+El paquete es muy pesado (~24.3kb, aproximadamente 9 veces `vue-intlayer`).
+
+**(fluent-vue)** (`fluent-vue@0.5.0`):
+
+- **fluent-vue** ofrece un intento de innovación a través del formato .ftl. La organización de los mensajes es excelente, más fácil de comenzar. Pero en la práctica, la falta de seguridad de tipos aumenta el riesgo de error y puede volverse rápidamente costoso de depurar. Además, esa solución carga los mensajes mediante un plugin de vite que obliga a cargar todo el contenido en todos los idiomas en cada página. Adicionalmente, es una solución extremadamente pesada (~92.7kb, aproximadamente 34 veces `vue-intlayer`).
+
+### 3 — Recomendaciones
+
+**(Intlayer)** (`vue-intlayer@8.7.12`):
+
+No juzgaré personalmente `vue-intlayer` por objetividad, ya que es mi propia solución.

package/docs/es/configuration.md

@@ -1,6 +1,6 @@
 ---
 createdAt: 2024-08-13
-updatedAt: 2026-04-08
+updatedAt: 2026-05-12
 title: Configuración (Configuration)
 description: Aprenda a configure Intlayer para su aplicación. Entienda los diversos ajustes y opciones disponibles para personalizar Intlayer según sus necesidades.
 keywords:
@@ -14,6 +14,9 @@ slugs:
   - concept
   - configuration
 history:
+  - version: 8.9.4
+    date: 2026-05-12
+    changes: "Añadir soporte para el proveedor LM Studio"
   - version: 8.7.0
     date: 2026-04-08
     changes: "Se añadieron las opciones `prune` y `minify` a la configuración de compilación"
@@ -350,7 +353,7 @@ const config: IntlayerConfig = {
   ai: {
     /**
      * Proveedor de IA que se utilizará.
-     * Opciones: 'openai', 'anthropic', 'mistral', 'deepseek', 'gemini', 'ollama', 'openrouter', 'alibaba', 'fireworks', 'groq', 'huggingface', 'bedrock', 'googlevertex', 'togetherai'
+     * Opciones: 'openai', 'anthropic', 'mistral', 'deepseek', 'gemini', 'ollama', 'openrouter', 'alibaba', 'fireworks', 'groq', 'huggingface', 'bedrock', 'googlevertex', 'togetherai', 'lmstudio'
      * Predeterminado: 'openai'
      */
     provider: "openai",
@@ -918,16 +921,17 @@ Intlayer admite múltiples proveedores de IA para una flexibilidad máxima. Los
 - **Groq**
 - **Amazon Bedrock**
 - **Together.ai**
-
-| Campo                | Descripción                                                                                                                              | Tipo                                                                                                                                                                                                                                                                                                                                                                                           | Predeterminado | Ejemplo                                                       | Nota                                                                                                                                                                                           |
-| -------------------- | ---------------------------------------------------------------------------------------------------------------------------------------- | ---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- | -------------- | ------------------------------------------------------------- | ---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
-| `provider`           | El proveedor que se usará para las funciones de IA de 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'`                                                 | Diferentes proveedores requieren diferentes llaves de API y tienen distintos precios.                                                                                                          |
-| `model`              | El modelo que se usará para las funciones de IA.                                                                                         | `string`                                                                                                                                                                                                                                                                                                                                                                                       | Ninguno        | `'gpt-4o-2024-11-20'`                                         | El modelo específico varía según el proveedor.                                                                                                                                                 |
-| `temperature`        | Controla la aleatoriedad de las respuestas de la IA.                                                                                     | `number`                                                                                                                                                                                                                                                                                                                                                                                       | Ninguno        | `0.1`                                                         | Temperatura más alta = más creativo y menos predecible.                                                                                                                                        |
-| `apiKey`             | Su llave API para el proveedor seleccionado.                                                                                             | `string`                                                                                                                                                                                                                                                                                                                                                                                       | Ninguno        | `process.env.OPENAI_API_KEY`                                  | Manténgalo en secreto; almacénelo en variables de entorno.                                                                                                                                     |
-| `applicationContext` | Contexto adicional sobre su aplicación para ayudar a la IA a generar traducciones más precisas (dominio, audiencia, tono, terminología). | `string`                                                                                                                                                                                                                                                                                                                                                                                       | Ninguno        | `'Mi contexto de aplicación'`                                 | Puede usarse para añadir reglas (p. ej.: `"No debes transformar las urls"`).                                                                                                                   |
-| `baseURL`            | La URL base para la API de IA.                                                                                                           | `string`                                                                                                                                                                                                                                                                                                                                                                                       | Ninguno        | `'https://api.openai.com/v1'` <br/> `'http://localhost:5000'` | Puede apuntar a un endpoint de API de IA local o personalizado.                                                                                                                                |
-| `dataSerialization`  | Formato de serialización de datos para las funciones de IA.                                                                              | `'json'` &#124; <br/> `'toon'`                                                                                                                                                                                                                                                                                                                                                                 | `undefined`    | `'toon'`                                                      | • `'json'`: estándar, fiable; usa más tokens.<br/>• `'toon'`: menos tokens, menos consistente.<br/>• Se pasan parámetros adicionales al modelo como contexto (esfuerzo de razonamiento, etc.). |
+- **LM Studio**
+
+| Campo                | Descripción                                                                                                                              | Tipo                                                                                                                                                                                                                                                                                                                                                                                                                     | Predeterminado | Ejemplo                                                       | Nota                                                                                                                                                                                           |
+| -------------------- | ---------------------------------------------------------------------------------------------------------------------------------------- | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------ | -------------- | ------------------------------------------------------------- | ---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
+| `provider`           | El proveedor que se usará para las funciones de IA de 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'`                                                 | Diferentes proveedores requieren diferentes llaves de API y tienen distintos precios.                                                                                                          |
+| `model`              | El modelo que se usará para las funciones de IA.                                                                                         | `string`                                                                                                                                                                                                                                                                                                                                                                                                                 | Ninguno        | `'gpt-4o-2024-11-20'`                                         | El modelo específico varía según el proveedor.                                                                                                                                                 |
+| `temperature`        | Controla la aleatoriedad de las respuestas de la IA.                                                                                     | `number`                                                                                                                                                                                                                                                                                                                                                                                                                 | Ninguno        | `0.1`                                                         | Temperatura más alta = más creativo y menos predecible.                                                                                                                                        |
+| `apiKey`             | Su llave API para el proveedor seleccionado.                                                                                             | `string`                                                                                                                                                                                                                                                                                                                                                                                                                 | Ninguno        | `process.env.OPENAI_API_KEY`                                  | Manténgalo en secreto; almacénelo en variables de entorno.                                                                                                                                     |
+| `applicationContext` | Contexto adicional sobre su aplicación para ayudar a la IA a generar traducciones más precisas (dominio, audiencia, tono, terminología). | `string`                                                                                                                                                                                                                                                                                                                                                                                                                 | Ninguno        | `'Mi contexto de aplicación'`                                 | Puede usarse para añadir reglas (p. ej.: `"No debes transformar las urls"`).                                                                                                                   |
+| `baseURL`            | La URL base para la API de IA.                                                                                                           | `string`                                                                                                                                                                                                                                                                                                                                                                                                                 | Ninguno        | `'https://api.openai.com/v1'` <br/> `'http://localhost:5000'` | Puede apuntar a un endpoint de API de IA local o personalizado.                                                                                                                                |
+| `dataSerialization`  | Formato de serialización de datos para las funciones de IA.                                                                              | `'json'` &#124; <br/> `'toon'`                                                                                                                                                                                                                                                                                                                                                                                           | `undefined`    | `'toon'`                                                      | • `'json'`: estándar, fiable; usa más tokens.<br/>• `'toon'`: menos tokens, menos consistente.<br/>• Se pasan parámetros adicionales al modelo como contexto (esfuerzo de razonamiento, etc.). |
 
 ---