# General Translation Knowledge Base: General Translation frente a Babel y Flask-Babel: ¿cuál deberías usar?
URL: https://generaltranslation.com/es/kb/general-translation-vs-flask-babel.mdx
Docs index: https://generaltranslation.com/llms.txt
Description: Babel da formato a fechas, números y monedas para cualquier configuración regional y gestiona catálogos de gettext, y Flask-Babel lo integra con Flask, pero ninguno de los dos traduce tus cadenas. La CLI de General Translation rellena los archivos PO de Babel para cada idioma, formas plurales incluidas, para que puedas seguir usando Flask-Babel y dejar de traducir catálogos a mano.
Category: Internacionalización
Last updated: 2026-10-16
Authors: Kevin Wu, Jackie Chen
Published: 2026-10-16

Babel da formato a fechas, números y monedas a partir de los datos de Unicode CLDR, y su comando `pybabel` extrae, actualiza y compila catálogos de mensajes de gettext. Flask-Babel integra esas herramientas con la gestión de solicitudes de Flask y las plantillas de Jinja. General Translation rellena los catálogos entre la extracción y la compilación, de modo que tu aplicación incorpora traducción automatizada sin renunciar a su configuración inicial de Flask-Babel.

## Lo que Babel y Flask-Babel hacen bien

* **Formato por configuración regional basado en CLDR.** [Babel 2.18.0 incluye los datos de CLDR 47](https://babel.pocoo.org/en/latest/changelog.html#version-2-18-0) para más de mil identificadores de configuración regional. `format_currency(1234.5, "EUR")` devuelve «1.234,50 €» en español, y `format_date` devuelve «16 października 2026» en polaco.
* **Herramientas de catálogo.** [`pybabel extract`](https://babel.pocoo.org/en/latest/cmdline.html) lee archivos de Python y plantillas de Jinja mediante un mapeo definido en `babel.cfg`; `pybabel init` crea un archivo PO con la regla de pluralización y las formas plurales adecuadas (tres para el polaco); `pybabel update` fusiona las cadenas nuevas y marca como fuzzy las que han cambiado, y `pybabel compile` genera los archivos `.mo`.
* **Integración con Flask.** Un `locale_selector` y un `timezone_selector` [determinan la configuración regional y la zona horaria de cada solicitud](https://python-babel.github.io/flask-babel/#configuration); `lazy_gettext` cubre las cadenas definidas en tiempo de importación; las plantillas de Jinja disponen de `_()`, `{% trans %}` y filtros de formato, y `force_locale` cambia la configuración regional de forma temporal, por ejemplo, para enviar un correo electrónico en otro idioma.
* **Estables y gratuitos.** Ambos tienen licencia BSD (consulta la [licencia de Babel](https://babel.pocoo.org/en/latest/license.html)). Babel funciona en cualquier programa de Python, y la [versión actual de Flask-Babel es la 4.0.0](https://github.com/python-babel/flask-babel/releases/tag/v4.0.0).

## Lo que Babel y Flask-Babel dejan en tus manos

Aquí tienes una pequeña aplicación con Flask-Babel:

```python title="app.py"
from datetime import date
from flask import Flask, request
from flask_babel import Babel, gettext, ngettext, format_currency, format_date


def select_locale():
    return request.accept_languages.best_match(["en", "es", "pl"])


app = Flask(__name__)
babel = Babel(app, locale_selector=select_locale)


@app.route("/inbox/<int:count>")
def inbox(count):
    return {
        "title": gettext("Inbox"),
        "unread": ngettext("You have %(num)d unread message.", "You have %(num)d unread messages.", count),
        "price": format_currency(1234.5, "EUR"),
        "date": format_date(date(2026, 10, 16), format="long"),
    }
```

`pybabel extract`, `pybabel init -l pl` y `pybabel compile` generan un catálogo en polaco con todos los `msgstr` vacíos. Con Flask-Babel 4.0.0, una solicitud con `Accept-Language: pl` devolvió lo siguiente:

```json title="Output"
{
  "date": "16 października 2026",
  "price": "1 234,50 €",
  "title": "Inbox",
  "unread": "You have 5 unread messages."
}
```

Babel da formato a la fecha y al precio para el polaco, pero todas las cadenas se quedan en inglés, sin ninguna advertencia. Cada cadena tiene que esperar a que alguien complete su entrada en el archivo PO, incluidas las tres formas plurales del polaco, y luego a que se ejecute `pybabel compile` y se vuelva a desplegar. Y con cada cadena nueva o editada, hay que repetir todo el proceso en cada idioma.

## Traducir los catálogos de Babel con General Translation

Si Flask-Babel ya te funciona, sigue usándolo y deja que la CLI de General Translation escriba los catálogos. Crea un catálogo en inglés una sola vez y actualízalo tras cada extracción, para que el origen quede en el mismo árbol que las traducciones:

```bash
pybabel extract -F babel.cfg -k lazy_gettext -o messages.pot .
pybabel init -i messages.pot -d translations -l en     # una sola vez
pybabel update -i messages.pot -d translations -l en   # después de cada extracción
```

Después, haz que `gt.config.json` apunte a él. Esta configuración se comprobó con `gt` 2.26.5:

```json title="gt.config.json"
{
  "defaultLocale": "en",
  "locales": ["es", "pl", "pt_BR"],
  "customMapping": { "pt_BR": { "code": "pt-BR" } },
  "files": {
    "pot": {
      "include": ["translations/[locale]/LC_MESSAGES/messages.po"],
      "transformationFormat": "PO"
    }
  }
}
```

La clave `pot` lee archivos PO y POT, y `"transformationFormat": "PO"` escribe archivos `.po` traducidos (consulta la [referencia del formato PO / POT](/docs/cli/reference/formats/po-pot-files)). [`customMapping`](/docs/cli/reference/config#custom-mapping) asocia el directorio `pt_BR` de Babel con el código de configuración regional estándar `pt-BR`. Configura la [CLI](/docs/cli/quickstart). Si ya tienes traducciones, impórtalas con [`npx gt upload`](/docs/cli/reference/commands/upload) antes de generar otras nuevas. Después, ejecuta [`npx gt translate`](/docs/cli/reference/commands/translate) y, a continuación, `pybabel compile -d translations`.

General Translation envía cada entrada con su `msgctxt`, los comentarios para traductores, las referencias de origen y las opciones como contexto. En las entradas plurales, escribe la cabecera `Plural-Forms` del idioma de destino y rellena todas las formas plurales `msgstr[n]` (por ejemplo, el polaco recibe las tres). Además, comprueba que los marcadores de posición como `%(num)d` se conserven intactos. Las entradas sin cambios reutilizan las traducciones anteriores en la siguiente ejecución. Un glosario y prompts personalizados en un [grupo de contexto](/docs/platform/dashboard/guides/defining-context-for-translations) mantienen la coherencia terminológica entre tus catálogos y el resto de tu producto, y los revisores pueden [editar cada entrada](/docs/platform/dashboard/guides/reviewing-translations) en el panel de control. Ejecuta la CLI en CI para que cada despliegue incluya catálogos actualizados. Si después haces cambios locales, guárdalos con [`npx gt save-local`](/docs/cli/reference/commands/save-local) antes de volver a generar.

## Babel y Flask-Babel frente a General Translation: comparación rápida

| Característica                       | Babel y Flask-Babel                                                    | General Translation                                                    |
| ------------------------------------ | ---------------------------------------------------------------------- | ---------------------------------------------------------------------- |
| Cómo escribes las cadenas            | Llamadas a `gettext` y `{% trans %}` de Jinja, extraídas a archivos PO | Conserva esas llamadas y plantillas; traduce los catálogos extraídos   |
| Traduce tu contenido                 | No                                                                     | Sí, con [`npx gt translate`](/docs/cli/reference/commands/translate)   |
| Formas plurales                      | `pybabel init` crea las formas plurales; tú completas cada una                | Genera todas las formas plurales PO para el idioma de destino                 |
| Formato de fechas, números y monedas | Sí, basado en CLDR                                                     | Conserva el formato de Babel                                           |
| Plantillas de Jinja                  | Sí                                                                     | Traduce los mensajes extraídos de tus plantillas existentes            |
| Frameworks                           | Babel en cualquier entorno; Flask-Babel para Flask                     | CLI para catálogos PO de Flask u otras aplicaciones basadas en gettext |
| Licencia                             | BSD                                                                    | CLI con licencia MIT                                                   |
| Costo                                | Gratuito                                                               | [Traducción con pago por uso](https://generaltranslation.com/pricing)  |

## Cuándo usar cada uno

Mantén tu proceso de traducción actual si los traductores o un TMS ya te entregan los catálogos que necesitas. Añade General Translation si quieres que los mensajes nuevos o modificados se traduzcan durante el desarrollo, con la terminología y las herramientas de revisión que tu equipo comparte entre proyectos. Flask-Babel se sigue encargando de Jinja, las configuraciones regionales de la solicitud, las fechas y las monedas, y el código de tu aplicación no cambia.

## Conclusiones clave

* Babel da formato a fechas, números y monedas para cualquier configuración regional y gestiona catálogos de gettext, y Flask-Babel lo integra en Flask, pero ninguno de los dos traduce tus cadenas.
* La CLI de General Translation traduce los archivos PO de Babel mediante la clave `pot`, `"transformationFormat": "PO"` y `customMapping` para directorios como `pt_BR`, y completa todas las formas plurales de cada idioma.
* Mantén el renderizado y el formato de Flask-Babel, importa tus traducciones existentes e incorpora General Translation entre la extracción y la compilación.

## Related questions

- [General Translation frente a GNU gettext: ¿necesitas ambos?](https://generaltranslation.com/es/kb/general-translation-vs-gettext.mdx): Conserva GNU gettext para la extracción y el renderizado, y añade General Translation para generar y mantener los archivos PO. General Translation incorpora las notas para traductores y el contexto de los mensajes en la generación, aplica una terminología compartida y ofrece a los revisores un editor en el panel de control. Tus llamadas actuales a gettext y tus catálogos compilados siguen como están.
- [General Translation frente al framework de traducción de Django: ¿necesitas ambos?](https://generaltranslation.com/es/kb/general-translation-vs-django-i18n.mdx): Usa el framework de traducción de Django y General Translation de forma conjunta. Django se encarga de la extracción de mensajes, la selección del idioma y el renderizado. General Translation rellena sus archivos PO, incluidas las formas plurales, con la terminología de tu producto y la revisión en el panel de control. Tus plantillas y patrones de URL siguen igual, y las traducciones se actualizan a la par que tu código.
- [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.
- [¿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.
- [¿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: [Alternativas a Transifex: General Translation vs. Transifex](https://generaltranslation.com/es/kb/general-translation-vs-transifex.mdx)
- Next question: [General Translation frente a GNU gettext: ¿necesitas ambos?](https://generaltranslation.com/es/kb/general-translation-vs-gettext.mdx)

## Sitemap

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