# General Translation Knowledge Base: ¿Puedo hacer i18n sin archivos de traducción?
URL: https://generaltranslation.com/es/kb/i18n-without-translation-files.mdx
Docs index: https://generaltranslation.com/llms.txt
Description: 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.
Category: Internacionalización
Last updated: 2026-10-21
Authors: Jackie Chen, Ernest McCarter
Published: 2026-05-07

Sí. Las bibliotecas de código abierto `gt-react` y `gt-next` de General Translation te permiten internacionalizar (i18n) una aplicación de React o Next.js sin claves de traducción y sin escribir un archivo JSON para cada idioma. Escribes el texto inline en tu JSX dentro del componente [`<T>`](/docs/react/reference/components/t), y [`npx gt translate`](/docs/cli/reference/commands/translate) genera las traducciones para todos los idiomas durante la compilación.

Las bibliotecas basadas en claves, como i18next, react-intl y next-intl, buscan cada cadena por su clave en un archivo de mensajes por idioma, así que cada cadena nueva necesita una clave en todos los archivos. Basta con añadir una clave a `en.json` y olvidarla en `ja.json` para que una línea de tu página de pago en japonés quede sin traducir.

Con General Translation, los archivos de traducción siguen existiendo, pero como resultado de la compilación. La CLI genera un archivo por idioma y puede publicar las traducciones en la CDN de General Translation. Nadie edita esos archivos a mano ni copia claves de uno a otro.

## Video

The video is narrated in English, with English captions.

[Can I do i18n without translation files?](https://caxecubb9c64cezv.public.blob.vercel-storage.com/films/kb-i18n-without-translation-files.mp4) (46 s)

General Translation lets you stop writing translation files with `gt-react` or `gt-next`. Run `npx gt init`, write the English inside a `<T>` component, then add `npx gt translate` to your build script so every build writes the translations.

## ¿Puedo traducir componentes de React inline en lugar de usar un archivo de claves?

Sí. Con General Translation, cada frase se queda en el componente, dentro de [`<T>`](/docs/react/reference/components/t), y la CLI traduce el bloque completo. En cambio, un resumen de compra con react-i18next obtiene cada cadena por su clave desde un archivo JSON:

```json title="locales/en/checkout.json"
{
  "summary": {
    "title": "Order summary",
    "item_count_one": "You have {{count}} item in your cart.",
    "item_count_other": "You have {{count}} items in your cart.",
    "tax_notice": "Tax is calculated at checkout."
  }
}
```

```tsx title="CheckoutSummary.tsx"
import { useTranslation } from 'react-i18next';

export function CheckoutSummary({ itemCount }: { itemCount: number }) {
  const { t } = useTranslation('checkout');
  return (
    <section>
      <h2>{t('summary.title')}</h2>
      <p>{t('summary.item_count', { count: itemCount })}</p>
      <small>{t('summary.tax_notice')}</small>
    </section>
  );
}
```

El mismo componente con `gt-next` conserva el texto en inglés directamente en el JSX. Otros frameworks de React importan desde su propio paquete, como `gt-react`.

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

export function CheckoutSummary({ itemCount }: { itemCount: number }) {
  return (
    <T>
      <section>
        <h2>Order summary</h2>
        <Plural
          n={itemCount}
          one={<p>You have <Num>{itemCount}</Num> item in your cart.</p>}
          other={<p>You have <Num>{itemCount}</Num> items in your cart.</p>}
        />
        <small>Tax is calculated at checkout.</small>
      </section>
    </T>
  );
}
```

La versión con `gt-next` no tiene `checkout.json`, ni claves que nombrar, ni un `ja.json` que actualizar. [`npx gt translate`](/docs/cli/reference/commands/translate) envía cada bloque [`<T>`](/docs/react/reference/components/t) a la API de General Translation, junto con su estructura de elementos como contexto, y genera una traducción para cada idioma definido en `gt.config.json`. [`<Plural>`](/docs/react/reference/components/plural) elige la forma plural que necesita cada idioma (el japonés usa una sola forma; el árabe, seis), y [`<Num>`](/docs/react/reference/components/num) da formato a la cantidad según la configuración regional del lector.

## ¿Qué bibliotecas de i18n permiten escribir texto directamente en JSX sin archivos de claves?

Con `gt-react` y `gt-next` de General Translation puedes escribir texto traducible directamente en JSX sin archivos de claves, y General Translation se encarga de generar las traducciones. Lingui y la extracción experimental de next-intl también aceptan mensajes inline, pero los extraen a catálogos que tu equipo, los traductores o un servicio siguen teniendo que traducir.

| Biblioteca                                  | Dónde escribes el texto                                                                                                                                                    | De dónde provienen las traducciones                                                                                                | Qué mantiene tu equipo                                                                          |
| ------------------------------------------- | -------------------------------------------------------------------------------------------------------------------------------------------------------------------------- | ---------------------------------------------------------------------------------------------------------------------------------- | ----------------------------------------------------------------------------------------------- |
| i18next (`react-i18next`)                   | Claves en un archivo JSON por idioma                                                                                                                                       | Tu equipo, traductores o un servicio                                                                                               | Una clave para cada cadena, en el archivo de cada idioma                                        |
| next-intl                                   | Claves en un catálogo JSON por idioma; los [mensajes inline con `useExtracted`](https://next-intl.dev/docs/usage/extraction) son experimentales                            | Tu equipo, traductores o un servicio                                                                                               | Cada catálogo, actualizado a medida que cambia el texto                                         |
| [Lingui](https://lingui.dev/introduction)   | Macros `<Trans>` inline con IDs de mensaje generados, extraídas a catálogos PO                                                                                             | Tu equipo, traductores o un servicio                                                                                               | Extraer, traducir y compilar los catálogos                                                      |
| General Translation (`gt-react`, `gt-next`) | JSX inline dentro de [`<T>`](/docs/react/reference/components/t), cadenas mediante [`useGT`](/docs/react/reference/hooks/use-gt) o, opcionalmente, diccionarios con claves | Generadas por [`npx gt translate`](/docs/cli/reference/commands/translate) en cada compilación, con contexto extraído de tu código | Envolver el texto en [`<T>`](/docs/react/reference/components/t) y un único paso de compilación |

Usa i18next o next-intl si los traductores o un sistema de gestión de traducciones ya trabajan con archivos de catálogo, o si el texto apenas cambia. Usa Lingui o la extracción de next-intl si quieres el texto de origen inline y piensas enviar los catálogos a traducir. Usa General Translation si quieres el texto inline y que todos los idiomas se generen en cada compilación. Los equipos que prefieran claves estables pueden seguir usándolas con el [modo diccionario](/docs/react/guides/translating-with-dictionaries) de General Translation.

## ¿Cuáles son las ventajas y desventajas de la i18n basada en claves y de la traducción inline?

La traducción inline mantiene cada oración en el componente de React que la renderiza, de modo que los componentes y los pull requests siguen siendo legibles y no hay claves que nombrar, sincronizar ni limpiar. La contrapartida es que el texto de origen vive en el código, así que cualquier cambio en el texto pasa por los desarrolladores. La i18n basada en claves guarda el texto en catálogos separados del código, lo que permite a redactores y traductores trabajar sin tocar los componentes, pero obliga a añadir una clave y una entrada en el archivo de cada idioma por cada cadena. General Translation admite ambos enfoques: texto inline con [`<T>`](/docs/react/reference/components/t), o claves con el modo diccionario.

| Tarea                                | Claves de traducción (i18next, next-intl)                                                                | Texto inline (General Translation)                                                                                                                               |
| ------------------------------------ | -------------------------------------------------------------------------------------------------------- | ---------------------------------------------------------------------------------------------------------------------------------------------------------------- |
| Leer un componente o un pull request | Ves `t('summary.tax_notice')` y tienes que abrir el archivo JSON para encontrar la oración               | Ves la oración directamente en el JSX                                                                                                                            |
| Añadir una cadena                    | Pones nombre a una clave, la añades al archivo de origen y luego la incorporas al archivo de cada idioma | La escribes dentro de [`<T>`](/docs/react/reference/components/t); la siguiente ejecución de [`gt translate`](/docs/cli/reference/commands/translate) la traduce |
| Cambiar el texto de origen           | Los demás idiomas conservan la traducción anterior hasta que alguien los actualiza                       | La siguiente ejecución vuelve a traducir la entrada modificada                                                                                                   |
| Eliminar un componente               | Sus claves siguen en todos los archivos hasta que alguien o un script las elimina                        | La siguiente ejecución deja de recopilar su contenido                                                                                                            |
| Añadir un idioma                     | Creas un archivo con todas las claves y lo traduces                                                      | Añades el código de configuración regional a `locales` en `gt.config.json` y ejecutas [`gt translate`](/docs/cli/reference/commands/translate)                   |
| IDs estables                         | Cada cadena tiene uno                                                                                    | Opcionales, con [`$id`](/docs/react/reference/components/t#id) en [`<T>`](/docs/react/reference/components/t) o con el modo diccionario                          |
| Quién edita el texto de origen       | Los redactores pueden editar un catálogo sin tocar el código                                             | Los cambios de texto son cambios de código                                                                                                                       |

Las claves son más adecuadas cuando los redactores necesitan editar el texto de origen sin tocar el código, o cuando los componentes no deben contener oraciones en ningún idioma concreto. En ese caso, conserva tus claves: el [modo diccionario](/docs/react/guides/translating-with-dictionaries) de General Translation lee un diccionario con claves y sigue generando las traducciones.

## ¿Cómo agrego compatibilidad con varios idiomas a una aplicación de Next.js con App Router sin claves de traducción?

Usa la biblioteca `gt-next` de General Translation y la CLI `gt` en cuatro pasos, que el [Inicio rápido de Next.js App Router](/docs/react/nextjs-quickstart) también explica para hacerlo manualmente:

1. Ejecuta [`npx gt@latest init`](/docs/cli/reference/commands/init). El asistente de configuración inicial detecta el App Router, puede instalar `gt-next`, agregar `withGTConfig` a `next.config.ts` y [`GTProvider`](/docs/react/reference/components/gt-provider) a `app/layout.tsx`, y guarda tus idiomas en `gt.config.json`. También puede guardar una clave de desarrollo en `.env.local` para que `next dev` traduzca el texto nuevo bajo demanda. Revisa los cambios que realice.
2. Envuelve el texto en [`<T>`](/docs/react/reference/components/t) y agrega un menú desplegable [`<LocaleSelector>`](/docs/react/reference/components/locale-selector) para cambiar de idioma. [`<T>`](/docs/react/reference/components/t) funciona tanto en Componentes de servidor como en Componentes de cliente.
3. Agrega [`npx gt translate`](/docs/cli/reference/commands/translate) antes de `next build` en tu script de compilación.
4. Configura `GT_PROJECT_ID` y `GT_API_KEY` en tu proveedor de hosting. La clave que usa la compilación debe tener habilitados los permisos **Files &gt; Write** y **Translation queue**.

```tsx title="app/page.tsx"
import { T, LocaleSelector } from 'gt-next';

export default function Home() {
  return (
    <main>
      <LocaleSelector />
      <T>
        <h1>Find your next project</h1>
        <p>Explore projects from teams around the world.</p>
      </T>
    </main>
  );
}
```

```json title="package.json"
{
  "scripts": {
    "build": "npx gt translate && next build"
  }
}
```

A partir de ese momento, cada compilación de producción genera las traducciones de todos los idiomas definidos en `gt.config.json`. Para ver una guía más detallada con componentes de servidor y de cliente, consulta [¿Cómo añado i18n a una aplicación de Next.js con App Router?](/kb/add-i18n-to-nextjs). Si prefieres delegar la configuración inicial a un agente de programación, consulta [el flujo de trabajo con agentes de programación](/kb/ai-agent-i18n-setup).

## ¿Cómo evito que los archivos JSON de traducciones se desincronicen de mi código fuente?

Genéralos a partir del código fuente en cada compilación en lugar de editarlos a mano. Con archivos de claves, una app con 400 cadenas en 12 idiomas de destino suma 4800 entradas que alguien tiene que mantener sincronizadas con el código. Con General Translation, [`npx gt translate`](/docs/cli/reference/commands/translate) se ejecuta antes de la compilación, recopila todos los bloques [`<T>`](/docs/react/reference/components/t) y todas las cadenas de [`useGT`](/docs/react/reference/hooks/use-gt), traduce lo nuevo o modificado a cada idioma definido en `gt.config.json` y escribe un archivo JSON por idioma en la ruta `files.gt.output`:

```json title="gt.config.json"
{
  "defaultLocale": "en",
  "locales": ["es", "fr", "ja"],
  "files": {
    "gt": {
      "output": "public/_gt/[locale].json"
    }
  }
}
```

```txt title=".gitignore"
public/_gt/
```

Como General Translation regenera esos archivos a partir del código que compila cada compilación, siempre coinciden con ese código. El inicio rápido de Next.js añade el directorio de salida a `.gitignore`, ya que los archivos se generan automáticamente. El [flujo de trabajo incremental](/docs/cli/guides/generating-translations#retranslate) de General Translation traduce solo el contenido de origen modificado y reutiliza las traducciones coincidentes de versiones anteriores. El [seguimiento de ramas](/docs/cli/guides/branching) (`--enable-branching`, en un plan Starter o Enterprise) mantiene las traducciones de una rama de funcionalidad separadas de las de producción hasta que se fusiona.

Para los equipos que prefieren confirmar los cambios de traducción en el repositorio, las [automatizaciones de Locadex](/docs/platform/locadex/guides/configuring-automations) traducen el contenido de origen nuevo o actualizado y, cuando cambia tu lista de idiomas, añaden o eliminan archivos de configuración regional, todo mediante pull requests. Cada automatización se ejecuta con uno de estos tres disparadores: cuando cambia una pull request, cuando se envía un commit o cuando alguien la inicia manualmente. Para configuraciones de CI, consulta [¿Cómo mantengo las traducciones actualizadas en cada despliegue?](/kb/translations-in-ci).

## ¿Puede General Translation añadir i18n a una aplicación React automáticamente?

Sí. General Translation automatiza los dos pasos de la i18n en React: envolver el texto para traducirlo y generar las traducciones.

* **En tiempo de compilación:** el compilador de General Translation, `@generaltranslation/compiler`, envuelve el texto JSX traducible en [`<T>`](/docs/react/reference/components/t) cuando activas `enableAutoJsxInjection` en `files.gt.parsingFlags` dentro de `gt.config.json`. La [inyección automática de JSX](/docs/cli/guides/using-auto-jsx) funciona en aplicaciones React de una sola página, aplicaciones React renderizadas en el servidor y compilaciones de Next.js con webpack. En Next.js, usa webpack para este flujo de trabajo del compilador; con Turbopack, marca el contenido directamente con [`<T>`](/docs/react/reference/components/t) o usa Locadex para añadir los envoltorios.
* **Mediante pull requests:** Locadex, el agente de IA de General Translation, ejecuta una automatización **Generate code** que envuelve tu código de origen en [`<T>`](/docs/react/reference/components/t) y en llamadas para cadenas como [`useGT`](/docs/react/reference/hooks/use-gt), y después abre un pull request para que lo revises o lo fusiones con auto-merge.
* **Para las traducciones:** [`npx gt translate`](/docs/cli/reference/commands/translate) en tu compilación, o una automatización **Generate translations and push** de Locadex, traduce el contenido nuevo y modificado a todos los idiomas configurados.

## ¿En qué se diferencia gt-next de next-intl?

next-intl renderiza mensajes a partir de un catálogo JSON por idioma que redacta tu equipo o un servicio externo. gt-next, la biblioteca de Next.js de General Translation, mantiene el texto inline en [`<T>`](/docs/react/reference/components/t) y genera todas las traducciones con [`gt translate`](/docs/cli/reference/commands/translate). Ambas son compatibles con el App Router y los Componentes de servidor, y las dos tienen licencia MIT.

No necesitas cambiar de biblioteca para usar General Translation. La CLI `gt` detecta next-intl, react-i18next y next-i18next a partir de `package.json` y [traduce sus archivos JSON](/docs/cli/guides/generating-translations) respetando la sintaxis de mensajes de cada biblioteca, así que tus componentes y tu enrutamiento no cambian. Si más adelante quieres pasar a texto inline, la [guía de migración](/docs/react/guides/migrating-i18n-libraries) explica cómo reemplazar claves con [`<T>`](/docs/react/reference/components/t), conservar los diccionarios con [`useTranslations`](/docs/react/reference/hooks/use-translations) y usar ambas bibliotecas en paralelo mientras migras ruta por ruta. Para ver una comparación detallada, consulta [next-intl vs gt-next](/kb/next-intl-vs-gt-next).

## ¿Cómo corrigen los revisores las traducciones sin editar los archivos de traducción?

Los revisores utilizan el [Editor de Traducciones del panel de control](/docs/platform/dashboard/guides/reviewing-translations) de General Translation. Allí comparan configuraciones regionales en paralelo y editan las traducciones generadas sin abrir archivos de configuración regional ni iniciar una nueva tarea de traducción. Si, en cambio, tu equipo edita los archivos descargados, [`npx gt save-local`](/docs/cli/reference/commands/save-local) sube esos cambios a la plataforma. También puedes pasar `--save-local` a [`gt translate`](/docs/cli/reference/commands/translate) para sincronizarlos en cada ejecución.

El contexto de traducción se define tanto en el código como en el panel de control. La [prop `context`](/docs/react/reference/components/t#context) de [`<T>`](/docs/react/reference/components/t) resuelve palabras ambiguas: &quot;Save&quot; en un editor de documentos se traduce al alemán como *speichern*, mientras que, en el sentido de ahorrar dinero, se traduce como *sparen*. Los [términos del glosario y los prompts personalizados](/docs/platform/dashboard/guides/defining-context-for-translations) de un grupo de contexto aplican la misma terminología y el mismo tono en tu aplicación, tu documentación y otros proyectos.

## ¿Dónde se almacenan las traducciones generadas y necesito una cuenta?

Las traducciones generadas pueden almacenarse en uno de estos dos lugares:

* **Incluidas en el paquete de tu app:** un [cargador local](/docs/react/guides/storing-translations) importa los archivos generados, de modo que la app en producción lee sus propias traducciones y no hace ninguna solicitud a General Translation en tiempo de ejecución. Las nuevas traducciones se incorporan en la siguiente compilación.
* **En la CDN de General Translation:** con la [entrega por CDN](/docs/react/guides/configuring#delivery), las ediciones publicadas llegan a la app desplegada sin necesidad de recompilarla, en función de su configuración de versión y caché.

`gt-react` y `gt-next` tienen [licencia MIT](https://github.com/generaltranslation/gt) y funcionan sin una cuenta de General Translation si tú mismo proporcionas las traducciones. [`npx gt generate`](/docs/cli/reference/commands/generate) genera un archivo de plantilla por cada configuración regional para que lo traduzcas manualmente. La generación de traducciones con [`gt translate`](/docs/cli/reference/commands/translate) utiliza el servicio alojado de General Translation; consulta [los precios de General Translation](https://generaltranslation.com/pricing).

## Puntos clave

* Puedes implementar i18n sin archivos de traducción: `gt-react` y `gt-next` de General Translation mantienen el texto inline en [`<T>`](/docs/react/reference/components/t) sin claves de traducción, y [`npx gt translate`](/docs/cli/reference/commands/translate) genera un archivo por idioma en cada compilación.
* Los archivos generados son un resultado de la compilación. Nadie los edita ni copia claves de uno a otro, así que se mantienen sincronizados con el código.
* El compilador de General Translation puede envolver JSX en [`<T>`](/docs/react/reference/components/t) en tiempo de compilación, y Locadex puede envolver el código y traducirlo mediante pull requests.
* Si ya usas next-intl o react-i18next, la CLI de `gt` traduce tus catálogos JSON existentes, y el modo diccionario conserva las claves si prefieres seguir usándolas.

## Related questions

- [¿Cómo agrego i18n a una aplicación de Next.js con App Router?](https://generaltranslation.com/es/kb/add-i18n-to-nextjs.mdx): Empieza con gt init para configurar General Translation en un proyecto compatible con App Router; luego marca el contenido de origen, genera las traducciones y verifica el cambio de idioma. gt-next mantiene el texto en JSX junto con el contexto de traducción; la CLI, el editor del panel de control y Locadex se encargan de la generación, la revisión y las actualizaciones continuas. Esta guía también muestra la configuración inicial explícita con archivos locales.
- [¿Cómo internacionalizo una aplicación con Cursor o Claude Code?](https://generaltranslation.com/es/kb/ai-agent-i18n-setup.mdx): Empieza con el prompt Setup for Agents de General Translation en Cursor o Claude Code, elige una funcionalidad y los idiomas de destino, y deja que el agente implemente y verifique el resultado. El inicio de sesión desde el navegador, la documentación legible por máquinas y las herramientas MCP enlazan la configuración inicial con la traducción y la revisión. Usa Locadex para automatizar la localización continua 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.
- [¿Cómo mantengo las traducciones actualizadas en cada despliegue?](https://generaltranslation.com/es/kb/translations-in-ci.mdx): Ejecuta la traducción como un paso del flujo antes de cada compilación de producción, para que el texto nuevo se publique ya traducido en el mismo despliegue que lo incorpora. La CLI gt de General Translation lo hace con npx gt translate, usando una clave de API del proyecto y el ID del proyecto almacenados como secretos de CI.

## Previous and next questions

- Previous question: [¿Cuál es el mejor software de localización para desarrolladores?](https://generaltranslation.com/es/kb/best-localization-software.mdx)
- Next question: [¿Cuál es la mejor biblioteca de i18n para una aplicación React?](https://generaltranslation.com/es/kb/best-react-i18n-library.mdx)

## Sitemap

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