# General Translation Knowledge Base: General Translation, Babel e Flask-Babel a confronto: quale scegliere?
URL: https://generaltranslation.com/it/kb/general-translation-vs-flask-babel.mdx
Docs index: https://generaltranslation.com/llms.txt
Description: Babel formatta date, numeri e valute per qualsiasi impostazione regionale e gestisce i cataloghi gettext, mentre Flask-Babel lo integra con Flask, ma nessuno dei due traduce le tue stringhe. La CLI di General Translation popola i file PO di Babel per ogni lingua, forme plurali incluse, così puoi continuare a usare Flask-Babel e smettere di tradurre i cataloghi a mano.
Category: Internazionalizzazione
Last updated: 2026-10-16
Authors: Kevin Wu, Jackie Chen
Published: 2026-10-16

Babel formatta date, numeri e valute sulla base dei dati Unicode CLDR, e il suo comando `pybabel` estrae, aggiorna e compila i cataloghi di messaggi gettext. Flask-Babel integra questi strumenti nella gestione delle richieste di Flask e nei modelli Jinja. General Translation popola i cataloghi tra la fase di estrazione e quella di compilazione: in questo modo la tua app ottiene la traduzione automatica senza rinunciare alla configurazione di Flask-Babel esistente.

## Cosa fanno bene Babel e Flask-Babel

* **Formattazione delle impostazioni regionali basata su CLDR.** [Babel 2.18.0 include i dati di CLDR 47](https://babel.pocoo.org/en/latest/changelog.html#version-2-18-0) per oltre mille identificatori di impostazioni regionali. `format_currency(1234.5, "EUR")` restituisce &quot;1.234,50 €&quot; in spagnolo e `format_date` restituisce &quot;16 października 2026&quot; in polacco.
* **Strumenti per i cataloghi.** [`pybabel extract`](https://babel.pocoo.org/en/latest/cmdline.html) legge file Python e modelli Jinja tramite una mappatura `babel.cfg`, `pybabel init` crea un file PO con la regola del plurale e gli slot corretti (tre per il polacco), `pybabel update` integra le nuove stringhe e contrassegna come fuzzy quelle modificate e `pybabel compile` genera i file `.mo`.
* **Integrazione con Flask.** `locale_selector` e `timezone_selector` [determinano l&#39;impostazione regionale e il fuso orario di ogni richiesta](https://python-babel.github.io/flask-babel/#configuration), `lazy_gettext` gestisce le stringhe definite al momento dell&#39;importazione, i modelli Jinja dispongono di `_()`, `{% trans %}` e di filtri di formattazione, mentre `force_locale` cambia temporaneamente l&#39;impostazione regionale, ad esempio per inviare un&#39;email in un&#39;altra lingua.
* **Stabili e gratuiti.** Entrambi sono distribuiti con licenza BSD (vedi la [licenza di Babel](https://babel.pocoo.org/en/latest/license.html)). Babel funziona in qualsiasi programma Python; la [versione attuale di Flask-Babel è la 4.0.0](https://github.com/python-babel/flask-babel/releases/tag/v4.0.0).

## Cosa Babel e Flask-Babel lasciano a carico tuo

Ecco una piccola app 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` e `pybabel compile` generano un catalogo polacco in cui tutti i `msgstr` sono vuoti. Con Flask-Babel 4.0.0, una richiesta con `Accept-Language: pl` ha poi restituito:

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

Babel formatta la data e il prezzo per il polacco, ma ogni stringa resta in inglese, senza alcun avviso. Ogni stringa resta in attesa che qualcuno compili la relativa voce PO, comprese tutte e tre le forme plurali del polacco, e poi che si esegua `pybabel compile` e una nuova distribuzione. Per ogni stringa nuova o modificata, questo processo va ripetuto in ciascuna lingua.

## Tradurre i cataloghi di Babel con General Translation

Se Flask-Babel fa già al caso tuo, continua a usarlo e lascia che sia la CLI di General Translation a scrivere i cataloghi. Crea una sola volta un catalogo in inglese e aggiornalo dopo ogni estrazione, in modo che la sorgente si trovi nello stesso albero delle traduzioni:

```bash
pybabel extract -F babel.cfg -k lazy_gettext -o messages.pot .
pybabel init -i messages.pot -d translations -l en     # una sola volta
pybabel update -i messages.pot -d translations -l en   # dopo ogni estrazione
```

Quindi fai puntare `gt.config.json` a quel file. Questa config è stata verificata 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 chiave `pot` legge i file PO e POT, mentre `"transformationFormat": "PO"` scrive i file `.po` tradotti (consulta il [riferimento al formato PO / POT](/docs/cli/reference/formats/po-pot-files)). [`customMapping`](/docs/cli/reference/config#custom-mapping) associa la directory `pt_BR` di Babel al codice locale standard `pt-BR`. Configura la [CLI](/docs/cli/quickstart). Se hai già delle traduzioni, importale con [`npx gt upload`](/docs/cli/reference/commands/upload) prima di generarne di nuove. Poi esegui [`npx gt translate`](/docs/cli/reference/commands/translate) e, a seguire, `pybabel compile -d translations`.

General Translation invia ogni voce insieme al relativo `msgctxt`, ai commenti per i traduttori, ai riferimenti all&#39;origine e ai flag, che fungono da contesto. Per le voci plurali, scrive l&#39;intestazione `Plural-Forms` della lingua di destinazione e compila tutti gli slot `msgstr[n]` (per il polacco, ad esempio, tutte e tre le forme), verificando inoltre che i segnaposto come `%(num)d` rimangano intatti. Alla successiva esecuzione, le voci non modificate riutilizzano le traduzioni precedenti. Il Glossario e i prompt personalizzati di un [gruppo di contesto](/docs/platform/dashboard/guides/defining-context-for-translations) garantiscono una terminologia coerente tra i tuoi cataloghi e il resto del prodotto, mentre i revisori possono [modificare ogni voce](/docs/platform/dashboard/guides/reviewing-translations) dalla dashboard. Esegui la CLI in CI, in modo che ogni distribuzione includa cataloghi aggiornati. Prima di generare nuovamente le traduzioni, salva eventuali modifiche locali successive con [`npx gt save-local`](/docs/cli/reference/commands/save-local).

## Babel e Flask-Babel e General Translation a confronto

| Funzionalità                           | Babel e Flask-Babel                                              | General Translation                                                    |
| -------------------------------------- | ---------------------------------------------------------------- | ---------------------------------------------------------------------- |
| Come scrivi le stringhe                | Chiamate `gettext` e `{% trans %}` di Jinja, estratte in file PO | Mantieni quelle chiamate e quei modelli; traduci i cataloghi estratti |
| Traduce i tuoi contenuti               | No                                                               | Sì, con [`npx gt translate`](/docs/cli/reference/commands/translate)   |
| Forme plurali                          | `pybabel init` crea gli slot, che compili uno per uno            | Genera tutti gli slot PO per la lingua di destinazione                 |
| Formattazione di date, numeri e valute | Sì, tramite CLDR                                                 | Mantiene la formattazione di Babel                                     |
| Modelli Jinja                         | Sì                                                               | Traduce i messaggi estratti dai tuoi modelli esistenti                |
| Framework                              | Babel ovunque; Flask-Babel per Flask                             | CLI per cataloghi PO di Flask o di altre applicazioni gettext          |
| Licenza                                | BSD                                                              | CLI con licenza MIT                                                    |
| Costo                                  | Gratuito                                                         | [Traduzione a consumo](https://generaltranslation.com/pricing)         |

## Quando usare l&#39;uno o l&#39;altro

Mantieni il tuo attuale processo di traduzione se i traduttori o un TMS forniscono già i cataloghi di cui hai bisogno. Aggiungi General Translation se vuoi che i messaggi nuovi e modificati vengano tradotti già in fase di sviluppo, con gli strumenti di terminologia e revisione che il tuo team condivide tra i vari progetti. Flask-Babel continua a gestire Jinja, le impostazioni locali della richiesta, le date e le valute, mentre il codice della tua applicazione resta invariato.

## Punti chiave

* Babel formatta date, numeri e valute per qualsiasi impostazione regionale e gestisce i cataloghi gettext, mentre Flask-Babel lo integra in Flask: nessuno dei due, però, traduce le tue stringhe.
* La CLI di General Translation traduce i file PO di Babel tramite la chiave `pot`, `"transformationFormat": "PO"` e `customMapping` per directory come `pt_BR`, compilando tutte le forme plurali previste da ciascuna lingua.
* Mantieni il rendering e la formattazione di Flask-Babel, importa le traduzioni esistenti e inserisci General Translation tra l&#39;estrazione e la compilazione.

## Related questions

- [General Translation vs. GNU gettext: servono entrambi?](https://generaltranslation.com/it/kb/general-translation-vs-gettext.mdx): Mantieni GNU gettext per l'estrazione e il rendering e aggiungi General Translation per generare e mantenere aggiornati i file PO. General Translation tiene conto delle note per i traduttori e del contesto dei messaggi in fase di generazione, applica una terminologia condivisa e mette a disposizione dei revisori un editor nella Dashboard. Le chiamate gettext esistenti e i cataloghi compilati restano al loro posto.
- [General Translation e il framework di traduzione di Django: servono entrambi?](https://generaltranslation.com/it/kb/general-translation-vs-django-i18n.mdx): Usa insieme il framework di traduzione di Django e General Translation. Django si occupa dell'estrazione dei messaggi, della selezione della lingua e del rendering. General Translation compila i suoi file PO, forme plurali comprese, con la terminologia del tuo prodotto e la revisione nella Dashboard. I tuoi template e i modelli di URL restano invariati, mentre le traduzioni si aggiornano di pari passo con il codice.
- [General Translation vs. i18next, react-intl e next-intl: quale libreria i18n scegliere?](https://generaltranslation.com/it/kb/general-translation-vs-i18n-libraries.mdx): Le librerie open source come i18next, react-intl e next-intl non traducono nulla. Si limitano a visualizzare le traduzioni che fornisci in un file di catalogo per ciascuna lingua, scritte da te, dai tuoi traduttori o da un servizio esterno. Anche le librerie di General Translation sono open source e svolgono lo stesso compito, ma General Translation si occupa anche della traduzione, usando il tuo codice come contesto.
- [Perché usare General Translation invece di un TMS (Smartling, Lokalise, Phrase, Crowdin o Transifex)?](https://generaltranslation.com/it/kb/general-translation-vs-tms.mdx): Un sistema di gestione delle traduzioni (TMS) come Smartling, Lokalise, Phrase, Crowdin o Transifex coordina i traduttori, ma gli sviluppatori devono comunque estrarre le stringhe, inviarle, attendere le traduzioni e reintegrarle nel prodotto. General Translation traduce i contenuti direttamente nel tuo codice insieme al loro contesto, distribuisce tutte le lingue a ogni rilascio e si basa su librerie open source, senza vendor lock-in.
- [Posso fare i18n senza file di traduzione?](https://generaltranslation.com/it/kb/i18n-without-translation-files.mdx): Sì. Con gt-react o gt-next, i contenuti restano inline nei tuoi componenti, all'interno di un componente `<T>`, e le traduzioni vengono generate come output in fase di compilazione. Non ci sono quindi chiavi né file JSON per ogni impostazione regionale da scrivere e mantenere sincronizzati.

## Previous and next questions

- Previous question: [General Translation vs. Weblate: quale scegliere?](https://generaltranslation.com/it/kb/general-translation-vs-weblate.mdx)
- Next question: [Perché usare General Translation invece di un TMS (Smartling, Lokalise, Phrase, Crowdin o Transifex)?](https://generaltranslation.com/it/kb/general-translation-vs-tms.mdx)

## Sitemap

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