# General Translation Knowledge Base: Posso fare i18n senza file di traduzione?
URL: https://generaltranslation.com/it/kb/i18n-without-translation-files.mdx
Docs index: https://generaltranslation.com/llms.txt
Description: Sì. Le librerie gt-react e gt-next di General Translation gestiscono l'i18n in React e Next.js senza chiavi di traduzione e senza dover mantenere un file JSON per ogni lingua. I testi restano inline nel JSX all'interno del componente `<T>` e il comando gt translate genera le traduzioni per ogni lingua durante la build, sfruttando il contesto del tuo codice. Locadex può mantenerle aggiornate tramite pull request.
Category: Internazionalizzazione
Last updated: 2026-10-21
Authors: Jackie Chen, Ernest McCarter
Published: 2026-05-07

Sì. Le librerie open source `gt-react` e `gt-next` di General Translation ti permettono di internazionalizzare (i18n) un&#39;app React o Next.js senza chiavi di traduzione e senza scrivere un file JSON per ogni lingua. Scrivi i testi inline nel JSX all&#39;interno del componente [`<T>`](/docs/react/reference/components/t) e [`npx gt translate`](/docs/cli/reference/commands/translate) genera le traduzioni per tutte le lingue durante la build.

Le librerie basate su chiavi, come i18next, react-intl e next-intl, recuperano ogni stringa tramite la relativa chiave da un file di messaggi per ciascuna lingua: ogni nuova stringa richiede quindi una chiave in ogni file. Basta una chiave aggiunta a `en.json` ma dimenticata in `ja.json` per lasciare non tradotta una riga della tua pagina di checkout in giapponese.

Con General Translation i file di traduzione esistono ancora, ma come output della build. La CLI genera un file per ogni lingua e può pubblicare le traduzioni sulla CDN di General Translation. Nessuno deve modificare quei file a mano né copiare chiavi da un file all&#39;altro.

## Video

The video is narrated in English, with English captions.

[Can I do i18n without translation files?](https://caxecubb9c64cezv.public.blob.vercel-storage.com/films/kb-i18n-without-translation-files.mp4) (46 s)

General Translation lets you stop writing translation files with `gt-react` or `gt-next`. Run `npx gt init`, write the English inside a `<T>` component, then add `npx gt translate` to your build script so every build writes the translations.

## Posso tradurre i componenti React inline invece di usare un file di chiavi?

Sì. Con General Translation, ogni frase resta nel componente, all&#39;interno di [`<T>`](/docs/react/reference/components/t), e la CLI traduce l&#39;intero blocco. Con react-i18next, invece, un riepilogo del checkout legge ogni stringa tramite la relativa chiave da un file JSON:

```json title="locales/en/checkout.json"
{
  "summary": {
    "title": "Order summary",
    "item_count_one": "You have {{count}} item in your cart.",
    "item_count_other": "You have {{count}} items in your cart.",
    "tax_notice": "Tax is calculated at checkout."
  }
}
```

```tsx title="CheckoutSummary.tsx"
import { useTranslation } from 'react-i18next';

export function CheckoutSummary({ itemCount }: { itemCount: number }) {
  const { t } = useTranslation('checkout');
  return (
    <section>
      <h2>{t('summary.title')}</h2>
      <p>{t('summary.item_count', { count: itemCount })}</p>
      <small>{t('summary.tax_notice')}</small>
    </section>
  );
}
```

Lo stesso componente con `gt-next` mantiene il testo in inglese direttamente nel JSX. Gli altri framework React importano dal rispettivo pacchetto, ad esempio `gt-react`.

```tsx title="CheckoutSummary.tsx"
import { T, Plural, Num } from 'gt-next';

export function CheckoutSummary({ itemCount }: { itemCount: number }) {
  return (
    <T>
      <section>
        <h2>Order summary</h2>
        <Plural
          n={itemCount}
          one={<p>You have <Num>{itemCount}</Num> item in your cart.</p>}
          other={<p>You have <Num>{itemCount}</Num> items in your cart.</p>}
        />
        <small>Tax is calculated at checkout.</small>
      </section>
    </T>
  );
}
```

La versione con `gt-next` non ha alcun `checkout.json`, nessuna chiave da nominare e nessun `ja.json` da aggiornare. [`npx gt translate`](/docs/cli/reference/commands/translate) invia ogni blocco [`<T>`](/docs/react/reference/components/t) all&#39;API di General Translation, insieme alla struttura dei suoi elementi come contesto, e genera una traduzione per ogni lingua definita in `gt.config.json`. [`<Plural>`](/docs/react/reference/components/plural) sceglie la forma plurale richiesta da ciascuna lingua (il giapponese ne usa una, l&#39;arabo sei) e [`<Num>`](/docs/react/reference/components/num) formatta il numero in base all&#39;impostazione regionale del lettore.

## Quali librerie i18n permettono di scrivere il testo direttamente in JSX senza file di chiavi?

`gt-react` e `gt-next` di General Translation permettono di scrivere testo traducibile direttamente in JSX senza file di chiavi, e le traduzioni vengono generate da General Translation. Anche Lingui e l&#39;estrazione sperimentale di next-intl accettano messaggi inline, ma li estraggono in cataloghi che il tuo team, i traduttori o un servizio devono comunque tradurre.

| Libreria                                    | Dove scrivi i testi                                                                                                                                                                       | Da dove provengono le traduzioni                                                                                               | Cosa deve gestire il tuo team                                                                               |
| ------------------------------------------- | ----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- | ------------------------------------------------------------------------------------------------------------------------------ | ----------------------------------------------------------------------------------------------------------- |
| i18next (`react-i18next`)                   | Chiavi in un file JSON per ogni lingua                                                                                                                                                    | Il tuo team, i traduttori o un servizio                                                                                        | Una chiave per ogni stringa, nel file di ogni lingua                                                        |
| next-intl                                   | Chiavi in un catalogo JSON per ogni lingua; i [messaggi inline con `useExtracted`](https://next-intl.dev/docs/usage/extraction) sono sperimentali                                         | Il tuo team, i traduttori o un servizio                                                                                        | Ogni catalogo, da aggiornare a ogni modifica dei testi                                                      |
| [Lingui](https://lingui.dev/introduction)   | Macro `<Trans>` inline con ID dei messaggi generati, estratti in cataloghi PO                                                                                                             | Il tuo team, i traduttori o un servizio                                                                                        | Estrazione, traduzione e compilazione dei cataloghi                                                         |
| General Translation (`gt-react`, `gt-next`) | JSX inline all&#39;interno di [`<T>`](/docs/react/reference/components/t), stringhe tramite [`useGT`](/docs/react/reference/hooks/use-gt) o, facoltativamente, dizionari basati su chiavi | Generate da [`npx gt translate`](/docs/cli/reference/commands/translate) a ogni build, con il contesto ricavato dal tuo codice | Racchiudere i testi in [`<T>`](/docs/react/reference/components/t) e aggiungere un unico passaggio di build |

Usa i18next o next-intl se i traduttori o un sistema di gestione delle traduzioni lavorano già con file di catalogo, oppure se i testi cambiano di rado. Usa Lingui o l&#39;estrazione di next-intl se vuoi il testo sorgente inline e prevedi di inviare i cataloghi in traduzione. Usa General Translation se vuoi i testi inline e tutte le lingue generate a ogni build. I team che preferiscono chiavi stabili possono continuare a usarle con la [modalità dizionario](/docs/react/guides/translating-with-dictionaries) di General Translation.

## Quali sono i pro e i contro dell&#39;i18n basata su chiavi e della traduzione inline?

La traduzione inline mantiene ogni frase nel componente React che la renderizza: in questo modo componenti e pull request restano leggibili e non ci sono chiavi da nominare, sincronizzare o ripulire. Lo svantaggio è che il testo sorgente risiede nel codice, quindi le modifiche ai testi passano dagli sviluppatori. L&#39;i18n basata su chiavi mantiene i testi in cataloghi separati dal codice: questo permette a redattori e traduttori di lavorare senza toccare i componenti, ma richiede, per ogni stringa, una chiave e una voce nel file di ciascuna lingua. General Translation supporta entrambi gli approcci: testo inline con [`<T>`](/docs/react/reference/components/t), oppure chiavi con la modalità dizionario.

| Attività                                 | Chiavi di traduzione (i18next, next-intl)                                                          | Testo inline (General Translation)                                                                                                                           |
| ---------------------------------------- | -------------------------------------------------------------------------------------------------- | ------------------------------------------------------------------------------------------------------------------------------------------------------------ |
| Leggere un componente o una pull request | Vedi `t('summary.tax_notice')` e devi aprire il file JSON per trovare la frase                     | Vedi la frase direttamente nel JSX                                                                                                                           |
| Aggiungere una stringa                   | Scegli un nome per la chiave, aggiungila al file sorgente, poi inseriscila nel file di ogni lingua | Scrivila dentro [`<T>`](/docs/react/reference/components/t); la successiva esecuzione di [`gt translate`](/docs/cli/reference/commands/translate) la traduce |
| Modificare il testo sorgente             | Le altre lingue mantengono la vecchia traduzione finché qualcuno non le aggiorna                   | L&#39;esecuzione successiva ritraduce la voce modificata                                                                                                     |
| Eliminare un componente                  | Le sue chiavi restano in ogni file finché qualcuno o uno script non le rimuove                     | L&#39;esecuzione successiva smette di raccoglierne il contenuto                                                                                              |
| Aggiungere una lingua                    | Crea un file con tutte le chiavi e traducilo                                                       | Aggiungi il codice locale a `locales` in `gt.config.json` ed esegui [`gt translate`](/docs/cli/reference/commands/translate)                                 |
| ID stabili                               | Ogni stringa ne ha uno                                                                             | Facoltativi, con [`$id`](/docs/react/reference/components/t#id) su [`<T>`](/docs/react/reference/components/t) o con la modalità dizionario                  |
| Chi modifica il testo sorgente           | I redattori possono modificare un catalogo senza toccare il codice                                 | Le modifiche ai testi sono modifiche al codice                                                                                                               |

Le chiavi sono la scelta migliore quando i redattori devono modificare il testo sorgente senza toccare il codice, o quando i componenti non devono contenere frasi in nessuna lingua specifica. In questi casi, mantieni le tue chiavi: la [modalità dizionario](/docs/react/guides/translating-with-dictionaries) di General Translation legge un dizionario basato su chiavi e genera comunque le traduzioni.

## Come si aggiunge il supporto multilingua a un&#39;app Next.js App Router senza chiavi di traduzione?

Usa la libreria `gt-next` di General Translation e la CLI `gt` in quattro passaggi, illustrati anche in versione manuale nell&#39;[Avvio rapido per Next.js App Router](/docs/react/nextjs-quickstart):

1. Esegui [`npx gt@latest init`](/docs/cli/reference/commands/init). La procedura guidata di configurazione rileva l&#39;App Router, può installare `gt-next`, aggiungere `withGTConfig` a `next.config.ts` e [`GTProvider`](/docs/react/reference/components/gt-provider) a `app/layout.tsx`, e salva le tue lingue in `gt.config.json`. Può anche salvare una chiave di sviluppo in `.env.local`, in modo che `next dev` traduca i nuovi testi su richiesta. Verifica le modifiche apportate.
2. Racchiudi i testi in [`<T>`](/docs/react/reference/components/t) e aggiungi un menu a discesa [`<LocaleSelector>`](/docs/react/reference/components/locale-selector) per cambiare lingua. [`<T>`](/docs/react/reference/components/t) funziona sia nei Componenti server sia nei Componenti Client.
3. Aggiungi [`npx gt translate`](/docs/cli/reference/commands/translate) prima di `next build` nello script di build.
4. Imposta `GT_PROJECT_ID` e `GT_API_KEY` nel tuo provider di hosting. La chiave usata per la build deve avere abilitati i permessi **Files &gt; Write** e **Translation queue**.

```tsx title="app/page.tsx"
import { T, LocaleSelector } from 'gt-next';

export default function Home() {
  return (
    <main>
      <LocaleSelector />
      <T>
        <h1>Find your next project</h1>
        <p>Explore projects from teams around the world.</p>
      </T>
    </main>
  );
}
```

```json title="package.json"
{
  "scripts": {
    "build": "npx gt translate && next build"
  }
}
```

A ogni build di produzione vengono poi generate le traduzioni per tutte le lingue indicate in `gt.config.json`. Per una guida più dettagliata che include i Componenti Server e Client, consulta [Come aggiungo l&#39;i18n a un&#39;app Next.js con App Router?](/kb/add-i18n-to-nextjs). Per affidare la configurazione a un agente di programmazione, consulta [il flusso di lavoro con agente di programmazione](/kb/ai-agent-i18n-setup).

## Come posso evitare che i file JSON di traduzione perdano la sincronizzazione con il codice sorgente?

Generali dal codice sorgente a ogni build, invece di modificarli a mano. Con i file di chiavi, un&#39;app con 400 stringhe in 12 lingue di destinazione ha 4.800 voci che qualcuno deve tenere allineate al codice. Con General Translation, [`npx gt translate`](/docs/cli/reference/commands/translate) viene eseguito prima della build, raccoglie ogni blocco [`<T>`](/docs/react/reference/components/t) e ogni stringa [`useGT`](/docs/react/reference/hooks/use-gt), traduce i contenuti nuovi o modificati in ciascuna lingua definita in `gt.config.json` e scrive un file JSON per lingua nel percorso `files.gt.output`:

```json title="gt.config.json"
{
  "defaultLocale": "en",
  "locales": ["es", "fr", "ja"],
  "files": {
    "gt": {
      "output": "public/_gt/[locale].json"
    }
  }
}
```

```txt title=".gitignore"
public/_gt/
```

Poiché General Translation rigenera questi file a partire dal codice compilato in ogni build, i file corrispondono sempre a quel codice. L&#39;Avvio rapido di Next.js aggiunge la directory di output a `.gitignore`, dato che si tratta di file generati. Il [flusso di lavoro incrementale](/docs/cli/guides/generating-translations#retranslate) di General Translation traduce solo il contenuto sorgente modificato e riutilizza le traduzioni corrispondenti delle versioni precedenti. Il [tracciamento dei branch](/docs/cli/guides/branching) (`--enable-branching`, disponibile con il piano Starter o con il Piano Enterprise) mantiene le traduzioni di un branch di funzionalità separate da quelle di produzione fino al merge.

Per i team che preferiscono eseguire il commit delle modifiche alle traduzioni nel repository, le [automazioni di Locadex](/docs/platform/locadex/guides/configuring-automations) traducono il contenuto di origine nuovo o aggiornato e, quando l&#39;elenco delle lingue cambia, aggiungono o rimuovono i file delle impostazioni regionali, il tutto tramite pull request. Ogni automazione viene eseguita in base a uno di tre trigger: la modifica di una pull request, il push di un commit oppure l&#39;avvio manuale. Per le configurazioni di CI, consulta [Come mantengo aggiornate le traduzioni a ogni deploy?](/kb/translations-in-ci).

## General Translation può aggiungere automaticamente l&#39;i18n a un&#39;app React?

Sì. General Translation automatizza entrambe le fasi dell&#39;i18n in React: racchiudere i testi da tradurre e generare le traduzioni.

* **In fase di compilazione:** il compilatore di General Translation, `@generaltranslation/compiler`, racchiude il testo JSX traducibile in [`<T>`](/docs/react/reference/components/t) quando imposti `enableAutoJsxInjection` in `files.gt.parsingFlags` all&#39;interno di `gt.config.json`. L&#39;[iniezione automatica di JSX](/docs/cli/guides/using-auto-jsx) funziona nelle single-page app React, nelle app React con rendering lato server e nelle build Next.js con webpack. Con Next.js, per questo flusso di lavoro del compilatore serve webpack; se usi Turbopack, contrassegna direttamente i contenuti con [`<T>`](/docs/react/reference/components/t) oppure affida a Locadex l&#39;aggiunta dei wrapper.
* **Tramite pull request:** Locadex, l&#39;Agente IA di General Translation, esegue un&#39;automazione **Generate code** che racchiude il codice sorgente in [`<T>`](/docs/react/reference/components/t) e in chiamate per le stringhe come [`useGT`](/docs/react/reference/hooks/use-gt), quindi apre una pull request che puoi revisionare o unire con auto-merge.
* **Per le traduzioni:** [`npx gt translate`](/docs/cli/reference/commands/translate) nella tua build, oppure un&#39;automazione Locadex **Generate translations and push**, traduce i contenuti nuovi e modificati in tutte le lingue configurate.

## Quali sono le differenze tra gt-next e next-intl?

next-intl renderizza i messaggi a partire da un catalogo JSON per ogni lingua, scritto dal tuo team o da un servizio esterno. gt-next, la libreria Next.js di General Translation, mantiene i testi inline in [`<T>`](/docs/react/reference/components/t) e genera tutte le traduzioni con [`gt translate`](/docs/cli/reference/commands/translate). Entrambe supportano l&#39;App Router e i Componenti server, ed entrambe sono distribuite con licenza MIT.

Non è necessario cambiare libreria per usare General Translation. La CLI `gt` rileva next-intl, react-i18next e next-i18next da `package.json` e [traduce i relativi file JSON](/docs/cli/guides/generating-translations) preservando la sintassi dei messaggi di ciascuna libreria, così componenti e routing restano invariati. Se in seguito vuoi passare ai testi inline, la [guida alla migrazione](/docs/react/guides/migrating-i18n-libraries) spiega come sostituire le chiavi con [`<T>`](/docs/react/reference/components/t), mantenere i dizionari con [`useTranslations`](/docs/react/reference/hooks/use-translations) e far convivere le due librerie mentre migri una route alla volta. Per un confronto dettagliato, consulta [next-intl vs gt-next](/kb/next-intl-vs-gt-next).

## Come possono i revisori correggere le traduzioni senza modificare i file di traduzione?

I revisori utilizzano l&#39;[Editor di traduzione della dashboard](/docs/platform/dashboard/guides/reviewing-translations) di General Translation, dove possono confrontare le impostazioni regionali fianco a fianco e modificare le traduzioni generate senza aprire i file delle impostazioni regionali né avviare una nuova attività di traduzione. Se invece il tuo team modifica i file scaricati, [`npx gt save-local`](/docs/cli/reference/commands/save-local) carica queste modifiche sulla piattaforma; in alternativa, puoi passare `--save-local` a [`gt translate`](/docs/cli/reference/commands/translate) per sincronizzarle a ogni esecuzione.

Il contesto di traduzione si definisce sia nel codice sia nella dashboard. La [prop `context`](/docs/react/reference/components/t#context) di [`<T>`](/docs/react/reference/components/t) risolve le ambiguità: &quot;Save&quot; in un editor di documenti diventa *speichern* in tedesco, mentre nel senso di risparmiare denaro diventa *sparen*. I [termini del glossario e i prompt personalizzati](/docs/platform/dashboard/guides/defining-context-for-translations) di un gruppo di contesto garantiscono terminologia e tono coerenti in tutta la tua app, nella documentazione e negli altri progetti.

## Dove vengono salvate le traduzioni generate e serve un account?

Le traduzioni generate possono trovarsi in due posti:

* **Nel bundle dell&#39;app:** un [loader locale](/docs/react/guides/storing-translations) importa i file generati, quindi l&#39;app in produzione legge le proprie traduzioni senza effettuare alcuna richiesta a General Translation a runtime. Le nuove traduzioni vengono rilasciate con la build successiva.
* **Sulla CDN di General Translation:** con la [consegna tramite CDN](/docs/react/guides/configuring#delivery), le modifiche pubblicate raggiungono l&#39;app distribuita senza bisogno di una nuova build, compatibilmente con le impostazioni di versione e di cache.

`gt-react` e `gt-next` sono [distribuiti con licenza MIT](https://github.com/generaltranslation/gt) e funzionano senza un account General Translation, a patto che sia tu a fornire le traduzioni. [`npx gt generate`](/docs/cli/reference/commands/generate) genera un file template per ogni impostazione regionale, da tradurre manualmente. La generazione delle traduzioni con [`gt translate`](/docs/cli/reference/commands/translate) si basa invece sul servizio ospitato di General Translation; consulta i [prezzi di General Translation](https://generaltranslation.com/pricing).

## Punti chiave

* Puoi gestire l&#39;i18n senza file di traduzione: `gt-react` e `gt-next` di General Translation mantengono i testi inline in [`<T>`](/docs/react/reference/components/t), senza chiavi di traduzione, mentre [`npx gt translate`](/docs/cli/reference/commands/translate) genera un file per ogni lingua a ogni build.
* I file generati sono output di build: nessuno li modifica né copia chiavi da un file all&#39;altro, quindi restano sempre sincronizzati con il codice.
* Il compilatore di General Translation può racchiudere il JSX in [`<T>`](/docs/react/reference/components/t) in fase di compilazione, mentre Locadex può racchiudere il codice e tradurlo tramite pull request.
* Se usi già next-intl o react-i18next, la CLI `gt` traduce i tuoi cataloghi JSON esistenti, e la modalità dizionario ti permette di mantenere le chiavi, se preferisci.

## Related questions

- [Come si aggiunge l'i18n a un'app Next.js con App Router?](https://generaltranslation.com/it/kb/add-i18n-to-nextjs.mdx): Inizia con gt init per configurare General Translation in un progetto App Router supportato, poi contrassegna il contenuto di origine, genera le traduzioni e verifica il cambio di lingua. gt-next mantiene i testi nel JSX insieme al contesto di traduzione; la CLI, l'editor della Dashboard e Locadex si occupano di generazione, revisione e aggiornamenti continui. Questa guida mostra anche la configurazione esplicita con file locali.
- [Come si internazionalizza un'app con Cursor o Claude Code?](https://generaltranslation.com/it/kb/ai-agent-i18n-setup.mdx): Inizia con il prompt Setup for Agents di General Translation in Cursor o Claude Code, scegli una funzionalità e le lingue di destinazione, poi lascia che sia l'agente a implementare e verificare il risultato. L'accesso tramite browser, la documentazione leggibile dalle macchine e gli strumenti MCP collegano la configurazione alla traduzione e alla revisione. Usa Locadex per automatizzare la localizzazione continua tramite pull request.
- [Come si gestiscono i plurali in React?](https://generaltranslation.com/it/kb/how-to-handle-plurals-in-react.mdx): Per gestire i plurali in React, fornisci per ogni lingua una frase per ciascuna forma plurale e scegli quella corretta in base alle regole del plurale di quella lingua, dato che l'inglese ha 2 forme, il russo 4 e l'arabo 6. Il componente `<Plural>` di General Translation in gt-react e gt-next accetta le tue forme sorgente, e General Translation genera le forme necessarie per ogni lingua di destinazione.
- [Come mantengo le traduzioni aggiornate a ogni distribuzione?](https://generaltranslation.com/it/kb/translations-in-ci.mdx): Esegui la traduzione come passaggio della pipeline prima di ogni build di produzione, così i nuovi testi vengono rilasciati già tradotti insieme alla distribuzione che li introduce. La CLI gt di General Translation lo fa con npx gt translate, usando una chiave API e un ID progetto archiviati come segreti CI.

## Previous and next questions

- Previous question: [Qual è il miglior software di localizzazione per sviluppatori?](https://generaltranslation.com/it/kb/best-localization-software.mdx)
- Next question: [Alternative a Crowdin: General Translation o Crowdin](https://generaltranslation.com/it/kb/general-translation-vs-crowdin.mdx)

## Sitemap

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