# General Translation Knowledge Base: ¿Cómo migro de Lokalise a General Translation?
URL: https://generaltranslation.com/es/kb/migrate-from-lokalise.mdx
Docs index: https://generaltranslation.com/llms.txt
Description: Conserva tus archivos de recursos, tu biblioteca de i18n y tus traducciones revisadas. Exporta desde Lokalise sin traducciones vacías, desactiva su sincronización con GitHub e importa los archivos con npx gt upload antes del primer npx gt translate. A partir de ahí, General Translation traduce las cadenas nuevas y modificadas durante la compilación, con tu glosario en un grupo de contexto y las descripciones de las claves como contexto por clave.
Category: Herramientas para flujos de trabajo
Last updated: 2026-11-12
Authors: Kevin Wu
Published: 2026-11-12

Lokalise almacena tus cadenas como claves dentro de un proyecto, genera archivos de recursos para cada plataforma al exportar y los sincroniza con tu repositorio. Al pasarte a General Translation, conservas los archivos de recursos que tu aplicación ya lee: la CLI `gt` los importa junto con tus traducciones existentes y, a partir de ahí, traduce las cadenas nuevas y modificadas durante la compilación o en CI. Tu biblioteca de i18n y tus claves no cambian; mover los textos inline es un paso aparte y opcional (consulta [cómo migrar desde react-i18next](/kb/migrate-from-react-i18next) o [desde next-intl](/kb/migrate-from-next-intl)). Tu glosario pasa a ser un grupo de contexto que pueden compartir tu aplicación, tu documentación y otros proyectos.

## ¿Qué se conserva al migrar desde Lokalise?

| En Lokalise                                          | En General Translation                                                                                                                                                                              |
| ---------------------------------------------------- | --------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
| Claves exportadas como archivos para cada plataforma | Los mismos archivos, indicados en `files` dentro de `gt.config.json`                                                                                                                                |
| Traducciones                                         | Se importan con [`npx gt upload`](/docs/cli/reference/commands/upload) y se conservan hasta que cambie su origen                                                                                    |
| Glosario                                             | Un glosario de [grupo de contexto](/docs/platform/dashboard/guides/defining-context-for-translations), importado desde CSV                                                                          |
| Guías de estilo para Pro AI                          | [Prompts personalizados](/docs/platform/dashboard/guides/defining-context-for-translations), globales o por configuración regional                                                                  |
| Descripciones de claves y límites de caracteres      | Comentarios en los archivos de iOS y Android, que General Translation interpreta como contexto, o un archivo de [metadatos asociados a claves](/docs/cli/reference/keyed-metadata) para JSON y YAML |
| Memoria de traducción                                | Las traducciones que hayas subido: las cadenas sin cambios las conservan y solo se traducen las cadenas nuevas o modificadas. Los archivos TMX no se importan                                       |
| GitHub App, auto-pull y GitHub Actions               | [`npx gt translate`](/docs/cli/reference/commands/translate) en CI, o pull requests de [Locadex](/docs/platform/locadex/quickstart)                                                                 |
| Tareas de revisión                                   | Edición en el [panel de control](/docs/platform/dashboard/guides/reviewing-translations), con aprobación en el Plan empresarial                                                                     |
| SDK over-the-air para iOS, Android y Flutter         | Las traducciones se incluyen en tus archivos de recursos con cada lanzamiento de la app                                                                                                             |

La CLI lee JSON, YAML, `.pot` y `.po`, `.strings`, `.stringsdict` y `.xcstrings` de iOS, `strings.xml` de Android, `.resx`, HTML, Markdown y MDX, entre otros. (Consulta los [formatos compatibles](/docs/cli/reference/config#files)). No lee XLIFF, ARB, `.properties` de Java ni exportaciones en CSV o XLSX, así que elige un formato compatible al descargar.

## Paso 1: Exporta un archivo por idioma

Lokalise no conserva tus archivos originales, sino que los genera a partir de las claves en cada exportación. Si tu repositorio ya contiene archivos sincronizados por Lokalise, exporta con la misma configuración para que el resultado coincida y revisa el diff con respecto al repositorio antes de importar.

Con la [CLI `lokalise2`](https://github.com/lokalise/lokalise-cli-2-go/blob/master/docs/lokalise2_file_download.md), la exportación JSON de una aplicación web tiene este aspecto:

```bash
lokalise2 --token "$LOKALISE_TOKEN" --project-id "$LOKALISE_PROJECT_ID" file download \
  --format json \
  --original-filenames=false \
  --bundle-structure "locales/%LANG_ISO%/common.json" \
  --unzip-to . \
  --export-empty-as skip \
  --filter-data nonhidden \
  --async
```

Para que la importación sea limpia, hay cuatro opciones clave:

* **`--export-empty-as skip`.** De forma predeterminada, Lokalise exporta las claves sin traducir como cadenas vacías, y `base` las rellena con el texto de origen. En ambos casos, se importarían como traducciones. `skip` las excluye.
* **Formatos de plurales y marcadores de posición.** Usa los que lea tu biblioteca: `--plural-format i18next_v4` para las claves `_one` y `_other` de i18next, o `--plural-format icu --placeholder-format icu` para next-intl. (Consulta los [formatos de plurales y marcadores de posición](https://developers.lokalise.com/reference/api-plurals-and-placeholders) de Lokalise).
* **Plataformas.** Cada clave pertenece a una o varias plataformas, y una exportación solo incluye las claves de la plataforma correspondiente a su formato. Haz una exportación por plataforma: `--format strings` y `stringsdict` para iOS, y `--format xml` para Android.
* **`--async`.** La descarga síncrona de Lokalise solo admite proyectos de menos de 10.000 pares clave-idioma; para proyectos más grandes se necesita la asíncrona.

Si no usas la CLI, abre la página **Download** del proyecto, elige el formato, establece **Empty translations** en skip y haz clic en **Build and download**. Para descargar se necesita el permiso de colaborador **Download files**.

Revisa los códigos de configuración regional en los nombres de las carpetas. Lokalise usa sus propios códigos de idioma, como `en_GB`, que la CLI compara de forma exacta con tu lista `locales`. Para reemplazar un código, haz clic en él en la página **Download** o usa `--language-mapping`; también puedes indicar los códigos tal como se exportan en `gt.config.json`.

## Paso 2: Detén la sincronización de Lokalise

Antes de que General Translation escriba ningún archivo, desactiva todas las vías que escriben traducciones en tu repositorio:

* Elimina el webhook de extracción automática (auto-pull) de Lokalise en la configuración de tu repositorio de GitHub.
* Deja de usar el disparador de GitHub en las descargas, que abre pull requests desde una rama nueva.
* Elimina o desactiva los flujos de trabajo que usan las GitHub Actions de push y pull de Lokalise.

Las aplicaciones de GitLab, Bitbucket y Azure DevOps funcionan igual. Si dos herramientas escriben en los mismos archivos, prevalecen los cambios de la que escriba en último lugar.

## Paso 3: Indica a la CLI dónde están los archivos

Instala la CLI de `gt` y describe los archivos exportados en `gt.config.json`:

```json title="gt.config.json"
{
  "defaultLocale": "en",
  "locales": ["de", "fr", "pt-BR"],
  "files": {
    "json": { "include": ["locales/[locale]/*.json"] }
  }
}
```

La CLI lee la sintaxis de mensajes de i18next y next-intl en los archivos JSON cuando encuentra `i18next` o `next-intl` en tu `package.json`, y trata los demás valores JSON como cadenas simples. (Consulta [Archivos JSON](/docs/cli/reference/formats/json-files)).

Inicia sesión con [`npx gt login`](/docs/cli/reference/commands/login) y define `GT_PROJECT_ID`, o bien define `projectId` en la configuración. En CI, usa `GT_API_KEY` con una clave de API del proyecto que tenga los permisos **Archivos &gt; Escritura**, **Cola de traducción &gt; Habilitada** y **Contexto &gt; Escritura**.

## Paso 4: Traslada tu glosario y el contexto de las claves

En la página [glosario](https://docs.lokalise.com/en/articles/1400629-glossary) de Lokalise, usa **More &gt; Download CSV** para exportar todos los términos con sus traducciones. El archivo usa punto y coma como separador y tiene una columna por idioma, como `de_DE`. Conserva `term`, cambia el nombre de `description` a `definition` y el de cada columna de idioma a `translation_<locale>` (por ejemplo, `translation_de`), elimina las demás columnas y guarda el archivo separado por comas. El importador de General Translation lee ese layout directamente e interpreta cualquier otro layout con IA. En el panel de control, crea un [grupo de contexto](/docs/platform/dashboard/guides/defining-context-for-translations), haz clic en **Import**, selecciona el archivo y asigna el grupo a tu proyecto antes de la primera ejecución de traducción, para que las nuevas traducciones usen tu terminología desde el principio.

Las descripciones de las claves le indican al traductor qué significa una cadena. Las exportaciones `.strings` de iOS y `strings.xml` de Android las incluyen como comentarios de forma predeterminada, y General Translation envía esos comentarios como contexto. En el caso de JSON, obtén la descripción y el límite de caracteres de cada clave con `lokalise2 key list` o a partir de una exportación [`json_structured`](https://docs.lokalise.com/en/articles/3229161-structured-json) de tu idioma de origen guardada fuera de las carpetas indicadas en `gt.config.json`, y escríbelos en un archivo de [metadatos asociados a claves](/docs/cli/reference/keyed-metadata) junto al archivo de origen:

```json title="locales/en/common.metadata.json"
{
  "checkout": {
    "save": { "context": "Button that saves the shipping address", "maxChars": 12 }
  }
}
```

Recrea tus guías de estilo de Pro AI como [prompts personalizados](/docs/platform/dashboard/guides/defining-context-for-translations). Si tu plan incluye la gestión de memoria de traducción, un administrador del equipo puede guardar una copia de seguridad con **Download as TMX file** en **Team settings &gt; Translation memory**.

## Paso 5: Sube los archivos antes de traducir

Primero, ejecuta [`npx gt upload`](/docs/cli/reference/commands/upload). Este comando envía cada archivo de origen junto con su archivo traducido correspondiente para cada configuración regional, y guarda esas traducciones como completadas:

```bash
npx gt upload
npx gt translate
```

A continuación, [`npx gt translate`](/docs/cli/reference/commands/translate) traduce solo lo que falta, como una nueva configuración regional o un archivo sin traducir, y escribe los resultados en las mismas rutas. Si ejecutas [`npx gt translate`](/docs/cli/reference/commands/translate) antes de [`npx gt upload`](/docs/cli/reference/commands/upload), se generan nuevas traducciones que sobrescriben los archivos exportados. General Translation traducirá las claves que Lokalise no había traducido la próxima vez que cambie su archivo de origen. Si quieres publicarlas antes, termina de traducirlas en Lokalise antes de exportar.

## Paso 6: Traduce automáticamente el texto nuevo

A partir de ahora, ejecuta [`npx gt translate`](/docs/cli/reference/commands/translate) en tu [compilación o CI](/kb/translations-in-ci), o deja que [Locadex](/docs/platform/locadex/quickstart) abra pull requests con las traducciones. Haz commit de `gt-lock.json`, que registra las traducciones que la CLI ya ha escrito para que no vuelva a descargarlas. Si tu equipo edita archivos traducidos en el repositorio, ejecuta [`npx gt save-local`](/docs/cli/reference/commands/save-local) antes de la siguiente traducción para que esos cambios se conserven.

## ¿Cuándo conviene seguir con Lokalise?

Sigue con Lokalise si tus aplicaciones móviles nativas dependen de actualizaciones de cadenas over-the-air (OTA), si tus diseñadores trabajan con el plugin de Figma y con capturas de pantalla, si encargas traducciones profesionales desde la misma herramienta o si tu flujo intercambia archivos XLIFF o ARB. (Consulta [General Translation vs. Lokalise](/kb/general-translation-vs-lokalise)).

## Preguntas frecuentes

### ¿Perderé mis traducciones revisadas?

No, siempre que omitas las traducciones vacías al exportar y ejecutes [`npx gt upload`](/docs/cli/reference/commands/upload) antes de [`npx gt translate`](/docs/cli/reference/commands/translate). Las traducciones subidas se mantienen intactas hasta que cambie su texto de origen, y tu equipo puede corregir cualquier traducción en el [panel de control](/docs/platform/dashboard/guides/reviewing-translations).

### ¿Qué pasa con las capturas de pantalla?

Se quedan en Lokalise. Para no perder la información que aportaban a los traductores, describe dónde aparece cada cadena en el contexto de su clave (paso 4).

## Puntos clave

* Exporta un archivo por idioma y plataforma con `--export-empty-as skip`, usando el mismo formato de plurales que ya lee tu app.
* Elimina el webhook, los disparadores y las Actions de Lokalise antes de que General Translation escriba en esos mismos archivos.
* Importa el glosario a un grupo de contexto y traslada las descripciones de las claves como contexto por clave antes de traducir.
* Ejecuta [`npx gt upload`](/docs/cli/reference/commands/upload) antes del primer [`npx gt translate`](/docs/cli/reference/commands/translate) y, a partir de ahí, traduce el texto nuevo durante la compilación o con Locadex.

## Related questions

- [Alternativas a Lokalise: General Translation vs. Lokalise](https://generaltranslation.com/es/kb/general-translation-vs-lokalise.mdx): General Translation es una sólida alternativa a Lokalise para equipos que quieren textos legibles en JSX y la traducción integrada en el desarrollo. Lokalise se basa en claves compartidas, integraciones con herramientas de diseño y entrega over-the-air para aplicaciones móviles. General Translation genera traducciones a partir del contenido marcado en la aplicación y permite revisarlas en su panel de control o en pull requests de GitHub.
- [¿Cómo migro de Crowdin a General Translation?](https://generaltranslation.com/es/kb/migrate-from-crowdin.mdx): Conserva tus archivos de recursos, tu biblioteca de i18n y tus traducciones revisadas. Activa Skip untranslated strings, descarga tus traducciones, impide que la integración de Git de Crowdin envíe traducciones e importa los archivos con npx gt upload antes del primer npx gt translate. A partir de ahí, General Translation traduce las cadenas nuevas y modificadas durante la compilación, usando tu glosario desde un grupo de contexto.
- [¿Cómo migro de Phrase a General Translation?](https://generaltranslation.com/es/kb/migrate-from-phrase.mdx): Conserva tus archivos de configuración regional, tu biblioteca de i18n y tus traducciones verificadas. Descarga los archivos desde Phrase Strings sin claves sin traducir ni alternativas de respaldo, desactiva Repo Sync e impórtalos con npx gt upload antes de ejecutar npx gt translate por primera vez. A partir de ahí, General Translation traduce las cadenas nuevas y modificadas durante la compilación, con tu base terminológica en un grupo de contexto y las descripciones de las claves como contexto de cada clave.
- [¿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.
- [¿Qué es la memoria de traducción y sigue siendo necesaria con la IA?](https://generaltranslation.com/es/kb/what-is-translation-memory.mdx): La memoria de traducción (TM) es una base de datos de pares de segmentos de origen y destino ya traducidos en la que una herramienta de traducción busca coincidencias exactas, en contexto y aproximadas. Con la IA, sigue siendo conveniente reutilizar la redacción aprobada y tener las traducciones anteriores disponibles como contexto. General Translation reutiliza las traducciones coincidentes de versiones anteriores de los archivos y conserva las ediciones del equipo, sin necesidad de mantener una TM aparte.

## Previous and next questions

- Previous question: [¿Cómo migro de Crowdin a General Translation?](https://generaltranslation.com/es/kb/migrate-from-crowdin.mdx)
- Next question: [¿Cómo migro de Phrase a General Translation?](https://generaltranslation.com/es/kb/migrate-from-phrase.mdx)

## Sitemap

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