# General Translation Knowledge Base: General Translation o Paraglide JS: quale scegliere?
URL: https://generaltranslation.com/it/kb/general-translation-vs-paraglide.mdx
Docs index: https://generaltranslation.com/llms.txt
Description: 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.
Category: Internazionalizzazione
Last updated: 2026-10-16
Authors: Kevin Wu, Jackie Chen
Published: 2026-10-16
Paraglide JS è una libreria i18n di inlang basata sul compilatore. I messaggi risiedono in file JSON come `messages/en.json` e il compilatore trasforma ciascuno di essi in una funzione tipizzata da richiamare come `m.greeting({ name })`, così il bundler può scartare i messaggi che una pagina non usa mai. La traduzione, però, resta a carico tuo: ogni messaggio in ogni lingua deve arrivare da te, da un traduttore o da un comando di traduzione automatica eseguito sui file. Anche le librerie di General Translation renderizzano le traduzioni, ma General Translation in più le genera, a partire da testi che scrivi una sola volta, inline, direttamente nei componenti.
## Cosa fa bene Paraglide JS
* **Sicurezza dei tipi.** Le chiavi e i parametri dei messaggi sono tipi generati. Con la versione 2.29.0, sia un `m.greting()` scritto male sia una chiamata a `m.greeting({})` senza il parametro `name` producono errori TypeScript.
* **Dimensione del bundle.** I messaggi vengono compilati in moduli ES, quindi quelli inutilizzati vengono rimossi tramite tree-shaking. Nel [benchmark pubblicato](https://paraglidejs.com/benchmark) da Paraglide, una pagina che utilizzava 100 messaggi su 200 in cinque impostazioni regionali trasferiva 47 KB con Paraglide e 205 KB con i18next.
* **Plurali e varianti.** Il formato dei messaggi predefinito [dichiara un selettore di plurale](https://paraglidejs.com/variants) ed esegue il matching sulle categorie CLDR come `one`, `few` e `many`. I [plugin](https://paraglidejs.com/file-formats) aggiungono il supporto per ICU MessageFormat 1 e per i file i18next, mentre i formattatori gestiscono numeri, date e tempo relativo tramite `Intl`.
* **Strategie per l'impostazione regionale.** Un [elenco `strategy`](https://paraglidejs.com/strategy) ordinato risolve l'impostazione regionale a partire dall'URL, da un cookie, da `localStorage`, dalla lingua preferita del browser, da una variabile globale, da strategie personalizzate o da `baseLocale`. Nella 2.29.0 il [valore predefinito](https://github.com/opral/paraglide-js/blob/main/src/compiler/compiler-options.ts) è `cookie`, `globalVariable` e infine `baseLocale`. Il [middleware lato server](https://paraglidejs.com/middleware) e `localizeUrl` gestiscono le route localizzate.
* **Ampio supporto ai framework.** Paraglide [funziona con qualsiasi app Vite](https://paraglidejs.com/vite) e offre guide per React, Vue, Solid, SvelteKit, TanStack Start, React Router, Astro e Next.js. È l'[add-on su cui si basa `npx sv add paraglide`](https://paraglidejs.com/sveltekit) nella CLI di Svelte. La sua [guida per Next.js](https://paraglidejs.com/next-js) supporta l'App Router tramite un plugin webpack, da eseguire con il flag `--webpack`.
* **Strumenti gratuiti e aperti.** La libreria è [distribuita con licenza MIT](https://github.com/opral/paraglide-js/blob/main/LICENSE). La [CLI di inlang](https://inlang.com/m/2qj2w8pu/app-inlang-cli) verifica i progetti in CI, [Sherlock](https://inlang.com/m/r7kp499g/app-inlang-ideExtension) mostra le traduzioni inline in VS Code e [Fink](https://fink.inlang.com/) è un editor gratuito basato su browser che esegue il commit delle modifiche dei traduttori in un repository GitHub.
## Cosa Paraglide JS lascia a te
Un progetto inlang è una cartella `project.inlang` il cui file `settings.json` elenca le tue impostazioni regionali, i plugin e il percorso dei file dei messaggi. Ecco una casella di posta con un messaggio semplice, uno con un parametro e uno con il plurale:
```json title="messages/en.json"
{
"inbox_title": "Inbox",
"greeting": "Hello {name}!",
"unread_messages": [
{
"declarations": ["input count", "local countPlural = count: plural"],
"selectors": ["countPlural"],
"match": {
"countPlural=one": "You have {count} unread message.",
"countPlural=*": "You have {count} unread messages."
}
}
]
}
```
```tsx title="Inbox.tsx"
import { m } from './paraglide/messages.js';
export function Inbox({ name, count }: { name: string; count: number }) {
return (
{m.inbox_title()}
{m.greeting({ name })}
{m.unread_messages({ count })}
);
}
```
Ogni altra impostazione regionale richiede un proprio file con le stesse chiavi e con le varianti previste da quella lingua: il polacco usa `one`, `few`, `many` e `*`. Se una chiave manca in `messages/pl.json`, la funzione compilata ripiega sull'impostazione regionale di base senza alcun avviso. Ecco il componente renderizzato con un file polacco privo di `greeting`:
```text title="Output"
pl Skrzynka odbiorcza
Hello Ada!
Masz 2 nieprzeczytane wiadomości.
```
`npx @inlang/cli check` l'ha rilevato: ha segnalato che `greeting` non ha una traduzione in polacco ed è terminato con codice di uscita 1, così la CI può bloccare la lacuna. Colmarla, però, resta compito tuo. `inlang machine translate` traduce i messaggi mancanti usando per impostazione predefinita un servizio gratuito gestito dalla community, oppure la tua chiave di Google Cloud Translation o DeepL, un messaggio alla volta e senza il componente in cui compare. La documentazione stessa della CLI di inlang suggerisce che gli agenti di programmazione con il contesto del prodotto e del codice possono produrre bozze migliori rispetto a una traduzione automatica generica.
## General Translation scrive le traduzioni
Le librerie di General Translation si occupano del rendering allo stesso modo. La differenza sta in dove risiedono i testi e in chi li traduce. Ecco la stessa casella di posta con `gt-react`:
```tsx title="Inbox.tsx"
import { T, Plural, Num, Var } from 'gt-react';
export function Inbox({ name, count }: { name: string; count: number }) {
return (
Inbox
Hello {name}!
You have {count} unread message.}
plural={You have {count} unread messages.
}
/>
);
}
```
Non c'è alcun file di messaggi da tenere sincronizzato: il testo inglese è il componente stesso. [`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 una traduzione per ogni impostazione regionale di destinazione: in questo modo una nuova frase viene tradotta prima della build, invece di ripiegare sull'inglese. Un valore in [``](/docs/react/reference/components/var) non viene mai inviato all'API, e [``](/docs/react/reference/components/plural) sceglie un ramo in base alle regole del plurale 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 file template per i team che traducono manualmente.
Il titolo, il saluto e i rami del plurale contenuti in questo blocco vengono inviati insieme per la traduzione. General Translation applica inoltre il [Glossario e i prompt personalizzati](/docs/platform/dashboard/guides/defining-context-for-translations) assegnati al progetto, e i revisori possono modificare i risultati nella dashboard. Aggiungi la CLI alla pipeline di CI, oppure configura [Locadex](/docs/platform/locadex/quickstart) per aprire pull request di traduzione a ogni modifica del codice.
Le librerie JavaScript di General Translation sono distribuite con licenza MIT e funzionano con traduzioni fornite da te, senza bisogno di un account. Includendo le traduzioni nel bundle dell'app, il rendering non dipende dal servizio ospitato; la consegna tramite CDN ti consente invece di pubblicare le modifiche alle traduzioni indipendentemente dai rilasci dell'applicazione. Per la configurazione, consulta [archiviazione delle traduzioni](/docs/react/guides/storing-translations).
Con General Translation, Sierra pubblica i propri contenuti web e go-to-market in oltre 7 impostazioni regionali. (Vedi le [distribuzioni in produzione](https://generaltranslation.com/enterprise).)
## Paraglide JS e General Translation a confronto
| Funzionalità | Paraglide JS | General Translation |
| ------------------------ | ---------------------------------------------------------------------------------------------- | --------------------------------------------------------------------------------------------------------------------------------------------------------------- |
| Come scrivi i testi | Chiavi in un file JSON per ogni impostazione regionale, richiamate con `m.key()` | JSX all'interno di [``](/docs/react/reference/components/t), stringhe tramite [`useGT`](/docs/react/reference/hooks/use-gt) o dizionari basati su chiavi |
| Traduce i tuoi contenuti | No; `inlang machine translate` si affida a un servizio della community, a Google o a DeepL | Sì, con [`npx gt translate`](/docs/cli/reference/commands/translate) |
| Cosa vede il traduttore | Il contenuto del messaggio passato allo strumento di traduzione scelto | Il blocco JSX contrassegnato, le note degli sviluppatori, il Glossario e i prompt personalizzati assegnati |
| Sicurezza dei tipi | Tipi generati per ogni chiave e parametro | JSX inline, senza chiavi di messaggio da digitare male |
| Bundle | Tree-shaking per singolo messaggio | Le traduzioni vengono caricate per impostazione regionale |
| Traduzione mancante | Fallback sull'impostazione regionale di base; `inlang check` la segnala | Generata da [`npx gt translate`](/docs/cli/reference/commands/translate); i contenuti non tradotti vengono renderizzati nella lingua di origine |
| Framework | App Vite, React, Vue, Solid, SvelteKit, Astro, TanStack Start, React Router, Next.js (webpack) | React, Next.js, Vue, Node.js e [altri SDK](/docs/overview/get-started) |
| Costo | Gratuito e open source | Librerie JavaScript gratuite; [traduzione fatturata in base all'utilizzo](https://generaltranslation.com/pricing) |
Resta su Paraglide JS se sviluppi con SvelteKit, Astro o Solid, se per te contano soprattutto il tree-shaking per singolo messaggio e le funzioni di messaggio tipizzate, oppure se il tuo team scrive o acquista già le proprie traduzioni. Scegli General Translation se vuoi testi leggibili direttamente nei componenti e tutte le lingue generate a ogni build tenendo conto del contesto del tuo codice.
## Passare a General Translation un componente alla volta
La migrazione graduale, un componente alla volta, è un approccio valido. I messaggi di Paraglide sono semplici funzioni e non richiedono alcun provider, quindi una chiamata `m.*` e un blocco [``](/docs/react/reference/components/t) possono essere renderizzati fianco a fianco mentre converti le route. La guida [Migrazione delle librerie i18n](/docs/react/guides/migrating-i18n-libraries) illustra i passaggi, a partire dalla [Guida rapida a React](/docs/react/react-quickstart) o dall'[Avvio rapido di Next.js](/docs/react/nextjs-quickstart).
## Punti chiave
* Paraglide JS compila i cataloghi in funzioni tipizzate e compatibili con il tree-shaking. Gli strumenti separati di inlang possono generare le traduzioni per questi cataloghi.
* General Translation mantiene i testi inline in [``](/docs/react/reference/components/t) e genera le traduzioni sfruttando il contesto del tuo codice, del tuo Glossario e dei prompt personalizzati, con la revisione nella dashboard.
* Continua a usare i messaggi esistenti di Paraglide mentre migri i componenti a General Translation. Ogni componente migrato include nel JSX il proprio testo di origine e il contesto di traduzione.
## 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 Intlayer: quale scegliere?](https://generaltranslation.com/it/kb/general-translation-vs-intlayer.mdx): 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.
- [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 o Mobility: quale scegliere?](https://generaltranslation.com/it/kb/general-translation-vs-mobility.mdx)
- Next question: [General Translation o Symfony Translation: quale scegliere?](https://generaltranslation.com/it/kb/general-translation-vs-symfony-translation.mdx)
## Sitemap
See the [Knowledge Base sitemap](https://generaltranslation.com/it/kb/sitemap.md) for every article.