# General Translation Knowledge Base: General Translation vs. i18next, react-intl e next-intl: quale libreria i18n scegliere? URL: https://generaltranslation.com/it/kb/general-translation-vs-i18n-libraries.mdx Docs index: https://generaltranslation.com/llms.txt Description: 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. Category: Internazionalizzazione Last updated: 2026-10-16 Authors: General Translation Team Published: 2026-10-16 Una libreria di internazionalizzazione (i18n) svolge due compiti durante l'esecuzione dell'app: seleziona il messaggio corrispondente all'impostazione regionale dell'utente e formatta plurali, date e numeri secondo quella stessa impostazione regionale. Le librerie open source come i18next, react-intl, next-intl, Lingui e vue-i18n si occupano di entrambi, ma nessuna traduce i tuoi contenuti. Questo lavoro resta a tuo carico, prima che l'app venga eseguita: inserire ogni stringa in un file di catalogo, tramite chiave o estraendo i messaggi inline, far tradurre ogni catalogo e tenerli tutti aggiornati man mano che la UI cambia. Le librerie di General Translation svolgono gli stessi compiti a run-time, ma in più General Translation si occupa anche della traduzione: i testi restano inline nei tuoi componenti e le traduzioni vengono generate durante la build. ## Cosa fanno bene le librerie consolidate Ognuna di queste librerie è matura, gratuita e ampiamente utilizzata, e ciascuna ha un proprio punto di forza: * **i18next** è la più scaricata. Funziona in qualsiasi ambiente JavaScript e la CLI ufficiale `i18next-cli` estrae le chiavi dal codice e genera i relativi tipi TypeScript. * **react-intl** (FormatJS) si basa su ICU MessageFormat, la sintassi standard per plurali e selezioni. La sua documentazione consiglia di scrivere ogni `defaultMessage` inline, accompagnato da una `description` per i traduttori, e di raccoglierli poi in un catalogo con `formatjs extract`. * **next-intl** è pensata per l'App Router di Next.js. Le sue traduzioni funzionano nei Componenti server, i messaggi usati solo dai Componenti server possono essere esclusi dal client e le chiavi dei messaggi supportano il controllo dei tipi. La sua API per i messaggi inline, introdotta nella versione 4.5, è ancora contrassegnata come sperimentale. * **Lingui** mantiene il testo di origine inline tramite macro come ``, genera automaticamente gli ID dei messaggi ed estrae i messaggi in cataloghi PO. * **vue-i18n** è il plugin i18n per Vue 3, con i messaggi in JSON, YAML o in blocchi `` all'interno dei single-file component. Tutte conservano le traduzioni in formati di catalogo, come JSON e PO, con cui traduttori e sistemi di gestione delle traduzioni (TMS) lavorano già abitualmente. ## Cosa resta a carico tuo Nessuna di queste librerie traduce nulla. Le traduzioni arrivano da te, dai tuoi traduttori o da un servizio esterno, come Locize del team di i18next o un TMS come Crowdin. Ecco un piccolo componente per la posta in arrivo con react-i18next: ```json title="locales/en/translation.json" { "inbox": { "title": "Inbox", "unread_one": "You have {{count}} unread message.", "unread_other": "You have {{count}} unread messages." } } ``` ```tsx title="Inbox.tsx" import { useTranslation } from 'react-i18next'; export function Inbox({ count }: { count: number }) { const { t } = useTranslation(); return (

{t('inbox.title')}

{t('inbox.unread', { count })}

); } ``` Ogni altra lingua richiede poi un proprio file, come `locales/es/translation.json`, scritto a mano o affidato a un traduttore. Ogni file deve inoltre contenere le forme plurali della propria lingua come chiavi separate: il giapponese ne usa una, il polacco quattro e l'arabo sei (`_zero`, `_one`, `_two`, `_few`, `_many` e `_other`). Una stringa aggiunta al componente resta assente da tutti gli altri file finché qualcuno non la inserisce, e chi traduce il catalogo vede `inbox.unread_other` e una frase, non la schermata in cui compare. ## General Translation fa lo stesso, e in più genera le traduzioni Le librerie di General Translation svolgono lo stesso lavoro di i18next, react-intl e next-intl. Selezionano i messaggi corretti per ogni impostazione regionale, ne applicano le regole del plurale e formattano numeri, valute e date con [``](/docs/react/reference/components/num), [``](/docs/react/reference/components/currency) e [``](/docs/react/reference/components/datetime). Gestiscono le variabili ICU-style nelle stringhe di [`useGT`](/docs/react/reference/hooks/use-gt), i dizionari basati su chiavi tramite [`useTranslations`](/docs/react/reference/hooks/use-translations) per i team che preferiscono usare le chiavi e, in `gt-next`, un URL dedicato per ogni impostazione regionale. Inoltre, General Translation fa ciò che le altre librerie non fanno: genera le traduzioni. Ecco la stessa inbox realizzata con `gt-react`. I testi restano nel componente, [``](/docs/react/reference/components/t) contrassegna il JSX da tradurre e [``](/docs/react/reference/components/plural) contiene le forme in inglese: ```tsx title="Inbox.tsx" import { T, Plural, Num } from 'gt-react'; export function Inbox({ count }: { count: number }) { return (

Inbox

You have {count} unread message.

} other={

You have {count} unread messages.

} />
); } ``` Eseguendo [`npx gt translate`](/docs/cli/reference/commands/translate) prima della build, ogni blocco [``](/docs/react/reference/components/t) viene inviato, insieme alla sua struttura di elementi, all'API di General Translation, che genera una traduzione per ogni impostazione regionale di destinazione. Tu scrivi le forme plurali previste dall'inglese, mentre la traduzione genera quelle richieste da ciascuna lingua di destinazione, come `few` e `many` del polacco. [``](/docs/react/reference/components/plural) sceglie poi un ramo tradotto in base alle regole del plurale dell'impostazione regionale del lettore. [``](/docs/react/reference/components/num) formatta il conteggio secondo l'impostazione regionale del lettore al momento del rendering, mentre un valore racchiuso in [``](/docs/react/reference/components/var) non viene mai inviato all'API. Se modifichi la frase, l'esecuzione successiva la traduce di nuovo; se elimini il componente, le relative traduzioni vengono rimosse insieme a esso. Le librerie di General Translation supportano Next.js (`gt-next`), React (`gt-react`), Vue 3 (`gt-vue`) e Node.js (`gt-node`), oltre a librerie sperimentali per React Native, TanStack Start e per Flask e FastAPI in Python. Sono distribuite con licenza MIT e funzionano anche senza un account General Translation: caricano le traduzioni da qualsiasi sorgente, e [`gt generate`](/docs/cli/reference/commands/generate) genera file template per i team che traducono manualmente. `gt-react` e `gt-next` non si basano su nessun'altra libreria i18n, perché il parsing e la formattazione dei messaggi ICU sono gestiti da pacchetti proprietari di General Translation. Per impostazione predefinita, le traduzioni vengono incluse come file nella build, ma possono anche essere caricate dalla CDN di General Translation. ## Confronto tra le librerie | Libreria | Come scrivi i testi | Traduce i tuoi contenuti? | Da dove provengono le traduzioni | Plurali | | ----------------------------------------------------------------- | ---------------------------------------------------------------------------------------------------------------------------------------- | ------------------------- | ------------------------------------------------------------------------------------------------------------------------------------------- | ----------------------------------------------------------------------------------------------------------------------------------------- | | [i18next](/kb/general-translation-vs-i18next) con `react-i18next` | Chiavi in un file JSON per ogni impostazione regionale | No | Da te, dai traduttori o da un servizio come Locize | Una chiave per ogni forma plurale | | [`react-intl`](/kb/general-translation-vs-react-intl) (FormatJS) | Testo `defaultMessage` inline, estratto in un catalogo JSON | No | Da te, dai traduttori o da un TMS | ICU MessageFormat | | `next-intl` | Chiavi in un file JSON per ogni impostazione regionale | No | Da te, dai traduttori o da un TMS come Crowdin | ICU MessageFormat | | [Lingui](/kb/general-translation-vs-lingui) | Macro inline, estratte in cataloghi PO | No | Da te, dai traduttori o da un TMS come Crowdin | ICU MessageFormat | | [`vue-i18n`](/kb/general-translation-vs-vue-i18n) | Chiavi in oggetti di messaggi per ogni impostazione regionale | No | Da te, dai traduttori o da un TMS | Forme separate da una barra verticale; la versione 11 richiede una regola personalizzata per lingue come il polacco | | General Translation (`gt-react`, `gt-next`, `gt-vue`) | JSX all'interno di [``](/docs/react/reference/components/t) oppure stringhe tramite [`useGT`](/docs/react/reference/hooks/use-gt) | Sì | Generate da [`npx gt translate`](/docs/cli/reference/commands/translate) sfruttando il contesto del tuo codice, oppure scritte dal tuo team | Rami di [``](/docs/react/reference/components/plural); la traduzione genera le forme richieste da ciascuna lingua di destinazione | Continua a usare i18next, react-intl, next-intl, Lingui o vue-i18n se i tuoi cataloghi e il tuo processo di traduzione funzionano già, se i traduttori o un TMS lavorano con file di catalogo, oppure se il tuo framework non è supportato dalle librerie di General Translation. Scegli le librerie di General Translation se vuoi che i testi restino leggibili direttamente nei componenti, che le traduzioni vengano generate tenendo conto del contesto del codice e che tutte le lingue siano aggiornate a ogni build, senza dover attendere un ciclo di traduzione. ## Mantieni la tua libreria o migra una route alla volta Cambiare libreria è facoltativo. La CLI `gt` rileva `next-intl` o `i18next` dal tuo `package.json` e ne traduce i file JSON mantenendo la sintassi dei messaggi. Sono supportati anche i progetti `react-i18next` e `next-i18next`, purché `i18next` sia una dipendenza diretta. Indica in `gt.config.json` il percorso dei tuoi cataloghi: ```json title="gt.config.json" { "defaultLocale": "en", "locales": ["es", "fr", "ja"], "files": { "json": { "include": ["locales/[locale]/*.json"] } } } ``` Per fornire a una chiave il contesto che il suo testo non riesce a trasmettere, aggiungi un file associato come `locales/en/translation.metadata.json` con una voce `context` o `maxChars` per quella chiave. (Consulta [Metadati associati alle chiavi](/docs/cli/reference/keyed-metadata) e [Generazione delle traduzioni](/docs/cli/guides/generating-translations).) Per passare a [``](/docs/react/reference/components/t), segui la guida [Migrazione da altre librerie i18n](/docs/react/guides/migrating-i18n-libraries), che illustra tre percorsi: sostituire le ricerche per chiave con testo inline, mantenere i tuoi dizionari e chiamare [`useTranslations`](/docs/react/reference/hooks/use-translations), oppure usare entrambe le librerie in parallelo migrando una route alla volta. General Translation è scelto dai migliori team di sviluppo al mondo, tra cui quelli di Cursor, Ramp, Profound, Cognition, Sierra e ClickHouse. Per provarlo sulla tua app, inizia con l'[Avvio rapido per Next.js](/docs/react/nextjs-quickstart), la [Guida rapida a React](/docs/react/react-quickstart) o l'[Avvio rapido per Vue](/docs/vue/quickstart). ## Punti chiave * i18next, react-intl, next-intl e le altre librerie i18n open source non traducono nulla: si limitano a renderizzare e formattare traduzioni che devi produrre e tenere aggiornate tu stesso. * Le librerie di General Translation svolgono lo stesso lavoro di rendering e formattazione e sono anch'esse open source con licenza MIT, ma General Translation si occupa anche della traduzione, a partire dai testi scritti inline in [``](/docs/react/reference/components/t), quindi non ci sono chiavi né cataloghi da mantenere sincronizzati. * Puoi continuare a usare i18next o next-intl e affidarti alla CLI `gt` per tradurne i file JSON, oppure migrare una route alla volta. ## Related questions - [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. - [Alternative a Google Translate: General Translation vs. Google Translate](https://generaltranslation.com/it/kb/general-translation-vs-google-translate.mdx): Google Translate è un modo rapido per tradurre testi occasionali, ma pubblicare un prodotto in un'altra lingua richiede anche che ogni stringa sia tradotta nel suo contesto, con termini coerenti, variabili e plurali corretti, una revisione e un processo di rilascio. General Translation comprende il contesto di ogni stringa nel tuo codice e automatizza l'intero flusso di lavoro di localizzazione, dal codice alla revisione fino a ogni rilascio. - [Alternative a i18next: General Translation vs. i18next](https://generaltranslation.com/it/kb/general-translation-vs-i18next.mdx): Scegli General Translation per mantenere i testi inline nei componenti React e generare le traduzioni sfruttando la struttura JSX e il contesto del prodotto. In alternativa, puoi continuare a usare i18next e affidarti a General Translation per tradurre i cataloghi esistenti. i18next si occupa del rendering dei messaggi e della selezione dei plurali, mentre la generazione delle traduzioni è affidata a un servizio separato. - [Alternative a react-intl: General Translation o react-intl](https://generaltranslation.com/it/kb/general-translation-vs-react-intl.mdx): General Translation consente ai team React di mantenere la sintassi dei messaggi ICU, aggiungendo la generazione delle traduzioni, una terminologia condivisa e la revisione nella Dashboard. react-intl fornisce la formattazione e gli strumenti di FormatJS per la gestione dei cataloghi; General Translation, invece, produce anche le traduzioni. - [General Translation vs. vue-i18n: quale scegliere?](https://generaltranslation.com/it/kb/general-translation-vs-vue-i18n.mdx): General Translation consente ai team Vue di scrivere il testo sorgente direttamente nei modelli e di generare le traduzioni con la CLI. Il suo plugin gt-vue renderizza questi contenuti con una formattazione locale-aware di plurali e numeri. Sceglilo per eliminare la manutenzione dei file sorgente basati su chiavi; vue-i18n resta una scelta valida per i team che usano il modulo i18n di Nuxt e un flusso di lavoro consolidato basato su cataloghi. ## Previous and next questions - Previous question: [General Translation vs. i18n-tasks: quale scegliere?](https://generaltranslation.com/it/kb/general-translation-vs-i18n-tasks.mdx) - Next question: [General Translation vs. Locize: quale scegliere?](https://generaltranslation.com/it/kb/general-translation-vs-locize.mdx) ## Sitemap See the [Knowledge Base sitemap](https://generaltranslation.com/it/kb/sitemap.md) for every article.