# General Translation Knowledge Base: General Translation vs. Paraglide JS: ¿cuál deberías usar?
URL: https://generaltranslation.com/es/kb/general-translation-vs-paraglide.mdx
Docs index: https://generaltranslation.com/llms.txt
Description: Elige General Translation para mantener el texto inline y generar traducciones que respetan la estructura de tus componentes de React, con terminología compartida y revisión en el panel de control. Elige Paraglide JS si buscas funciones de mensaje compiladas y tipadas, con tree-shaking por mensaje. Paraglide renderiza tus catálogos; General Translation conecta el texto de origen con la generación de traducciones y sus actualizaciones continuas.
Category: Internacionalización
Last updated: 2026-10-16
Authors: Kevin Wu, Jackie Chen
Published: 2026-10-16
Paraglide JS es una biblioteca de i18n de inlang basada en un compilador. Guardas los mensajes en archivos JSON como `messages/en.json` y su compilador convierte cada mensaje en una función tipada que invocas como `m.greeting({ name })`, lo que permite a tu empaquetador descartar los mensajes que una página nunca usa. Lo que Paraglide deja en tus manos es la traducción en sí: cada mensaje en cada idioma lo aportas tú, un traductor o un comando de traducción automática que ejecutas sobre los archivos. Las bibliotecas de General Translation también renderizan traducciones, pero General Translation además las genera a partir del texto que escribes una sola vez, inline, en tus componentes.
## Lo que Paraglide JS hace bien
* **Seguridad de tipos.** Las claves y los parámetros de los mensajes se generan como tipos. En la versión 2.29.0, tanto un `m.greting()` mal escrito como una llamada a `m.greeting({})` sin su parámetro `name` producen errores de TypeScript.
* **Tamaño del paquete.** Los mensajes se compilan como módulos ES, de modo que los que no se usan se eliminan mediante tree-shaking. En el [benchmark publicado](https://paraglidejs.com/benchmark) por Paraglide, una página que usaba 100 de 200 mensajes en cinco configuraciones regionales transfirió 47 KB con Paraglide y 205 KB con i18next.
* **Plurales y variantes.** El formato de mensajes predeterminado [declara un selector de plural](https://paraglidejs.com/variants) y compara con categorías de CLDR como `one`, `few` y `many`. Los [plugins](https://paraglidejs.com/file-formats) añaden compatibilidad con ICU MessageFormat 1 y con archivos de i18next, y los formateadores abarcan números, fechas y tiempo relativo mediante `Intl`.
* **Estrategias de configuración regional.** Una [lista `strategy`](https://paraglidejs.com/strategy) ordenada resuelve la configuración regional a partir de la URL, una cookie, `localStorage`, el idioma preferido del navegador, una variable global, estrategias personalizadas o la `baseLocale`. En la versión 2.29.0, el [valor predeterminado](https://github.com/opral/paraglide-js/blob/main/src/compiler/compiler-options.ts) es `cookie`, `globalVariable` y, por último, `baseLocale`. El [middleware de servidor](https://paraglidejs.com/middleware) y `localizeUrl` se encargan de las rutas localizadas.
* **Compatibilidad con frameworks.** Paraglide [funciona con cualquier aplicación de Vite](https://paraglidejs.com/vite) y ofrece guías para React, Vue, Solid, SvelteKit, TanStack Start, React Router, Astro y Next.js. Es el [complemento que se instala con `npx sv add paraglide`](https://paraglidejs.com/sveltekit) en la CLI de Svelte. Su [guía de Next.js](https://paraglidejs.com/next-js) admite el App Router mediante un plugin de webpack, que se ejecuta con la opción `--webpack`.
* **Herramientas gratuitas y abiertas.** La biblioteca tiene [licencia MIT](https://github.com/opral/paraglide-js/blob/main/LICENSE). La [CLI de inlang](https://inlang.com/m/2qj2w8pu/app-inlang-cli) verifica los proyectos en CI, [Sherlock](https://inlang.com/m/r7kp499g/app-inlang-ideExtension) muestra las traducciones inline en VS Code y [Fink](https://fink.inlang.com/) es un editor gratuito para el navegador que hace commit de los cambios de los traductores en un repositorio de GitHub.
## Lo que Paraglide JS deja en tus manos
Un proyecto de inlang es una carpeta `project.inlang` cuyo archivo `settings.json` enumera tus configuraciones regionales, tus plugins y la ruta a tus archivos de mensajes. Este es un ejemplo de bandeja de entrada con un mensaje simple, un parámetro y un plural:
```json title="messages/en.json"
{
"inbox_title": "Inbox",
"greeting": "Hello {name}!",
"unread_messages": [
{
"declarations": ["input count", "local countPlural = count: plural"],
"selectors": ["countPlural"],
"match": {
"countPlural=one": "You have {count} unread message.",
"countPlural=*": "You have {count} unread messages."
}
}
]
}
```
```tsx title="Inbox.tsx"
import { m } from './paraglide/messages.js';
export function Inbox({ name, count }: { name: string; count: number }) {
return (
{m.inbox_title()}
{m.greeting({ name })}
{m.unread_messages({ count })}
);
}
```
Cada una de las demás configuraciones regionales necesita su propio archivo con las mismas claves y con las variantes que exige ese idioma: el polaco usa `one`, `few`, `many` y `*`. Si falta una clave en `messages/pl.json`, la función compilada recurre a la configuración regional base sin emitir ninguna advertencia. Así se ve el componente renderizado con un archivo en polaco al que le falta `greeting`:
```text title="Output"
pl Skrzynka odbiorcza
Hello Ada!
Masz 2 nieprzeczytane wiadomości.
```
`npx @inlang/cli check` lo detectó: informó que `greeting` no tiene traducción al polaco y terminó con el código 1, así que la CI puede bloquear ese hueco. Pero completarlo sigue siendo cosa tuya. `inlang machine translate` traduce los mensajes que faltan con un servicio gratuito mantenido por la comunidad de forma predeterminada, o con tu propia clave de Google Cloud Translation o DeepL, mensaje por mensaje y sin el componente en el que aparece cada uno. La propia documentación de la CLI de inlang sugiere que los agentes de programación con contexto del producto y del código pueden generar mejores borradores que la traducción automática genérica.
## General Translation escribe las traducciones
Las bibliotecas de General Translation se encargan del mismo trabajo de renderizado. La diferencia está en dónde se almacena el texto y quién lo traduce. Esta es la misma bandeja de entrada con `gt-react`:
```tsx title="Inbox.tsx"
import { T, Plural, Num, Var } from 'gt-react';
export function Inbox({ name, count }: { name: string; count: number }) {
return (
Inbox
Hello {name}!
You have {count} unread message.}
plural={You have {count} unread messages.
}
/>
);
}
```
No hay ningún archivo de mensajes que mantener sincronizado: el texto en inglés es el propio componente. [`npx gt translate`](/docs/cli/reference/commands/translate) envía cada bloque [``](/docs/react/reference/components/t), junto con su estructura de elementos, a la API de General Translation y genera una traducción para cada configuración regional de destino, de modo que una frase nueva queda traducida antes de la compilación en lugar de mostrarse en inglés como alternativa. Un valor dentro de [``](/docs/react/reference/components/var) nunca se envía a la API, y [``](/docs/react/reference/components/plural) elige una rama según las reglas de pluralización de la configuración regional del lector. [`npx gt validate`](/docs/cli/reference/commands/validate) comprueba el proyecto sin llamar a la API, y [`gt generate`](/docs/cli/reference/commands/generate) genera archivos de plantilla para los equipos que traducen manualmente.
El encabezado, el saludo y las ramas de plural de este bloque se envían juntos a traducir. General Translation también aplica el [glosario y los prompts personalizados](/docs/platform/dashboard/guides/defining-context-for-translations) asignados al proyecto, y los revisores editan los resultados en el panel de control. Añade la CLI a tu CI o configura [Locadex](/docs/platform/locadex/quickstart) para que abra pull requests de traducción cuando cambie tu código.
Las bibliotecas de JavaScript de General Translation tienen licencia MIT y funcionan con traducciones propias sin necesidad de una cuenta. Si incluyes las traducciones en el bundle de tu aplicación, el renderizado no depende del servicio alojado; con la entrega mediante CDN, puedes publicar cambios en las traducciones con independencia de los lanzamientos de la aplicación. Consulta [almacenamiento de traducciones](/docs/react/guides/storing-translations) para ver la configuración inicial.
Sierra ofrece más de 7 configuraciones regionales en su contenido web y comercial gracias a General Translation. (Consulta [despliegues en producción](https://generaltranslation.com/enterprise)).
## Paraglide JS vs. General Translation de un vistazo
| Característica | Paraglide JS | General Translation |
| ---------------------- | ------------------------------------------------------------------------------------------------------- | --------------------------------------------------------------------------------------------------------------------------------------------------- |
| Cómo escribes el texto | Claves en un archivo JSON por configuración regional, que se invocan como `m.key()` | JSX dentro de [``](/docs/react/reference/components/t), cadenas mediante [`useGT`](/docs/react/reference/hooks/use-gt) o diccionarios con claves |
| Traduce tu contenido | No; `inlang machine translate` usa un servicio comunitario, Google o DeepL | Sí, con [`npx gt translate`](/docs/cli/reference/commands/translate) |
| Qué ve el traductor | El contenido del mensaje que se envía a la herramienta de traducción elegida | El bloque JSX marcado, las notas de los desarrolladores y el glosario y los prompts personalizados asignados |
| Seguridad de tipos | Tipos generados para cada clave y parámetro | JSX inline, sin claves de mensaje que puedas escribir mal |
| Paquete | Tree-shaking por mensaje | Las traducciones se cargan por configuración regional |
| Traducción faltante | Recurre a la configuración regional base; `inlang check` la notifica | Se genera con [`npx gt translate`](/docs/cli/reference/commands/translate); el contenido sin traducir se renderiza en el idioma de origen |
| Frameworks | Aplicaciones Vite, React, Vue, Solid, SvelteKit, Astro, TanStack Start, React Router, Next.js (webpack) | React, Next.js, Vue, Node.js y [otros SDK](/docs/overview/get-started) |
| Costo | Gratuito y de código abierto | Bibliotecas de JavaScript gratuitas; [traducción facturada según el uso](https://generaltranslation.com/pricing) |
Quédate con Paraglide JS si desarrollas con SvelteKit, Astro o Solid, si lo que más te importa es el tree-shaking por mensaje y las funciones de mensaje tipadas, o si tu equipo ya redacta o compra sus propias traducciones. Usa General Translation si quieres que el texto se lea directamente en tus componentes y que cada idioma se genere con el contexto de tu código en cada compilación.
## Migrar a General Translation componente por componente
Es posible migrar componente por componente. Los mensajes de Paraglide son funciones simples y no necesitan un proveedor, así que una llamada a `m.*` y un bloque [``](/docs/react/reference/components/t) pueden renderizarse en paralelo mientras conviertes las rutas. En [Migrar bibliotecas de i18n](/docs/react/guides/migrating-i18n-libraries) se explican los pasos, partiendo del [Quickstart de React](/docs/react/react-quickstart) o del [Inicio rápido de Next.js](/docs/react/nextjs-quickstart).
## Conclusiones clave
* Paraglide JS compila los catálogos en funciones tipadas y compatibles con tree-shaking. Por separado, las herramientas de inlang pueden generar traducciones para esos catálogos.
* General Translation mantiene el texto inline en [``](/docs/react/reference/components/t) y genera traducciones con contexto a partir de tu código, tu glosario y tus prompts personalizados, que luego puedes revisar en el panel de control.
* Mantén en funcionamiento los mensajes existentes de Paraglide mientras migras los componentes a General Translation. Cada componente migrado lleva su texto de origen y su contexto de traducción en el propio JSX.
## Related questions
- [General Translation vs. i18next, react-intl y next-intl: ¿qué biblioteca de i18n deberías usar?](https://generaltranslation.com/es/kb/general-translation-vs-i18n-libraries.mdx): Las bibliotecas de código abierto como i18next, react-intl y next-intl no traducen nada. Muestran las traducciones que tú proporcionas en un archivo de catálogo para cada idioma, escritas por ti, por tus traductores o por un servicio externo. Las bibliotecas de General Translation también son de código abierto y cumplen la misma función, pero además General Translation se encarga de traducir, usando tu código como contexto.
- [General Translation vs. Intlayer: ¿cuál deberías usar?](https://generaltranslation.com/es/kb/general-translation-vs-intlayer.mdx): Intlayer guarda el contenido de cada componente en un archivo de declaración tipado situado junto a él, con todos los idiomas escritos en paralelo, y puede completar los idiomas que faltan con el proveedor de IA que tú configures. General Translation mantiene los textos inline en tus componentes, en un solo idioma, y genera los demás idiomas a partir del contexto de tu código.
- [¿Puedo hacer i18n sin archivos de traducción?](https://generaltranslation.com/es/kb/i18n-without-translation-files.mdx): Sí. Con gt-react o gt-next, el contenido se mantiene inline en tus componentes, dentro de un componente ``, y las traducciones se generan en tiempo de compilación, por lo que no tienes que escribir claves ni archivos JSON por configuración regional ni mantenerlos sincronizados.
- [¿Cómo gestiono los plurales en React?](https://generaltranslation.com/es/kb/how-to-handle-plurals-in-react.mdx): No codifiques la lógica de pluralización a mano con comprobaciones como n === 1. Para aplicaciones solo en inglés basta con una pequeña función auxiliar, pero las aplicaciones multilingües necesitan reglas de pluralización adaptadas a la configuración regional, y un componente de i18n como `` de gt-react o gt-next se encarga de ellas en todos los idiomas.
- [¿Por qué usar General Translation en lugar de un TMS (Smartling, Lokalise, Phrase, Crowdin o Transifex)?](https://generaltranslation.com/es/kb/general-translation-vs-tms.mdx): Un sistema de gestión de traducciones (TMS) como Smartling, Lokalise, Phrase, Crowdin o Transifex coordina a los traductores, pero los ingenieros siguen teniendo que extraer las cadenas, enviarlas, esperar las traducciones y volver a integrarlas en el producto. General Translation traduce el contenido de tu código junto con su contexto, incluye todos los idiomas en cada lanzamiento y funciona con bibliotecas de código abierto, sin dependencia de proveedor.
## Previous and next questions
- Previous question: [General Translation vs. nestjs-i18n: ¿cuál deberías usar?](https://generaltranslation.com/es/kb/general-translation-vs-nestjs-i18n.mdx)
- Next question: [General Translation vs. Rails I18n: ¿necesitas ambos?](https://generaltranslation.com/es/kb/general-translation-vs-rails-i18n.mdx)
## Sitemap
See the [Knowledge Base sitemap](https://generaltranslation.com/es/kb/sitemap.md) for every article.