# General Translation Knowledge Base: Peut-on faire de l’i18n sans fichiers de traduction ? URL: https://generaltranslation.com/fr/kb/i18n-without-translation-files.mdx Docs index: https://generaltranslation.com/llms.txt Description: Oui. Les bibliothèques gt-react et gt-next de General Translation permettent d’internationaliser React et Next.js sans clés de traduction ni fichier JSON par langue à maintenir. Le texte reste intégré au JSX, dans le composant ``, et la commande gt translate génère les traductions de chaque langue lors de la compilation, en s’appuyant sur le contexte de votre code. Locadex peut les tenir à jour via des pull requests. Category: Internationalisation Last updated: 2026-10-21 Authors: Jackie Chen, Ernest McCarter Published: 2026-05-07 Oui. Les bibliothèques open source `gt-react` et `gt-next` de General Translation vous permettent d’internationaliser (i18n) une application React ou Next.js sans clés de traduction et sans écrire de fichier JSON pour chaque langue. Vous rédigez le texte directement dans votre JSX, à l’intérieur du composant [``](/docs/react/reference/components/t), et [`npx gt translate`](/docs/cli/reference/commands/translate) génère les traductions pour toutes les langues au moment de la compilation. Les bibliothèques à base de clés, comme i18next, react-intl et next-intl, recherchent chaque chaîne de caractères par sa clé dans un fichier de messages propre à chaque langue : chaque nouvelle chaîne exige donc une clé dans chacun de ces fichiers. Une clé ajoutée à `en.json` mais oubliée dans `ja.json`, et c’est une ligne de votre page de paiement en japonais qui reste non traduite. Les fichiers de traduction existent toujours avec General Translation, mais comme artefact de compilation. La CLI génère un fichier par langue et peut publier les traductions sur le CDN de General Translation. Personne ne modifie ces fichiers à la main ni ne recopie de clés de l’un à l’autre. ## 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 `` component, then add `npx gt translate` to your build script so every build writes the translations. ## Puis-je traduire des composants React de manière intégrée plutôt qu'avec un fichier de clés ? Oui. Avec General Translation, chaque phrase reste dans le composant, à l'intérieur de [``](/docs/react/reference/components/t), et la CLI traduit le bloc entier. Avec react-i18next, un récapitulatif de commande récupère chaque chaîne de caractères par sa clé dans un fichier 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 (

{t('summary.title')}

{t('summary.item_count', { count: itemCount })}

{t('summary.tax_notice')}
); } ``` Avec `gt-next`, le même composant conserve le texte anglais directement dans le JSX. Les autres frameworks React importent depuis leur propre paquet, comme `gt-react`. ```tsx title="CheckoutSummary.tsx" import { T, Plural, Num } from 'gt-next'; export function CheckoutSummary({ itemCount }: { itemCount: number }) { return (

Order summary

You have {itemCount} item in your cart.

} other={

You have {itemCount} items in your cart.

} /> Tax is calculated at checkout.
); } ``` La version `gt-next` n'a ni `checkout.json`, ni clés à nommer, ni `ja.json` à mettre à jour. [`npx gt translate`](/docs/cli/reference/commands/translate) envoie chaque bloc [``](/docs/react/reference/components/t) à l'API de General Translation, en utilisant la structure de ses éléments comme contexte, puis génère une traduction pour chaque langue définie dans `gt.config.json`. [``](/docs/react/reference/components/plural) sélectionne la forme du pluriel adaptée à chaque langue (une seule en japonais, six en arabe), et [``](/docs/react/reference/components/num) met en forme le nombre selon le paramètre régional du lecteur. ## Quelles bibliothèques i18n permettent d'écrire du texte directement dans le JSX sans fichiers de clés ? Les bibliothèques `gt-react` et `gt-next` de General Translation vous permettent d'écrire du texte traduisible directement dans le JSX, sans aucun fichier de clés : General Translation se charge de générer les traductions. Lingui et l'extraction expérimentale de next-intl acceptent également les messages intégrés, mais elles les extraient dans des catalogues qu'il reste à faire traduire par votre équipe, des traducteurs ou un service. | Bibliothèque | Où vous rédigez le texte | D'où proviennent les traductions | Ce que votre équipe maintient | | ------------------------------------------- | ----------------------------------------------------------------------------------------------------------------------------------------------------------------------- | ----------------------------------------------------------------------------------------------------------------------------------- | --------------------------------------------------------------------------------------------------------- | | i18next (`react-i18next`) | Des clés dans un fichier JSON par langue | Votre équipe, des traducteurs ou un service | Une clé pour chaque chaîne de caractères, dans le fichier de chaque langue | | next-intl | Des clés dans un catalogue JSON par langue ; les [messages intégrés avec `useExtracted`](https://next-intl.dev/docs/usage/extraction) sont expérimentaux | Votre équipe, des traducteurs ou un service | Chaque catalogue, tenu à jour au fil des modifications du texte | | [Lingui](https://lingui.dev/introduction) | Des macros `` intégrées avec des identifiants de message générés, extraites dans des catalogues PO | Votre équipe, des traducteurs ou un service | L'extraction, la traduction et la compilation des catalogues | | General Translation (`gt-react`, `gt-next`) | Du JSX intégré dans [``](/docs/react/reference/components/t), des chaînes via [`useGT`](/docs/react/reference/hooks/use-gt), ou des dictionnaires à clés facultatifs | Générées par [`npx gt translate`](/docs/cli/reference/commands/translate) à chaque compilation, avec le contexte issu de votre code | L'encapsulation du texte dans [``](/docs/react/reference/components/t) et une étape de compilation | Utilisez i18next ou next-intl lorsque des traducteurs ou un système de gestion de la traduction travaillent déjà à partir de fichiers de catalogue, ou lorsque le texte change rarement. Utilisez Lingui ou l'extraction de next-intl si vous souhaitez garder le texte source intégré au code et prévoyez de faire traduire les catalogues en externe. Utilisez General Translation si vous voulez un texte intégré et toutes les langues générées à chaque compilation. Les équipes qui préfèrent des clés stables peuvent les conserver grâce au [mode dictionnaire](/docs/react/guides/translating-with-dictionaries) de General Translation. ## Quels sont les avantages et les inconvénients de l’i18n par clés et de la traduction intégrée ? La traduction intégrée conserve chaque phrase dans le composant React qui l’affiche : les composants et les pull requests restent lisibles, et il n’y a aucune clé à nommer, synchroniser ou nettoyer. En contrepartie, le texte source se trouve dans le code, et toute modification du texte passe donc par les développeurs. L’i18n par clés conserve le texte dans des catalogues distincts du code, ce qui permet aux rédacteurs et aux traducteurs de travailler sans toucher aux composants, mais impose d’ajouter, pour chaque chaîne de caractères, une clé et une entrée dans le fichier de chaque langue. General Translation prend en charge les deux approches : le texte intégré avec [``](/docs/react/reference/components/t), ou les clés avec le mode dictionnaire. | Tâche | Clés de traduction (i18next, next-intl) | Texte intégré (General Translation) | | ------------------------------------- | ---------------------------------------------------------------------------------------------- | --------------------------------------------------------------------------------------------------------------------------------------------------------- | | Lire un composant ou une pull request | Vous voyez `t('summary.tax_notice')` et devez ouvrir le fichier JSON pour trouver la phrase | Vous voyez la phrase directement dans le JSX | | Ajouter une chaîne de caractères | Nommer une clé, l’ajouter au fichier source, puis la reporter dans le fichier de chaque langue | L’écrire dans [``](/docs/react/reference/components/t) ; la prochaine exécution de [`gt translate`](/docs/cli/reference/commands/translate) la traduit | | Modifier le texte source | Les autres langues conservent l’ancienne traduction jusqu’à ce que quelqu’un les mette à jour | La prochaine exécution retraduit l’entrée modifiée | | Supprimer un composant | Ses clés restent dans chaque fichier jusqu’à ce qu’une personne ou un script les supprime | La prochaine exécution cesse de collecter son contenu | | Ajouter une langue | Créer un fichier contenant toutes les clés et le traduire | Ajouter le code de langue à `locales` dans `gt.config.json` et exécuter [`gt translate`](/docs/cli/reference/commands/translate) | | Identifiants stables | Chaque chaîne de caractères en possède un | Facultatifs, avec [`$id`](/docs/react/reference/components/t#id) sur [``](/docs/react/reference/components/t) ou le mode dictionnaire | | Qui modifie le texte source | Les rédacteurs peuvent modifier un catalogue sans toucher au code | Toute modification du texte est une modification du code | Les clés sont plus adaptées lorsque les rédacteurs modifient le texte source sans toucher au code, ou lorsque les composants ne doivent contenir aucune phrase dans une langue particulière. Dans ce cas, conservez vos clés : le [mode dictionnaire](/docs/react/guides/translating-with-dictionaries) de General Translation lit un dictionnaire à clés et génère malgré tout les traductions. ## Comment ajouter la prise en charge multilingue à une application Next.js App Router sans clés de traduction ? Utilisez la bibliothèque `gt-next` de General Translation et la CLI `gt` en quatre étapes, que le [Démarrage rapide Next.js App Router](/docs/react/nextjs-quickstart) présente également en version manuelle : 1. Exécutez [`npx gt@latest init`](/docs/cli/reference/commands/init). L’assistant de configuration initiale détecte l’App Router, peut installer `gt-next`, ajouter `withGTConfig` à `next.config.ts` et [`GTProvider`](/docs/react/reference/components/gt-provider) à `app/layout.tsx`, et enregistre vos langues dans `gt.config.json`. Il peut également enregistrer une clé de développement dans `.env.local`, afin que `next dev` traduise les nouveaux textes à la demande. Vérifiez les modifications qu’il apporte. 2. Encapsulez vos textes dans [``](/docs/react/reference/components/t) et ajoutez une liste déroulante [``](/docs/react/reference/components/locale-selector) pour changer de langue. [``](/docs/react/reference/components/t) fonctionne aussi bien dans les Composants Serveur que dans les Composants Client. 3. Placez [`npx gt translate`](/docs/cli/reference/commands/translate) avant `next build` dans votre script de compilation. 4. Définissez `GT_PROJECT_ID` et `GT_API_KEY` chez votre hébergeur. La clé utilisée lors de la compilation doit disposer des autorisations **Files > Write** et **Translation queue**. ```tsx title="app/page.tsx" import { T, LocaleSelector } from 'gt-next'; export default function Home() { return (

Find your next project

Explore projects from teams around the world.
); } ``` ```json title="package.json" { "scripts": { "build": "npx gt translate && next build" } } ``` Chaque compilation de production génère ensuite les traductions pour toutes les langues définies dans `gt.config.json`. Pour un guide plus détaillé couvrant les Composants Serveur et Client, consultez [Comment ajouter l'i18n à une application Next.js App Router ?](/kb/add-i18n-to-nextjs). Pour confier la configuration initiale à un agent de codage, consultez [le workflow avec agent de codage](/kb/ai-agent-i18n-setup). ## Comment éviter que les fichiers JSON de traduction se désynchronisent de mon code source ? Générez-les à partir du code source à chaque compilation au lieu de les modifier à la main. Avec des fichiers de clés, une application comptant 400 chaînes dans 12 langues cibles représente 4 800 entrées que quelqu'un doit maintenir alignées sur le code. Avec General Translation, [`npx gt translate`](/docs/cli/reference/commands/translate) s'exécute avant la compilation, collecte chaque bloc [``](/docs/react/reference/components/t) et chaque chaîne [`useGT`](/docs/react/reference/hooks/use-gt), traduit les contenus nouveaux ou modifiés dans chaque langue définie dans `gt.config.json`, puis écrit un fichier JSON par langue dans le chemin `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/ ``` Comme General Translation régénère ces fichiers à partir du code compilé à chaque compilation, ils correspondent toujours à ce code. Le Démarrage rapide Next.js ajoute le répertoire de sortie au fichier `.gitignore`, puisque ces fichiers sont générés. Le [workflow incrémental](/docs/cli/guides/generating-translations#retranslate) de General Translation ne traduit que la source modifiée et réutilise les traductions correspondantes des versions précédentes. Le [suivi des branches](/docs/cli/guides/branching) (`--enable-branching`, avec un plan Starter ou Enterprise) isole les traductions d'une branche de fonctionnalité de la Production jusqu'à sa fusion. Pour les équipes qui souhaitent que les modifications de traduction soient commitées dans le dépôt, les [automatisations Locadex](/docs/platform/locadex/guides/configuring-automations) traduisent le contenu source nouveau ou mis à jour, et ajoutent ou suppriment des fichiers de paramètres régionaux lorsque votre liste de langues change, via des pull requests. Chaque automatisation se déclenche de l'une des trois façons suivantes : modification d'une pull request, push d'un commit ou lancement manuel. Pour les configurations CI, consultez [Comment maintenir les traductions à jour à chaque déploiement ?](/kb/translations-in-ci). ## General Translation peut-il ajouter automatiquement l'i18n à une application React ? Oui. General Translation automatise les deux étapes de l'i18n dans React : l'encapsulation des textes à traduire et la génération des traductions. * **Au moment du build :** le compilateur General Translation, `@generaltranslation/compiler`, encapsule le texte JSX traduisible dans [``](/docs/react/reference/components/t) lorsque vous activez `enableAutoJsxInjection` sous `files.gt.parsingFlags` dans `gt.config.json`. L'[injection automatique de JSX](/docs/cli/guides/using-auto-jsx) fonctionne dans les applications monopages React, les applications React avec rendu côté serveur et les compilations Next.js avec webpack. Pour Next.js, utilisez webpack pour ce workflow du compilateur ; avec Turbopack, balisez directement le contenu avec [``](/docs/react/reference/components/t) ou laissez Locadex ajouter les composants d'encapsulation. * **Via des pull requests :** Locadex, l'agent IA de General Translation, exécute une automatisation **Generate code** qui encapsule votre code source dans [``](/docs/react/reference/components/t) et dans des appels de traduction de chaînes de caractères tels que [`useGT`](/docs/react/reference/hooks/use-gt), puis ouvre une pull request que vous pouvez relire ou fusionner automatiquement grâce à l'auto-merge. * **Pour les traductions :** [`npx gt translate`](/docs/cli/reference/commands/translate) intégré à votre compilation, ou une automatisation Locadex **Generate translations and push**, traduit le contenu nouveau ou modifié dans chacune des langues configurées. ## Comment gt-next se compare-t-il à next-intl ? next-intl affiche des messages à partir d'un catalogue JSON par langue, rédigé par votre équipe ou par un service. gt-next, la bibliothèque Next.js de General Translation, conserve les textes intégrés dans [``](/docs/react/reference/components/t) et génère toutes les traductions avec [`gt translate`](/docs/cli/reference/commands/translate). Les deux prennent en charge l'App Router et les Composants Serveur, et sont tous deux sous licence MIT. Nul besoin de changer de bibliothèque pour utiliser General Translation. Le CLI `gt` détecte next-intl, react-i18next et next-i18next à partir de `package.json` et [traduit leurs fichiers JSON](/docs/cli/guides/generating-translations) en préservant la syntaxe de message propre à chaque bibliothèque : vos composants et votre routage restent inchangés. Si vous souhaitez ensuite passer à des textes intégrés, le [guide de migration](/docs/react/guides/migrating-i18n-libraries) explique comment remplacer les clés par [``](/docs/react/reference/components/t), conserver les dictionnaires avec [`useTranslations`](/docs/react/reference/hooks/use-translations) et faire cohabiter les deux bibliothèques le temps de migrer une route après l'autre. Pour une comparaison détaillée, consultez [next-intl vs gt-next](/kb/next-intl-vs-gt-next). ## Comment les relecteurs corrigent-ils les traductions sans modifier les fichiers de traduction ? Les relecteurs utilisent l'[Éditeur de Traduction du tableau de bord](/docs/platform/dashboard/guides/reviewing-translations) de General Translation. Ils comparent les paramètres régionaux côte à côte et modifient les traductions générées sans ouvrir les fichiers de paramètres régionaux ni lancer de nouvelle tâche de traduction. Si votre équipe préfère modifier les fichiers téléchargés, [`npx gt save-local`](/docs/cli/reference/commands/save-local) téléverse ces modifications sur la plateforme ; vous pouvez aussi passer `--save-local` à [`gt translate`](/docs/cli/reference/commands/translate) pour les synchroniser à chaque exécution. Le contexte de traduction se définit dans le code et dans le tableau de bord. La [prop `context`](/docs/react/reference/components/t#context) de [``](/docs/react/reference/components/t) permet de lever l'ambiguïté sur certains mots : « Save » dans un éditeur de documents se traduit par *speichern* en allemand, alors qu'au sens d'économiser de l'argent, il se traduit par *sparen*. Les [termes du glossaire et les instructions personnalisées](/docs/platform/dashboard/guides/defining-context-for-translations) d'un groupe de contexte garantissent une terminologie et un ton cohérents dans votre application, votre documentation et vos autres projets. ## Où sont stockées les traductions générées, et ai-je besoin d'un compte ? Les traductions générées sont stockées à l'un de ces deux endroits : * **Intégrées à votre application :** un [loader local](/docs/react/guides/storing-translations) importe les fichiers générés : l'application en production lit donc ses propres traductions et n'envoie aucune requête à General Translation à l'exécution. Les nouvelles traductions sont livrées avec la compilation suivante. * **Sur le CDN de General Translation :** avec la [livraison via CDN](/docs/react/guides/configuring#delivery), les modifications publiées parviennent à l'application déployée sans recompilation, selon ses paramètres de version et de cache. `gt-react` et `gt-next` sont [sous licence MIT](https://github.com/generaltranslation/gt) et fonctionnent sans compte General Translation si vous fournissez vous-même les traductions. [`npx gt generate`](/docs/cli/reference/commands/generate) génère un fichier modèle par paramètre régional, à traduire manuellement. La génération de traductions avec [`gt translate`](/docs/cli/reference/commands/translate) passe par le service hébergé de General Translation ; consultez [les tarifs de General Translation](https://generaltranslation.com/pricing). ## Points clés * Vous pouvez faire de l'i18n sans fichiers de traduction : avec `gt-react` et `gt-next` de General Translation, le texte reste intégré dans [``](/docs/react/reference/components/t), sans clés de traduction, et [`npx gt translate`](/docs/cli/reference/commands/translate) génère un fichier par langue à chaque compilation. * Les fichiers générés sont des artefacts de compilation. Personne ne les modifie ni n'y recopie de clés d'un fichier à l'autre : ils restent donc synchronisés avec le code. * Le compilateur de General Translation peut encapsuler le JSX dans [``](/docs/react/reference/components/t) au moment du build, et Locadex peut encapsuler le code et le traduire au moyen de pull requests. * Si vous utilisez déjà next-intl ou react-i18next, la CLI `gt` traduit vos catalogues JSON existants, et le mode dictionnaire vous permet de conserver les clés si vous y tenez. ## Related questions - [Comment ajouter l’i18n à une application Next.js App Router ?](https://generaltranslation.com/fr/kb/add-i18n-to-nextjs.mdx): Commencez par gt init pour configurer General Translation dans un projet App Router pris en charge, puis balisez le contenu source, générez les traductions et vérifiez le changement de langue. gt-next conserve les textes dans le JSX avec leur contexte de traduction ; la CLI, l’éditeur du tableau de bord et Locadex prennent en charge la génération, la relecture et les mises à jour continues. Ce guide présente également la configuration initiale explicite avec des fichiers locaux. - [Comment internationaliser une application avec Cursor ou Claude Code ?](https://generaltranslation.com/fr/kb/ai-agent-i18n-setup.mdx): Commencez par le prompt Setup for Agents de General Translation dans Cursor ou Claude Code, choisissez une fonctionnalité et des langues cibles, puis laissez l’agent implémenter et vérifier le résultat. La connexion via le navigateur, la documentation lisible par machine et les outils MCP font le lien entre la configuration initiale, la traduction et la relecture. Utilisez Locadex pour automatiser la localisation continue au moyen de pull requests. - [Comment gérer les formes plurielles dans React ?](https://generaltranslation.com/fr/kb/how-to-handle-plurals-in-react.mdx): Pour gérer les formes plurielles dans React, fournissez à chaque langue une phrase par forme du pluriel et sélectionnez-la selon les règles de pluriel de cette langue, car l’anglais compte 2 formes, le russe 4 et l’arabe 6. Le composant `` de General Translation, disponible dans gt-react et gt-next, prend vos formes source, et General Translation génère les formes requises par chaque langue cible. - [Comment maintenir les traductions à jour à chaque déploiement ?](https://generaltranslation.com/fr/kb/translations-in-ci.mdx): Exécutez la traduction comme une étape du pipeline avant chaque compilation de production, afin que les nouveaux textes soient livrés traduits avec le déploiement qui les ajoute. Le CLI gt de General Translation s’en charge avec npx gt translate, à l’aide d’une clé API de projet et d’un identifiant de projet stockés comme secrets CI. ## Previous and next questions - Previous question: [Quel est le meilleur logiciel de localisation pour les développeurs ?](https://generaltranslation.com/fr/kb/best-localization-software.mdx) - Next question: [Alternatives à Crowdin : General Translation ou Crowdin](https://generaltranslation.com/fr/kb/general-translation-vs-crowdin.mdx) ## Sitemap See the [Knowledge Base sitemap](https://generaltranslation.com/fr/kb/sitemap.md) for every article.