# General Translation Knowledge Base: Alternative a next-intl: gt-next vs. next-intl URL: https://generaltranslation.com/it/kb/next-intl-vs-gt-next.mdx Docs index: https://generaltranslation.com/llms.txt Description: next-intl renderizza le traduzioni che fornisci in un catalogo di messaggi per ciascuna lingua. Anche gt-next renderizza le traduzioni, ma in più General Translation le genera a partire dai testi scritti inline nel tuo JSX. Entrambi sono rilasciati con licenza MIT e supportano l'App Router e i Componenti server. Se i tuoi cataloghi next-intl funzionano già, puoi mantenerli e usare General Translation per tradurli senza alcuna migrazione. Category: Strumenti per il flusso di lavoro Last updated: 2026-10-16 Authors: Jackie Chen Published: 2026-10-16 next-intl e gt-next localizzano entrambi le app Next.js basate sull'App Router, Componenti server inclusi. La differenza sta nell'origine delle traduzioni: next-intl mostra i messaggi che il tuo team o un servizio di traduzione inserisce in un catalogo JSON per ciascuna lingua, mentre gt-next mantiene i testi sorgente inline nel tuo JSX e General Translation genera tutte le traduzioni durante la build. Le opzioni sono quindi tre: mantenere next-intl e il tuo attuale processo di traduzione; mantenere next-intl e affidare a General Translation la traduzione dei suoi cataloghi, senza modificare i tuoi componenti; oppure adottare gt-next per scrivere i testi inline e ottenere traduzioni generate. ## Che differenze ci sono tra next-intl e gt-next? | Domanda | next-intl | gt-next (General Translation) | | ------------------------------------ | -------------------------------------------------------------------------------------------------- | ---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- | | Traduce i tuoi contenuti? | No. Renderizza i messaggi che fornisci tu, scritti dal tuo team o da un servizio come Crowdin | Sì. [`gt translate`](/docs/cli/reference/commands/translate) genera le traduzioni sfruttando il contesto del tuo codice, oppure il tuo team può scriverle | | Dove si trova il testo sorgente? | Messaggi con chiave in un catalogo JSON; l'estrazione inline con `useExtracted` è sperimentale | JSX inline all'interno di [``](/docs/react/reference/components/t) e stringhe tramite [`useGT`](/docs/react/reference/hooks/use-gt); sono supportati anche i dizionari con chiave | | Componenti server? | Sì, con API distinte per componenti sincroni e asincroni | Sì: [``](/docs/react/reference/components/t), [`useGT`](/docs/react/reference/hooks/use-gt) e [`getGT`](/docs/react/nextjs/reference/functions/get-gt) | | Componenti client? | All'interno di `NextIntlClientProvider` | All'interno di [`GTProvider`](/docs/react/reference/components/gt-provider) | | Routing delle impostazioni regionali | Middleware con route precedute dal prefisso dell'impostazione regionale | [`createNextMiddleware`](/docs/react/nextjs/app-router-middleware) con un segmento `app/[locale]` | | Plurali | ICU MessageFormat in ogni catalogo | Rami di [``](/docs/react/reference/components/plural), tradotti insieme al resto del blocco | | Distribuzione delle traduzioni | File di catalogo inclusi nel bundle dell'app | File nel bundle, oppure la CDN di General Translation per aggiornamenti senza dover ridistribuire | | Licenza | MIT | MIT | Fonti: [configurazione dell'App Router di next-intl](https://next-intl.dev/docs/getting-started/app-router), [utilizzo lato server e lato client di next-intl](https://next-intl.dev/docs/environments/server-client-components), [Avvio rapido di gt-next](/docs/react/nextjs-quickstart). ## Come appare la stessa intestazione in ciascuna libreria? Nel flusso di lavoro basato su catalogo di next-intl, il messaggio sorgente risiede in un file JSON: ```json { "Projects": { "heading": "Find your next project" } } ``` Il componente seleziona il messaggio in base al namespace e alla chiave: ```tsx import { useTranslations } from 'next-intl'; export default function ProjectHeading() { const t = useTranslations('Projects'); return

{t('heading')}

; } ``` Con gt-next, la stessa frase resta all'interno del componente: ```tsx import { T } from 'gt-next'; export default function ProjectHeading() { return (

Find your next project

 ); } ``` Entrambi gli snippet presuppongono che il provider e la configurazione di ciascuna libreria siano già impostati. Consulta la [guida alla configurazione di next-intl](https://next-intl.dev/docs/getting-started/app-router) e il [riferimento di ``](/docs/react/reference/components/t). Un catalogo consente ai revisori di leggere i testi separatamente dal codice. Con i testi inline, invece, i revisori vedono ogni frase all'interno del JSX a cui appartiene e General Translation può tradurla usando quella struttura come contesto. Per le formulazioni ancora ambigue, [`` di gt-next accetta una prop `context`](/docs/react/reference/components/t#context), mentre l'[estrazione sperimentale di next-intl supporta le descrizioni dei messaggi](https://next-intl.dev/docs/usage/extraction#descriptions). Anche l'API sperimentale [`useExtracted`](https://next-intl.dev/docs/usage/extraction) di next-intl consente di scrivere i messaggi inline ed estrarli nei cataloghi. L'estrazione cambia il modo in cui si scrivono i testi, ma non traduce i cataloghi estratti, che dovranno comunque essere tradotti dal tuo team o da un servizio esterno. ## Si può usare General Translation senza abbandonare next-intl? Sì. La CLI `gt` rileva next-intl dal tuo `package.json` e [traduce i relativi cataloghi JSON](/docs/cli/guides/generating-translations) preservando la sintassi dei messaggi di next-intl. Componenti, chiamate di traduzione e routing restano invariati. Per provarlo, configura `gt.config.json` in modo che punti ai cataloghi sorgente e di destinazione, importa le traduzioni già esistenti e traduci una nuova impostazione regionale. I revisori possono correggere il risultato nell'[Editor di traduzione della dashboard](/docs/platform/dashboard/guides/reviewing-translations). Se invece modificano i cataloghi scaricati direttamente nel tuo repository, esegui [`gt save-local`](/docs/cli/reference/commands/save-local) prima della successiva esecuzione di traduzione, in modo che quelle modifiche non vadano perse. Se in seguito passi a gt-next, la [guida alla migrazione](/docs/react/guides/migrating-i18n-libraries) spiega come importare le traduzioni revisionate, mantenere i tuoi dizionari e usare entrambe le librerie mentre migri una route alla volta. ## Come gestisce ciascuna libreria i Componenti Server e Client? Nessuna delle due librerie richiede di trasformare una pagina dell'App Router in un Componente client per localizzarla. La differenza sta nell'API da chiamare in ciascun ambiente. | Componente | next-intl | gt-next | | --------------------------- | --------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- | --------------------------------------------------------------------------------------------------------------------------------------------------------------------------- | | Componente server sincrono | [`useTranslations`](https://next-intl.dev/docs/environments/server-client-components#using-internationalization-in-server-components), con la configurazione della richiesta | [``](/docs/react/reference/components/t) per il JSX; [`useGT`](/docs/react/reference/hooks/use-gt) per le stringhe | | Componente server asincrono | Usa `await` su [`getTranslations`](https://next-intl.dev/docs/environments/server-client-components#async-components) da `next-intl/server` | Usa `await` su [`getGT`](/docs/react/nextjs/reference/functions/get-gt) da `gt-next/server`, quindi chiama la funzione restituita | | Componente client | [`useTranslations`](https://next-intl.dev/docs/environments/server-client-components#using-internationalization-in-client-components) all'interno di `NextIntlClientProvider` | [``](/docs/react/reference/components/t) o [`useGT`](/docs/react/reference/hooks/use-gt) all'interno di [`GTProvider`](/docs/react/reference/components/gt-provider) | Con entrambe le librerie, mantieni i controlli interattivi nei componenti client e traduci il resto della pagina sul server. next-intl consente inoltre di [passare etichette già tradotte](https://next-intl.dev/docs/environments/server-client-components#option-1-passing-translated-labels-to-client-components) da un Componente server a un controllo client, così il client non riceve l'intero catalogo. ## Come vengono fornite le traduzioni di gt-next in produzione? gt-next supporta due modalità di consegna: * **Includere le traduzioni nel bundle dell'app** tramite un [loader locale](/docs/react/guides/storing-translations). In produzione l'app legge i propri file di traduzione e non effettua chiamate a General Translation a runtime. Gli aggiornamenti vengono rilasciati con la build successiva. * **Caricare le traduzioni dalla CDN di General Translation** tramite la [configurazione di consegna remota](/docs/react/nextjs/config). Le modifiche pubblicate raggiungono l'app distribuita senza bisogno di una nuova build, in base alle impostazioni di versione e cache. gt-next è [rilasciato con licenza MIT](https://github.com/generaltranslation/gt) e renderizza le traduzioni incluse nel bundle senza bisogno di un account General Translation, esattamente come next-intl renderizza i propri cataloghi. ## Quali team usano gt-next in produzione? General Translation è utilizzato dai team di sviluppo di Cursor, Ramp, Profound, Cognition, Sierra e ClickHouse. Profound usa General Translation per localizzare il suo prodotto principale, un'app Next.js basata su App Router. Consulta le [distribuzioni in produzione](https://generaltranslation.com/enterprise). ## Quando scegliere next-intl o gt-next? **Mantieni next-intl** se il suo modello basato su cataloghi si adatta alla tua app e il tuo processo di traduzione funziona già. Se il problema principale è la gestione ripetitiva delle chiavi, prova la sua estrazione sperimentale prima di migrare. **Mantieni next-intl e aggiungi General Translation** se il collo di bottiglia è la produzione delle traduzioni. La CLI `gt` traduce i tuoi cataloghi esistenti, quindi componenti, chiamate e routing restano invariati. **Scegli gt-next** se vuoi scrivere i testi inline nel JSX e generare le traduzioni a ogni build. Provalo su una singola route che utilizzi Componenti Server e Client, plurali, testo ricco e metadati. Mantieni gli URL localizzati della route e le traduzioni esistenti finché i rispettivi sostituti non sono pronti, e verifica una build di produzione prima di migrare altre route. Per iniziare, segui l'[Avvio rapido per Next.js App Router](/docs/react/nextjs-quickstart). Per confrontare altre librerie, consulta [General Translation vs. i18next, react-intl e next-intl](/kb/general-translation-vs-i18n-libraries). ## Domande frequenti ### next-intl traduce i miei contenuti? No. next-intl renderizza e formatta i messaggi presenti nei tuoi cataloghi. Le traduzioni vengono fornite dal tuo team, da traduttori o da un servizio come [Crowdin](https://next-intl.dev/docs/workflows/localization-management). In alternativa, General Translation può tradurre i cataloghi di next-intl senza richiedere alcuna migrazione. ### Posso usare General Translation con next-intl? Sì. La CLI `gt` traduce i cataloghi JSON di next-intl preservandone la sintassi dei messaggi, quindi puoi mantenere i tuoi componenti e il routing. Consulta [Generare le traduzioni](/docs/cli/guides/generating-translations). ### gt-next è gratuito e open source? Sì. gt-next è distribuito con licenza MIT e renderizza le traduzioni incluse nel bundle senza bisogno di un account. Per generare traduzioni con il servizio in hosting di General Translation, consulta la pagina dei [prezzi](https://generaltranslation.com/pricing). ### gt-next supporta i React Server Components? Sì. Usa [``](/docs/react/reference/components/t) e [`useGT`](/docs/react/reference/hooks/use-gt) nei Componenti server sincroni e [`getGT`](/docs/react/nextjs/reference/functions/get-gt) in quelli asincroni. ### Posso migrare da next-intl a gt-next una route alla volta? Sì. La [guida alla migrazione](/docs/react/guides/migrating-i18n-libraries) spiega come usare entrambe le librerie in parallelo, importare le traduzioni esistenti e continuare a usare i dizionari basati su chiavi dove preferisci. ## Altre alternative a next-intl Per le app Next.js, i team valutano anche queste librerie: * **i18next:** renderizza cataloghi basati su chiavi con selezione del plurale e, insieme a react-i18next e next-i18next, è una scelta diffusa per le app React e Next.js. (Vedi [General Translation vs. i18next](/kb/general-translation-vs-i18next).) * **react-intl:** formatta i messaggi ICU e offre una guida per l'App Router di Next.js. (Vedi [General Translation vs. react-intl](/kb/general-translation-vs-react-intl).) * **Paraglide JS:** compila i cataloghi in funzioni di messaggio tipizzate e tree-shakable, con un'integrazione Next.js per le build webpack. (Vedi [General Translation vs. Paraglide JS](/kb/general-translation-vs-paraglide).) ## Punti chiave * next-intl e gt-next supportano entrambi l'App Router, i Componenti server e il routing delle impostazioni regionali, ed entrambi sono distribuiti con licenza MIT. * next-intl renderizza le traduzioni che fornisci tu. Anche gt-next le renderizza, ma General Translation le genera anche a partire dal JSX inline, usando il tuo codice come contesto. * Non è necessario migrare per usare General Translation: la CLI `gt` traduce i cataloghi next-intl esistenti. * Se decidi di migrare, procedi una route alla volta e mantieni caricate le traduzioni esistenti finché quelle nuove non sono pronte. ## Related questions - [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. - [Come si configura la SEO per un'app Next.js multilingue?](https://generaltranslation.com/it/kb/multilingual-nextjs-seo.mdx): Assegna a ogni lingua un URL dedicato, imposta l'attributo lang del tag html, fai puntare l'URL canonical di ogni pagina alla pagina stessa, aggiungi le alternative hreflang per ogni lingua, traduci titoli e descrizioni ed elenca tutte le versioni linguistiche nella sitemap. - [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 ``, 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. - [Come si gestiscono i plurali in React?](https://generaltranslation.com/it/kb/how-to-handle-plurals-in-react.mdx): Non inserire la logica del plurale direttamente nel codice con controlli come n === 1. Per le app solo in inglese basta un semplice helper, ma le app multilingue richiedono regole del plurale locale-aware, che un componente i18n come `` di gt-react o gt-next gestisce per ogni lingua. ## Previous and next questions - Previous question: [Alternative a Lokalise: General Translation vs. Lokalise](https://generaltranslation.com/it/kb/general-translation-vs-lokalise.mdx) - Next question: [Alternative a Phrase: General Translation vs. Phrase](https://generaltranslation.com/it/kb/general-translation-vs-phrase.mdx) ## Sitemap See the [Knowledge Base sitemap](https://generaltranslation.com/it/kb/sitemap.md) for every article.