# General Translation Knowledge Base: General Translation o Intlayer: quale scegliere? URL: https://generaltranslation.com/it/kb/general-translation-vs-intlayer.mdx Docs index: https://generaltranslation.com/llms.txt Description: Intlayer conserva il contenuto di ogni componente in un file di dichiarazione tipizzato posto accanto al componente stesso, con tutte le lingue scritte una accanto all'altra, e può completare le lingue mancanti con un provider di IA da te configurato. General Translation mantiene i testi inline nei componenti in un'unica lingua e genera le altre lingue sfruttando il contesto del tuo codice. Category: Internazionalizzazione Last updated: 2026-10-16 Authors: Kevin Wu, Jackie Chen Published: 2026-10-16 Intlayer è una [libreria i18n open source](https://github.com/aymericzip/intlayer) che colloca il contenuto in un file di dichiarazione accanto a ciascun componente, ad esempio `inbox.content.ts`, in cui ogni stringa elenca le proprie traduzioni in un'unica chiamata `t({ en, es, pl })`. Un hook come `useIntlayer('inbox')` restituisce quel contenuto, tipizzato, nell'impostazione regionale corrente. Intlayer completa le lingue mancanti con un provider di IA da te configurato e offre un editor visuale gratuito e un CMS ospitato facoltativo, ma ogni lingua di ogni stringa continua a risiedere nei tuoi file sorgente, e sta a te scriverla, completarla e revisionarla. General Translation segue la strada opposta: scrivi i testi una sola volta, inline, nella lingua di origine, e General Translation genera le altre lingue sfruttando il contesto del tuo codice. ## Cosa fa bene Intlayer * **Contenuti accanto al componente.** Un file di dichiarazione per ogni componente mantiene il testo vicino al codice che lo renderizza. * **Sicurezza dei tipi.** Le chiavi di `useIntlayer` sono tipizzate: nella versione 9.7.0, `useIntlayer('inbx')` genera un errore TypeScript. Viene segnalata anche una chiamata `t()` a cui manca una delle impostazioni regionali configurate (in un test sulla 9.7.0 si ottiene un errore di tipo, e `strictMode` determina il livello di rigore del controllo), così eventuali lacune emergono prima del rilascio. * **Tipi di contenuto avanzati.** Oltre al testo per impostazione regionale, le dichiarazioni supportano [plurali per categoria CLDR](https://intlayer.org/doc/concept/content/plural) (`plural({ one, few, many, other })`), enumerazioni, condizioni, genere, Markdown, HTML, annidamento e inserimento. * **Scegli il tuo modello.** `intlayer fill` traduce le impostazioni regionali mancanti con OpenAI, Anthropic, Mistral, Gemini, DeepSeek, Ollama, OpenRouter e altri provider, da configurare in [`ai` in `intlayer.config.ts`](https://intlayer.org/doc/concept/configuration) oppure tramite `--provider` e `--api-key`. Con la tua chiave e il pacchetto `@intlayer/ai` installato, [il comando viene eseguito in locale](https://intlayer.org/doc/concept/cli/fill) e paghi direttamente il provider. * **Modifica visuale.** Il pacchetto `intlayer-editor` carica la tua app in esecuzione in un editor dove i redattori selezionano e modificano il testo, e poi riporta le modifiche nei file di dichiarazione. [Secondo la documentazione di Intlayer](https://intlayer.org/doc/concept/editor), l'editor è rilasciato con licenza Apache 2.0, è gratuito per uso commerciale ed è pensato per gli ambienti di sviluppo e di staging. * **Ampio supporto ai framework.** Le [guide](https://intlayer.org/doc/get-started) coprono Next.js, React con Vite, React Router, TanStack Start, React Native, Vue e Nuxt, Svelte e SvelteKit, Solid, Preact, Astro, Angular e framework lato server come Express, NestJS, Fastify e Hono. ## Cosa Intlayer lascia a carico tuo Ecco il file di contenuto di una casella di posta con tre impostazioni regionali: ```ts title="inbox.content.ts" import { t, plural, type Dictionary } from 'intlayer'; const inboxContent = { key: 'inbox', content: { title: t({ en: 'Inbox', es: 'Bandeja de entrada', pl: 'Skrzynka odbiorcza', }), unread: t({ en: plural({ one: 'You have {{count}} unread message.', other: 'You have {{count}} unread messages.', }), es: plural({ one: 'Tienes {{count}} mensaje sin leer.', other: 'Tienes {{count}} mensajes sin leer.', }), pl: plural({ one: 'Masz {{count}} nieprzeczytaną wiadomość.', few: 'Masz {{count}} nieprzeczytane wiadomości.', many: 'Masz {{count}} nieprzeczytanych wiadomości.', other: 'Masz {{count}} nieprzeczytanej wiadomości.', }), }), }, } satisfies Dictionary; export default inboxContent; ``` ```tsx title="Inbox.tsx" import { useIntlayer } from 'react-intlayer'; export function Inbox({ count }: { count: number }) { const { title, unread } = useIntlayer('inbox'); return (

{title}

{unread({ count })}

); } ``` Il risultato viene renderizzato correttamente in ogni impostazione regionale, ma il file cresce con ognuna che aggiungi: con 20 impostazioni regionali, ogni stringa contiene 20 voci. E anche una nuova stringa le richiede tutte. Aggiungendo `archive: t({ en: 'Archive' })` si otteneva un errore di tipo che elencava le impostazioni regionali ancora mancanti: ```text title="Output" Type '{ en: string; }' is missing the following properties from type 'Required>': es, pl ``` A runtime, le impostazioni regionali mancanti ricadevano sull'inglese. Per colmare la lacuna, devi scrivere tu le traduzioni oppure eseguire `intlayer fill`. Fill invia al modello il contenuto del dizionario, [la sua descrizione](https://intlayer.org/doc/concept/content) e una stringa `applicationContext` presa dalla tua config. Non vede il componente né il JSX attorno a una stringa. [Il compilatore di Intlayer](https://intlayer.org/doc/compiler) può estrarre il testo JSX semplice in file di contenuto in fase di compilazione, così non devi scrivere le dichiarazioni a mano, ma le traduzioni finiscono comunque in quei file. ## General Translation mantiene una sola lingua nel codice Le librerie di General Translation renderizzano le traduzioni allo stesso modo, selezionando i messaggi di ciascuna impostazione regionale e applicandone le regole del plurale. La differenza è che nei tuoi componenti è presente solo la lingua di origine. Ecco la stessa casella di posta con `gt-react`: ```tsx title="Inbox.tsx" import { T, Plural, Num } from 'gt-react'; export function Inbox({ count }: { count: number }) { return (

Inbox

You have {count} unread message.

} plural={

You have {count} unread messages.

} />
); } ``` Non c'è alcun file di contenuti né alcuna chiave. [`npx gt translate`](/docs/cli/reference/commands/translate) invia ogni blocco [``](/docs/react/reference/components/t), insieme alla sua struttura di elementi, all'API di General Translation e scrive in file separati le traduzioni per ogni impostazione regionale di destinazione: per aggiungere un'impostazione regionale basta quindi modificare `gt.config.json`, senza toccare i tuoi componenti. Tu scrivi le forme plurali previste dall'inglese, la traduzione genera quelle richieste da ciascuna lingua di destinazione e [``](/docs/react/reference/components/plural) sceglie il ramo tradotto in base alle regole dell'impostazione regionale del lettore. [`npx gt validate`](/docs/cli/reference/commands/validate) verifica il progetto senza chiamare l'API, mentre [`gt generate`](/docs/cli/reference/commands/generate) genera i template per i team che traducono manualmente. È il contesto a fare la differenza. General Translation traduce insieme il testo e la struttura JSX di ogni blocco contrassegnato, avvalendosi delle note degli sviluppatori per chiarirne il significato. Un pulsante “Salva” riferito a un documento in tedesco diventa “speichern”, mentre un invito a risparmiare denaro diventa “sparen”. I [gruppi di contesto](/docs/platform/dashboard/guides/defining-context-for-translations) applicano il tuo Glossario e i tuoi prompt personalizzati ai progetti a cui li assegni. I revisori apportano le modifiche nella dashboard, mentre la CLI o [Locadex](/docs/platform/locadex/quickstart) gestiscono gli aggiornamenti man mano che il codice cambia. I team che vogliono contrassegnare automaticamente il JSX esistente possono attivare l'[iniezione automatica di JSX](/docs/cli/guides/using-auto-jsx). Le librerie JavaScript sono distribuite con licenza MIT e possono renderizzare le traduzioni fornite anche senza un account. Puoi mantenere le traduzioni nella tua build oppure pubblicarle sulla CDN di General Translation. Cursor utilizza General Translation per oltre 14 impostazioni regionali tra sito web e documentazione. (Vedi le [distribuzioni in produzione](https://generaltranslation.com/enterprise).) ## Intlayer e General Translation a confronto | Funzionalità | Intlayer | General Translation | | ------------------------------- | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- | --------------------------------------------------------------------------------------------------------------------------------------------------------------- | | Come si scrivono i testi | `t({ en, es, ... })` in un file di dichiarazione per ogni componente, letto con `useIntlayer` | JSX all'interno di [``](/docs/react/reference/components/t), stringhe tramite [`useGT`](/docs/react/reference/hooks/use-gt) o dizionari basati su chiavi | | Dove risiedono le traduzioni | Nei file di dichiarazione o in file di contenuto separati per ogni impostazione regionale | File separati per ogni impostazione regionale o CDN di General Translation | | Traduzione con IA | `intlayer fill` con la chiave del tuo provider o tramite il servizio di Intlayer | [`npx gt translate`](/docs/cli/reference/commands/translate) tramite l'API di General Translation | | Contesto fornito al modello | Contenuto del dizionario, descrizione e una stringa di contesto dell'applicazione | Struttura JSX contrassegnata, note degli sviluppatori, Glossario e prompt personalizzati assegnati | | Impostazioni regionali mancanti | Segnalate come errore di tipo in un test con la 9.7.0; [`intlayer test`](https://intlayer.org/doc/concept/cli/test) le rileva | Generate da [`npx gt translate`](/docs/cli/reference/commands/translate); il contenuto non tradotto viene renderizzato nella lingua di origine | | Modifica | Editor visuale locale gratuito; CMS ospitato facoltativo | Modifica e revisione delle traduzioni nella dashboard | | Framework | React, Next.js, Vue, Svelte, Solid, Angular, Astro, React Native e server Node.js | React, Next.js, Vue, Node.js e [altri SDK](/docs/overview/get-started) | | Licenza e costi | Apache 2.0; i piani del CMS ospitato variano in base a progetti, postazioni e spazio di archiviazione ([prezzi](https://app.intlayer.org/pricing), verificati a ottobre 2026) | Librerie JavaScript con licenza MIT; [traduzione a consumo](https://generaltranslation.com/pricing) | Scegli Intlayer se vuoi avere ogni lingua visibile accanto al componente, errori di tipo per le impostazioni regionali mancanti, un editor direttamente sulla pagina per i redattori o la sua integrazione con Svelte, Solid o Angular. Scegli General Translation se preferisci scrivere i testi una sola volta nella lingua di origine e far generare tutte le altre lingue sfruttando il contesto del tuo codice, il tuo Glossario e i prompt personalizzati. ## Passare da Intlayer a General Translation Migra un componente alla volta, continuando a usare le sue traduzioni Intlayer finché la relativa versione General Translation non è pronta. In un rendering lato server con `react-intlayer` 9.7.0 e `gt-react` 11.4.12, un componente Intlayer e un componente [``](/docs/react/reference/components/t) sono stati renderizzati affiancati all'interno di `IntlayerProvider` e [`GTProvider`](/docs/react/reference/components/gt-provider). Copia i valori `en` del componente come JSX all'interno di [``](/docs/react/reference/components/t), genera le traduzioni con [`npx gt translate`](/docs/cli/reference/commands/translate) e verifica il risultato prima di passare il componente alla nuova versione. Inizia con l'[Avvio rapido di Next.js](/docs/react/nextjs-quickstart) o con la [Guida rapida a React](/docs/react/react-quickstart) e consulta [Migrare le librerie i18n](/docs/react/guides/migrating-i18n-libraries) per usare due librerie in parallelo durante la migrazione. ## Punti chiave * Intlayer conserva il contenuto di ogni componente in un file di dichiarazione tipizzato, con tutte le lingue affiancate, segnala le impostazioni regionali mancanti come errori di tipo e le completa tramite un provider di IA da te configurato. * General Translation mantiene nei componenti solo la lingua di origine e genera tutte le altre lingue sfruttando il contesto del tuo codice, il tuo Glossario e i prompt personalizzati, con la possibilità di revisione nella dashboard. * Intlayer supporta più framework e offre l'editing visuale direttamente sulla pagina; puoi migrare a General Translation un componente alla volta, dato che le due librerie possono renderizzare l'una accanto all'altra. ## 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. - [General Translation o Paraglide JS: quale scegliere?](https://generaltranslation.com/it/kb/general-translation-vs-paraglide.mdx): Scegli General Translation per mantenere i testi inline e generare traduzioni basate sulla struttura dei tuoi componenti React, su una terminologia condivisa e sulla revisione nella Dashboard. Scegli Paraglide JS per funzioni di messaggio compilate e tipizzate, con tree-shaking per singolo messaggio. Paraglide renderizza i tuoi cataloghi; General Translation collega i testi sorgente alla generazione delle traduzioni e ai successivi aggiornamenti. - [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. - [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. ## Previous and next questions - Previous question: [General Translation e il framework di traduzione di Django: servono entrambi?](https://generaltranslation.com/it/kb/general-translation-vs-django-i18n.mdx) - Next question: [General Translation o Lingui: quale scegliere?](https://generaltranslation.com/it/kb/general-translation-vs-lingui.mdx) ## Sitemap See the [Knowledge Base sitemap](https://generaltranslation.com/it/kb/sitemap.md) for every article.