# General Translation Knowledge Base: General Translation vs. Intlayer: ¿cuál deberías usar?
URL: https://generaltranslation.com/es/kb/general-translation-vs-intlayer.mdx
Docs index: https://generaltranslation.com/llms.txt
Description: 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.
Category: Internacionalización
Last updated: 2026-10-16
Authors: Kevin Wu, Jackie Chen
Published: 2026-10-16

Intlayer es una [biblioteca de i18n de código abierto](https://github.com/aymericzip/intlayer) que coloca el contenido en un archivo de declaración junto a cada componente, como `inbox.content.ts`, donde cada cadena incluye sus traducciones en una única llamada a `t({ en, es, pl })`. Un hook como `useIntlayer('inbox')` devuelve ese contenido, tipado, en la configuración regional actual. Intlayer completa los idiomas que faltan con el proveedor de IA que tú configures, e incluye un editor visual gratuito y un CMS alojado opcional, pero todos los idiomas de cada cadena siguen estando en tus archivos de origen, y eres tú quien tiene que escribirlos, completarlos y revisarlos. General Translation sigue el camino contrario: escribes los textos una sola vez, inline, en el idioma de origen, y General Translation genera los demás idiomas a partir del contexto de tu código.

## Lo que Intlayer hace bien

* **Contenido junto al componente.** Un archivo de declaración por componente mantiene el texto cerca del código que lo renderiza.
* **Seguridad de tipos.** Las claves de `useIntlayer` están tipadas: en la versión 9.7.0, `useIntlayer('inbx')` genera un error de TypeScript. También se detecta una llamada a `t()` a la que le falte alguna de las configuraciones regionales definidas (en una prueba con la 9.7.0 produjo un error de tipo; `strictMode` determina el rigor de la comprobación), así que cualquier hueco sale a la luz antes de publicar.
* **Tipos de contenido enriquecido.** Además del texto por configuración regional, las declaraciones admiten [plurales por categoría CLDR](https://intlayer.org/doc/concept/content/plural) (`plural({ one, few, many, other })`), enumeraciones, condiciones, género, Markdown, HTML, anidamiento e inserción.
* **Usa tu propio modelo.** `intlayer fill` traduce las configuraciones regionales que faltan con OpenAI, Anthropic, Mistral, Gemini, DeepSeek, Ollama, OpenRouter y otros proveedores, que se configuran en [`ai` dentro de `intlayer.config.ts`](https://intlayer.org/doc/concept/configuration) o con `--provider` y `--api-key`. Con tu propia clave y el paquete `@intlayer/ai` instalado, [se ejecuta en local](https://intlayer.org/doc/concept/cli/fill) y pagas directamente al proveedor.
* **Edición visual.** El paquete `intlayer-editor` carga tu aplicación en ejecución dentro de un editor en el que los redactores seleccionan y editan texto, y después guarda los cambios en tus archivos de declaración. [Según la documentación de Intlayer](https://intlayer.org/doc/concept/editor), el editor tiene licencia Apache 2.0, es gratuito para uso comercial y está pensado para entornos de desarrollo y preproducción.
* **Compatibilidad con frameworks.** Las [guías](https://intlayer.org/doc/get-started) cubren Next.js, React con Vite, React Router, TanStack Start, React Native, Vue y Nuxt, Svelte y SvelteKit, Solid, Preact, Astro, Angular y frameworks de servidor como Express, NestJS, Fastify y Hono.

## Lo que Intlayer deja en tus manos

Este es el archivo de contenido de una bandeja de entrada con tres configuraciones regionales:

```ts title="inbox.content.ts"
import { t, plural, type Dictionary } from 'intlayer';

const inboxContent = {
  key: 'inbox',
  content: {
    title: t({
      en: 'Inbox',
      es: 'Bandeja de entrada',
      pl: 'Skrzynka odbiorcza',
    }),
    unread: t({
      en: plural({
        one: 'You have {{count}} unread message.',
        other: 'You have {{count}} unread messages.',
      }),
      es: plural({
        one: 'Tienes {{count}} mensaje sin leer.',
        other: 'Tienes {{count}} mensajes sin leer.',
      }),
      pl: plural({
        one: 'Masz {{count}} nieprzeczytaną wiadomość.',
        few: 'Masz {{count}} nieprzeczytane wiadomości.',
        many: 'Masz {{count}} nieprzeczytanych wiadomości.',
        other: 'Masz {{count}} nieprzeczytanej wiadomości.',
      }),
    }),
  },
} satisfies Dictionary;

export default inboxContent;
```

```tsx title="Inbox.tsx"
import { useIntlayer } from 'react-intlayer';

export function Inbox({ count }: { count: number }) {
  const { title, unread } = useIntlayer('inbox');
  return (
    <section>
      <h1>{title}</h1>
      <p>{unread({ count })}</p>
    </section>
  );
}
```

Esto se renderiza correctamente en todas las configuraciones regionales, pero el archivo crece con cada una que agregas: con 20 configuraciones regionales, cada cadena lleva 20 entradas. Además, cada cadena nueva las necesita todas. Al agregar `archive: t({ en: 'Archive' })`, se produjo un error de tipo que indicaba las configuraciones regionales que aún faltaban:

```text title="Output"
Type '{ en: string; }' is missing the following properties from type
'Required<Record<keyof __RequiredLocalesRegistry, unknown>>': es, pl
```

En tiempo de ejecución, las configuraciones regionales que faltaban recurrían al inglés. Para cubrir ese hueco, tienes que escribir las traducciones tú mismo o ejecutar `intlayer fill`. Fill envía al modelo el contenido del diccionario, [su descripción](https://intlayer.org/doc/concept/content) y una cadena `applicationContext` de tu configuración. No ve el componente ni el JSX que rodea a cada cadena. [El compilador de Intlayer](https://intlayer.org/doc/compiler) puede extraer texto JSX plano a archivos de contenido en tiempo de compilación, así que no hace falta escribir las declaraciones a mano, pero las traducciones siguen acabando en esos archivos.

## General Translation mantiene un solo idioma en el código

Las bibliotecas de General Translation renderizan las traducciones de la misma manera: eligen los mensajes de cada configuración regional y aplican sus reglas de plural. La diferencia es que en tus componentes solo está el idioma de origen. Aquí tienes la misma bandeja de entrada con `gt-react`:

```tsx title="Inbox.tsx"
import { T, Plural, Num } from 'gt-react';

export function Inbox({ count }: { count: number }) {
  return (
    <T>
      <section>
        <h1>Inbox</h1>
        <Plural
          n={count}
          singular={<p>You have <Num>{count}</Num> unread message.</p>}
          plural={<p>You have <Num>{count}</Num> unread messages.</p>}
        />
      </section>
    </T>
  );
}
```

No hay archivo de contenido ni claves. [`npx gt translate`](/docs/cli/reference/commands/translate) envía cada bloque [`<T>`](/docs/react/reference/components/t), junto con su estructura de elementos, a la API de General Translation y escribe las traducciones de cada configuración regional de destino en archivos independientes, de modo que añadir una configuración regional modifica `gt.config.json`, no tus componentes. Tú escribes las formas plurales que usa el inglés, la traducción genera las que necesita cada idioma de destino y [`<Plural>`](/docs/react/reference/components/plural) elige una rama traducida según las reglas 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 plantillas para los equipos que traducen a mano.

Lo que marca la diferencia en el resultado es el contexto. General Translation traduce conjuntamente el texto y la estructura JSX de cada bloque marcado, con notas de los desarrolladores que aclaran el significado. Un botón «Save» para un documento se traduce como «speichern» en alemán; una oferta para ahorrar dinero, como «sparen». Los [grupos de contexto](/docs/platform/dashboard/guides/defining-context-for-translations) aplican tu glosario y tus prompts personalizados a los proyectos que les asignes. Los revisores editan en el panel de control, y la CLI o [Locadex](/docs/platform/locadex/quickstart) se encargan de las actualizaciones a medida que cambia el código. Los equipos que quieran marcar automáticamente el JSX existente pueden activar la [inyección automática de JSX](/docs/cli/guides/using-auto-jsx).

Las bibliotecas de JavaScript tienen licencia MIT y pueden renderizar traducciones ya proporcionadas sin necesidad de una cuenta. Mantén las traducciones en tu compilación o publícalas en la CDN de General Translation.

Cursor usa General Translation para más de 14 configuraciones regionales en su web y su documentación. (Consulta los [despliegues en producción](https://generaltranslation.com/enterprise)).

## Intlayer vs. General Translation de un vistazo

| Característica                       | Intlayer                                                                                                                                                                                   | General Translation                                                                                                                                 |
| ------------------------------------ | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------ | --------------------------------------------------------------------------------------------------------------------------------------------------- |
| Cómo se escribe el texto             | `t({ en, es, ... })` en un archivo de declaración por componente, que se lee con `useIntlayer`                                                                                             | JSX dentro de [`<T>`](/docs/react/reference/components/t), cadenas mediante [`useGT`](/docs/react/reference/hooks/use-gt) o diccionarios con claves |
| Dónde se almacenan las traducciones  | En los archivos de declaración o en archivos de contenido por configuración regional                                                                                                       | En archivos independientes por configuración regional o en la CDN de General Translation                                                            |
| Traducción con IA                    | `intlayer fill` con la clave de tu proveedor o mediante el servicio de Intlayer                                                                                                            | [`npx gt translate`](/docs/cli/reference/commands/translate) mediante la API de General Translation                                                 |
| Contexto que recibe el modelo        | Contenido del diccionario, descripción y una cadena de contexto de la aplicación                                                                                                           | Estructura JSX marcada, notas de los desarrolladores, y el glosario y los prompts personalizados asignados                                          |
| Configuraciones regionales faltantes | Se señalan como error de tipo en una prueba con la versión 9.7.0; [`intlayer test`](https://intlayer.org/doc/concept/cli/test) las detecta                                                 | Se generan con [`npx gt translate`](/docs/cli/reference/commands/translate); el contenido sin traducir se renderiza en el idioma de origen          |
| Edición                              | Editor visual local gratuito; CMS alojado opcional                                                                                                                                         | Edición y revisión de traducciones en el panel de control                                                                                           |
| Frameworks                           | React, Next.js, Vue, Svelte, Solid, Angular, Astro, React Native y servidores Node.js                                                                                                      | React, Next.js, Vue, Node.js y [otros SDKs](/docs/overview/get-started)                                                                             |
| Licencia y costo                     | Apache 2.0; el precio de los planes del CMS alojado depende del número de proyectos, puestos y almacenamiento ([precios](https://app.intlayer.org/pricing), consultado en octubre de 2026) | Bibliotecas de JavaScript con licencia MIT; [traducción con pago por uso](https://generaltranslation.com/pricing)                                   |

Elige Intlayer si quieres ver todos los idiomas junto al componente, obtener errores de tipo cuando falten configuraciones regionales, ofrecer a los redactores un editor en la propia página o usar su integración con Svelte, Solid o Angular. Usa General Translation si prefieres escribir el texto una sola vez en el idioma de origen y que todos los demás idiomas se generen a partir del contexto de tu código, tu glosario y tus prompts personalizados.

## Migrar de Intlayer a General Translation

Migra los componentes de uno en uno y sigue usando sus traducciones de Intlayer hasta que la versión de General Translation de cada uno esté lista. En un renderizado en el servidor con `react-intlayer` 9.7.0 y `gt-react` 11.4.12, un componente de Intlayer y un componente [`<T>`](/docs/react/reference/components/t) se renderizaron sin problemas uno junto al otro dentro de `IntlayerProvider` y [`GTProvider`](/docs/react/reference/components/gt-provider). Copia los valores `en` del componente como JSX dentro de [`<T>`](/docs/react/reference/components/t), genera las traducciones con [`npx gt translate`](/docs/cli/reference/commands/translate) y revisa el resultado antes de hacer el cambio. Empieza con el [Inicio rápido de Next.js](/docs/react/nextjs-quickstart) o el [Quickstart de React](/docs/react/react-quickstart), y consulta [Migrar bibliotecas de i18n](/docs/react/guides/migrating-i18n-libraries) para saber cómo usar dos bibliotecas a la vez durante una migración.

## Puntos clave

* Intlayer guarda el contenido de cada componente en un archivo de declaración tipado con todos los idiomas juntos, detecta las configuraciones regionales que faltan como errores de tipo y las completa con el proveedor de IA que configures.
* General Translation mantiene solo el idioma de origen en tus componentes y genera todos los demás idiomas con contexto extraído de tu código, tu glosario y tus prompts personalizados, con revisión en el panel de control.
* Intlayer es compatible con más frameworks y ofrece edición visual directamente en la página; puedes migrar a General Translation componente a componente, ya que ambas bibliotecas pueden renderizarse en paralelo.

## 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. Paraglide JS: ¿cuál deberías usar?](https://generaltranslation.com/es/kb/general-translation-vs-paraglide.mdx): 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.
- [¿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 `<T>`, 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 `<Plural>` 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. i18next, react-intl y next-intl: ¿qué biblioteca de i18n deberías usar?](https://generaltranslation.com/es/kb/general-translation-vs-i18n-libraries.mdx)
- Next question: [General Translation vs. Lingui: ¿cuál deberías usar?](https://generaltranslation.com/es/kb/general-translation-vs-lingui.mdx)

## Sitemap

See the [Knowledge Base sitemap](https://generaltranslation.com/es/kb/sitemap.md) for every article.