# 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.

## Video

The video is narrated in English, with English captions.

[General Translation vs. Intlayer: which should you use?](https://caxecubb9c64cezv.public.blob.vercel-storage.com/films/kb-general-translation-vs-intlayer.mp4) (42 s)

General Translation keeps copy inline in your components in one language and generates the other languages with the context of your code, while Intlayer keeps every language side by side in typed declaration files and fills gaps with an AI provider you configure. Write copy once inside a `<T>` component, run `npx gt translate` before the build, and review in the Dashboard while Locadex handles updates.

## 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í. Las bibliotecas gt-react y gt-next de General Translation permiten hacer i18n en React y Next.js sin claves de traducción y sin tener que mantener un archivo JSON por idioma. El texto permanece inline en JSX dentro del componente `<T>`, y el comando gt translate genera las traducciones de cada idioma durante la compilación, con contexto extraído de tu código. Locadex puede mantenerlas al día mediante pull requests.
- [¿Cómo gestiono los plurales en React?](https://generaltranslation.com/es/kb/how-to-handle-plurals-in-react.mdx): Para gestionar los plurales en React, asigna a cada idioma una oración por cada forma plural y selecciónala con las reglas de plural de ese idioma, ya que el inglés tiene 2 formas, el ruso tiene 4 y el árabe tiene 6. El componente `<Plural>` de General Translation en gt-react y gt-next recibe tus formas de origen, y General Translation genera las formas que necesita cada idioma de destino.
- [General Translation frente a un TMS (Crowdin, Lokalise, Phrase)](https://generaltranslation.com/es/kb/general-translation-vs-tms.mdx): Elige General Translation cuando los desarrolladores quieran que la generación de traducciones, el contexto derivado del código y la revisión estén vinculados a los lanzamientos del producto. Conserva tus catálogos y tu biblioteca de renderizado actuales, o escribe JSX inline sin claves de traducción. Un TMS encaja con programas centrados en proveedores lingüísticos, editores CAT e intercambio de XLIFF; sus integraciones pueden automatizar las transferencias de archivos.

## 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.