# General Translation Knowledge Base: General Translation o Lingui: quale scegliere?
URL: https://generaltranslation.com/it/kb/general-translation-vs-lingui.mdx
Docs index: https://generaltranslation.com/llms.txt
Description: Scegli General Translation per mantenere i testi inline come con Lingui e generare le traduzioni usando la struttura JSX come contesto. Lingui estrae i messaggi inline in cataloghi che i tuoi traduttori o un servizio collegato dovranno tradurre. La CLI di General Translation aggiorna le traduzioni man mano che il codice cambia e il tuo team le revisiona nella Dashboard.
Category: Internazionalizzazione
Last updated: 2026-10-16
Authors: Kevin Wu, Jackie Chen
Published: 2026-10-16

Sul fronte della scrittura del codice, l&#39;approccio di Lingui è molto vicino a quello di General Translation. Scrivi `<Trans>Inbox</Trans>` in un componente, le macro di Lingui lo compilano in un messaggio ICU con un ID generato, `lingui extract` genera i cataloghi PO e `lingui compile` trasforma i cataloghi tradotti in piccoli moduli JavaScript. Quello che Lingui lascia fuori è la traduzione vera e propria: la sua documentazione suggerisce di [modificare i cataloghi a mano o sincronizzarli con Crowdin o Translation.io](https://lingui.dev/tools/introduction). Anche General Translation mantiene i testi inline, ma le traduzioni le genera direttamente.

## Cosa fa bene Lingui

* **Sorgente inline con le macro.** La macro `<Trans>` e le [macro di Lingui](https://lingui.dev/ref/macro) per i plurali e le semplici stringhe mantengono il testo inglese nel componente e vengono compilate in ICU MessageFormat, così nessuno deve scrivere chiavi.
* **Un runtime leggero.** I messaggi vengono compilati in anticipo e, secondo le misurazioni di Lingui stesso, il suo runtime pesa [circa 2 kB](https://lingui.dev/introduction).
* **Cataloghi compatibili con gettext.** [PO è il formato predefinito](https://lingui.dev/ref/catalog-formats), `lingui extract` esegue il merge dei nuovi messaggi in ogni impostazione regionale e contrassegna come obsoleti quelli rimossi, mentre i campi `context` e `comment` arrivano ai traduttori.
* **Componenti server.** [A partire dalla versione 4.10](https://lingui.dev/tutorials/react-rsc), `<Trans>` e `useLingui` funzionano sul server, a patto che ogni pagina o layout chiami `setI18n`.
* **Sviluppo attivo.** [La versione 6 è stata rilasciata ad aprile 2026](https://lingui.dev/blog/2026/04/22/announcing-lingui-6.0) (solo ESM, Node.js 22.19 o successivo), con licenza MIT.

## Cosa Lingui lascia a te

Ecco una piccola inbox realizzata con le macro React di Lingui:

```jsx title="Inbox.jsx"
import { Trans, Plural } from '@lingui/react/macro';

export function Inbox({ count }) {
  return (
    <section>
      <h1>
        <Trans>Inbox</Trans>
      </h1>
      <p>
        <Trans>
          You have <Plural value={count} one="# unread message" other="# unread messages" />.
        </Trans>
      </p>
    </section>
  );
}
```

`lingui extract` aggiunge ai cataloghi PO i nuovi messaggi nella lingua di destinazione, con traduzioni vuote. I tuoi traduttori o un servizio collegato compilano queste voci mantenendo intatta la sintassi ICU. Ecco il catalogo spagnolo a lavoro completato:

```text title="locales/es/messages.po"
#: src/Inbox.jsx:7
msgid "Inbox"
msgstr "Bandeja de entrada"

#: src/Inbox.jsx:10
msgid "You have {count, plural, one {# unread message} other {# unread messages}}."
msgstr "Tienes {count, plural, one {# mensaje sin leer} other {# mensajes sin leer}}."
```

Poi [`lingui compile`](https://lingui.dev/ref/cli) trasforma il catalogo in un modulo caricato dall&#39;app. Questo ciclo di estrazione, traduzione e compilazione si ripete a ogni modifica; le macro richiedono una [trasformazione in fase di build](https://lingui.dev/installation) (il plugin Babel di Lingui, il suo plugin Vite o un plugin SWC sperimentale); e chi traduce lavora sulla voce PO e sui relativi commenti, non sul componente.

## Mantieni i testi inline e lascia che General Translation generi i cataloghi

Le librerie di General Translation mantengono la stessa scrittura inline: i testi restano in [`<T>`](/docs/react/reference/components/t), le forme plurali vanno in [`<Plural>`](/docs/react/reference/components/plural) e [`<Num>`](/docs/react/reference/components/num) formatta i valori per ciascuna impostazione regionale. In più, General Translation fa ciò che Lingui non fa: genera le traduzioni. 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 (
    <T>
      <section>
        <h1>Inbox</h1>
        <Plural
          n={count}
          singular={<p>You have <Num>{count}</Num> unread message.</p>}
          plural={<p>You have <Num>{count}</Num> unread messages.</p>}
        />
      </section>
    </T>
  );
}
```

[`npx gt translate`](/docs/cli/reference/commands/translate) invia ogni blocco [`<T>`](/docs/react/reference/components/t) insieme alla struttura dei suoi elementi e genera i cataloghi di destinazione prima della build. I rami sorgente `singular` e `plural` forniscono il testo per le forme richieste da ciascuna lingua di destinazione. [`<Plural>`](/docs/react/reference/components/plural) seleziona il ramo tradotto a runtime. Le stringhe al di fuori di JSX passano per [`useGT`](/docs/react/reference/hooks/use-gt), l&#39;equivalente della macro per stringhe di Lingui.

In questo esempio, l&#39;intestazione della casella di posta e i rami del messaggio vengono inviati insieme in traduzione. Puoi anche aggiungere una [nota `context`](/docs/react/reference/components/t#context) per chiarire significati specifici del prodotto. I revisori modificano il testo generato nell&#39;[Editor di traduzione della dashboard](/docs/platform/dashboard/guides/reviewing-translations); all&#39;esecuzione successiva, la CLI riutilizza le traduzioni invariate e genera i nuovi testi, senza bisogno di un comando separato per compilare i cataloghi.

La piattaforma e la documentazione di Profound sono disponibili in oltre 47 impostazioni regionali grazie a General Translation. (Vedi le [distribuzioni in produzione](https://generaltranslation.com/enterprise).)

## Lingui e General Translation a confronto

| Funzionalità               | Lingui                                                                                                    | General Translation                                                                                                                |
| -------------------------- | --------------------------------------------------------------------------------------------------------- | ---------------------------------------------------------------------------------------------------------------------------------- |
| Come si scrivono i testi   | Macro inline come `<Trans>`                                                                               | JSX inline in [`<T>`](/docs/react/reference/components/t) e stringhe in [`useGT`](/docs/react/reference/hooks/use-gt)              |
| Traduce i tuoi contenuti   | No                                                                                                        | Sì, con [`npx gt translate`](/docs/cli/reference/commands/translate)                                                               |
| Passaggi per ogni modifica | Estrazione, traduzione di ogni catalogo PO e compilazione, più una trasformazione delle macro nella build | [`npx gt translate`](/docs/cli/reference/commands/translate) prima della build                                                     |
| Cataloghi                  | File PO per ogni impostazione regionale, compilati in moduli JavaScript                                   | Generati per ogni impostazione regionale, archiviati nel tuo repository o sulla CDN di General Translation                         |
| Cosa vede il traduttore    | Il messaggio, più i campi `context` e `comment`                                                           | La struttura all&#39;interno dei blocchi JSX contrassegnati, le note di contesto, il Glossario condiviso e i prompt personalizzati |

Resta su Lingui se i tuoi traduttori lavorano con cataloghi PO di gettext, se il suo runtime compilato e minimale è importante per il tuo bundle o se il tuo processo di traduzione funziona già. Scegli General Translation se vuoi la stessa scrittura inline senza il ciclo di estrazione, traduzione e compilazione, con traduzioni generate tenendo conto del contesto del tuo codice.

## Migrare da Lingui

Migra un componente o una route alla volta. Il `<Trans>` di Lingui corrisponde a [`<T>`](/docs/react/reference/components/t), mentre il suo `<Plural value={count} one="…" other="…" />` corrisponde a [`<Plural>`](/docs/react/reference/components/plural) con `n={count}` e i rami `singular` e `plural`, usando [`<Num>`](/docs/react/reference/components/num) per il numero. La sua macro per le stringhe corrisponde a [`useGT`](/docs/react/reference/hooks/use-gt). Continua a caricare le traduzioni Lingui esistenti per i componenti che non hai ancora migrato. Dopo aver migrato l&#39;ultimo componente, rimuovi la trasformazione delle macro e gli script di estrazione e compilazione. (Vedi [Migrare le librerie i18n](/docs/react/guides/migrating-i18n-libraries).)

## Punti chiave

* Lingui mantiene i testi inline e compila un runtime leggero; i cataloghi di destinazione vengono forniti dai traduttori o da un servizio collegato.
* Le librerie di General Translation mantengono la stessa scrittura inline, ma è General Translation stessa a occuparsi della traduzione, sfruttando il contesto del tuo codice e senza alcun ciclo di gestione dei cataloghi.
* Le macro di Lingui hanno un corrispettivo diretto in [`<T>`](/docs/react/reference/components/t), [`<Plural>`](/docs/react/reference/components/plural) e [`useGT`](/docs/react/reference/hooks/use-gt), quindi puoi migrare un componente alla volta.

## 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.
- [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.
- [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 o Intlayer: quale scegliere?](https://generaltranslation.com/it/kb/general-translation-vs-intlayer.mdx)
- Next question: [General Translation o Mobility: quale scegliere?](https://generaltranslation.com/it/kb/general-translation-vs-mobility.mdx)

## Sitemap

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