# General Translation Knowledge Base: General Translation vs. Lingui: ¿cuál deberías usar?
URL: https://generaltranslation.com/es/kb/general-translation-vs-lingui.mdx
Docs index: https://generaltranslation.com/llms.txt
Description: Elige General Translation para mantener el texto inline como en Lingui y generar las traducciones usando tu estructura JSX como contexto. Lingui extrae los mensajes inline a catálogos para que tus traductores o un servicio conectado los traduzcan. La CLI de General Translation actualiza las traducciones a medida que cambia tu código, y tu equipo las revisa en el panel de control.
Category: Internacionalización
Last updated: 2026-10-16
Authors: Kevin Wu, Jackie Chen
Published: 2026-10-16

A la hora de escribir el código, el enfoque de Lingui se parece mucho al de General Translation. Escribes `<Trans>Inbox</Trans>` en un componente, las macros de Lingui lo compilan en un mensaje ICU con un ID generado, `lingui extract` genera catálogos PO y `lingui compile` convierte los catálogos traducidos en pequeños módulos de JavaScript. Lo que Lingui deja fuera es la traducción en sí: su documentación remite a [editar los catálogos a mano o sincronizarlos con Crowdin o Translation.io](https://lingui.dev/tools/introduction). General Translation también mantiene el texto inline, pero además se encarga de generar las traducciones.

## Lo que Lingui hace bien

* **Texto de origen inline con macros.** La macro `<Trans>` y las [macros de Lingui](https://lingui.dev/ref/macro) para plurales y cadenas simples mantienen el texto en inglés dentro del componente y se compilan a formato de mensajes ICU, así que nadie tiene que escribir claves.
* **Un tiempo de ejecución ligero.** Los mensajes se compilan de antemano y, según sus propias mediciones, el tiempo de ejecución de Lingui ocupa [unos 2 kB](https://lingui.dev/introduction).
* **Catálogos compatibles con gettext.** [PO es el formato predeterminado](https://lingui.dev/ref/catalog-formats); `lingui extract` fusiona los mensajes nuevos en cada configuración regional y marca como obsoletos los eliminados, y los campos `context` y `comment` llegan a los traductores.
* **Componentes de servidor.** [Desde la versión 4.10](https://lingui.dev/tutorials/react-rsc), `<Trans>` y `useLingui` funcionan en el servidor siempre que cada página o layout llame a `setI18n`.
* **Desarrollo activo.** [La versión 6 se publicó en abril de 2026](https://lingui.dev/blog/2026/04/22/announcing-lingui-6.0) (solo ESM, Node.js 22.19 o posterior) bajo licencia MIT.

## Lo que Lingui deja en tus manos

Aquí tienes una pequeña bandeja de entrada hecha con las macros de React de Lingui:

```jsx title="Inbox.jsx"
import { Trans, Plural } from '@lingui/react/macro';

export function Inbox({ count }) {
  return (
    <section>
      <h1>
        <Trans>Inbox</Trans>
      </h1>
      <p>
        <Trans>
          You have <Plural value={count} one="# unread message" other="# unread messages" />.
        </Trans>
      </p>
    </section>
  );
}
```

`lingui extract` añade los nuevos mensajes del idioma de destino a los catálogos PO con las traducciones vacías. Tus traductores o un servicio conectado completan esas entradas respetando la sintaxis ICU. Así queda el catálogo en español una vez hecho esto:

```text title="locales/es/messages.po"
#: src/Inbox.jsx:7
msgid "Inbox"
msgstr "Bandeja de entrada"

#: src/Inbox.jsx:10
msgid "You have {count, plural, one {# unread message} other {# unread messages}}."
msgstr "Tienes {count, plural, one {# mensaje sin leer} other {# mensajes sin leer}}."
```

Después, [`lingui compile`](https://lingui.dev/ref/cli) convierte el catálogo en un módulo que carga la aplicación. Este ciclo de extracción, traducción y compilación se repite con cada cambio; las macros requieren una [transformación en tiempo de compilación](https://lingui.dev/installation) (el plugin de Babel de Lingui, su plugin de Vite o un plugin experimental de SWC), y quien traduce trabaja a partir de la entrada PO y sus comentarios, no del componente.

## Mantén el texto inline y deja que General Translation genere los catálogos

Las bibliotecas de General Translation conservan la misma redacción inline: el texto permanece en [`<T>`](/docs/react/reference/components/t), las formas plurales van en [`<Plural>`](/docs/react/reference/components/plural) y [`<Num>`](/docs/react/reference/components/num) da formato a los valores para cada configuración regional. Además, General Translation hace lo que Lingui no hace: genera las traducciones. Esta es 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>
  );
}
```

[`npx gt translate`](/docs/cli/reference/commands/translate) envía cada bloque [`<T>`](/docs/react/reference/components/t) junto con su estructura de elementos y genera los catálogos de destino antes de la compilación. Las ramas de origen `singular` y `plural` proporcionan el texto para las formas que requiere cada idioma de destino. [`<Plural>`](/docs/react/reference/components/plural) selecciona la rama traducida en tiempo de ejecución. Las cadenas fuera de JSX se gestionan con [`useGT`](/docs/react/reference/hooks/use-gt), el equivalente de la macro de cadenas de Lingui.

En este ejemplo, el encabezado de la bandeja de entrada y las ramas del mensaje se envían juntos a traducir. También puedes añadir una [nota de `context`](/docs/react/reference/components/t#context) para aclarar significados propios del producto. Los revisores editan el texto generado en el [Editor de Traducciones del panel de control](/docs/platform/dashboard/guides/reviewing-translations); la siguiente ejecución de la CLI reutiliza las traducciones que no han cambiado y genera el texto nuevo, sin necesidad de un comando aparte para compilar catálogos.

La plataforma y la documentación de Profound están disponibles en más de 47 configuraciones regionales gracias a General Translation. (Consulta los [despliegues en producción](https://generaltranslation.com/enterprise)).

## Lingui frente a General Translation de un vistazo

| Característica           | Lingui                                                                                            | General Translation                                                                                                      |
| ------------------------ | ------------------------------------------------------------------------------------------------- | ------------------------------------------------------------------------------------------------------------------------ |
| Cómo se redacta el texto | Macros inline como `<Trans>`                                                                      | JSX inline en [`<T>`](/docs/react/reference/components/t) y cadenas en [`useGT`](/docs/react/reference/hooks/use-gt)     |
| Traduce tu contenido     | No                                                                                                | Sí, con [`npx gt translate`](/docs/cli/reference/commands/translate)                                                     |
| Pasos por cambio         | Extraer, traducir cada catálogo PO y compilar, con una transformación de macros en tu compilación | Ejecutar [`npx gt translate`](/docs/cli/reference/commands/translate) antes de la compilación                            |
| Catálogos                | Archivos PO por configuración regional, compilados a módulos de JavaScript                        | Generados por configuración regional y almacenados en tu repositorio o en la CDN de General Translation                  |
| Lo que ve el traductor   | El mensaje y los campos `context` y `comment`                                                     | La estructura de los bloques JSX marcados, las notas de contexto, y el glosario y los prompts personalizados compartidos |

Quédate con Lingui si tus traductores trabajan con catálogos PO de gettext, si su tiempo de ejecución compilado y mínimo es importante para el tamaño de tu paquete o si tu proceso de traducción ya funciona bien. Elige General Translation si quieres la misma redacción inline sin el ciclo de extracción, traducción y compilación, y traducciones generadas teniendo en cuenta el contexto de tu código.

## Migración desde Lingui

Migra un componente o una ruta cada vez. El `<Trans>` de Lingui equivale a [`<T>`](/docs/react/reference/components/t), y su `<Plural value={count} one="…" other="…" />` equivale a [`<Plural>`](/docs/react/reference/components/plural) con `n={count}` y las ramas `singular` y `plural`, junto con [`<Num>`](/docs/react/reference/components/num) para el número. Su macro de cadenas equivale a [`useGT`](/docs/react/reference/hooks/use-gt). Sigue cargando las traducciones existentes de Lingui para los componentes que aún no hayas migrado. Cuando hayas migrado el último componente, elimina la transformación de macros y los scripts de extracción y compilación. (Consulta [Migración de bibliotecas de i18n](/docs/react/guides/migrating-i18n-libraries)).

## Conclusiones clave

* Lingui mantiene el texto inline y compila un tiempo de ejecución ligero; los traductores o un servicio conectado proporcionan cada catálogo de destino.
* Las bibliotecas de General Translation conservan la misma redacción inline y, además, General Translation se encarga de la traducción, con el contexto de tu código y sin ciclos de catálogo.
* Las macros de Lingui tienen equivalentes muy directos en [`<T>`](/docs/react/reference/components/t), [`<Plural>`](/docs/react/reference/components/plural) y [`useGT`](/docs/react/reference/hooks/use-gt), así que puedes migrar componente a componente.

## 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.
- [Alternativas a i18next: General Translation vs. i18next](https://generaltranslation.com/es/kb/general-translation-vs-i18next.mdx): Elige General Translation para mantener los textos inline en los componentes de React y generar traducciones a partir de su estructura JSX y del contexto del producto. También puedes seguir usando i18next y recurrir a General Translation para traducir los catálogos existentes. i18next se encarga de renderizar los mensajes y seleccionar los plurales, pero las traducciones las genera un servicio aparte.
- [Alternativas a react-intl: General Translation vs. react-intl](https://generaltranslation.com/es/kb/general-translation-vs-react-intl.mdx): General Translation permite a los equipos de React conservar la sintaxis de mensajes ICU y, además, añade generación de traducciones, terminología compartida y revisión en el panel de control. react-intl ofrece formato y herramientas de catálogos de FormatJS; General Translation, además, genera las traducciones.
- [General Translation vs. vue-i18n: ¿cuál deberías usar?](https://generaltranslation.com/es/kb/general-translation-vs-vue-i18n.mdx): General Translation permite a los equipos de Vue escribir el texto de origen directamente en las plantillas y generar traducciones con la CLI. Su plugin gt-vue renderiza ese contenido con formato de plurales y de números adaptado a la configuración regional. Elígelo si quieres dejar de mantener archivos de origen basados en claves; vue-i18n sigue siendo una buena opción para equipos que usan el módulo i18n de Nuxt y un flujo de trabajo de catálogos ya consolidado.
- [¿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.

## Previous and next questions

- Previous question: [General Translation vs. Intlayer: ¿cuál deberías usar?](https://generaltranslation.com/es/kb/general-translation-vs-intlayer.mdx)
- Next question: [General Translation vs. Locize: ¿cuál deberías usar?](https://generaltranslation.com/es/kb/general-translation-vs-locize.mdx)

## Sitemap

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