Traduction Django pour les développeurs solo : de semaines à minutes

Vous avez construit une application Django. Elle fonctionne, les utilisateurs s'inscrivent, et maintenant vous voulez atteindre des personnes qui ne parlent pas anglais. Le problème est évident dès qu'on y regarde : le framework d'internationalisation de Django est excellent pour extraire les chaînes traduisibles, mais il ne fait absolument rien pour remplir les traductions. Cette partie, c'est à vous de la faire.

Si vous êtes un développeur solo ou une équipe de deux personnes, le fossé entre makemessages et une application entièrement traduite peut sembler énorme. Je vais passer en revue les options réalistes, expliquer pourquoi la plupart échouent pour les petites équipes, et montrer un workflow qui transforme la traduction d'une corvée de plusieurs semaines en une commande de deux minutes.

Les Options Traditionnelles (et Pourquoi Elles Font Mal)

Option 1 : Copier-Coller depuis Google Translate

La première tentative la plus courante. Vous ouvrez votre fichier .po, copiez chaque msgid dans Google Translate, collez le résultat en tant que msgstr, et recommencez. Pour chaque chaîne. Dans chaque langue.

Une application Django typique contient 200 à 500 chaînes traduisibles. Si vous traduisez dans cinq langues, cela fait 1 000 à 2 500 cycles de copier-coller. Même si chacun ne prend que 30 secondes, vous en avez pour 8 à 20 heures de travail abrutissant. Et c'est avant de corriger les erreurs de formatage, les placeholders cassés et les incohérences terminologiques qui s'infiltrent inévitablement.

Pire encore, il faut tout refaire au sprint suivant quand vous ajoutez de nouvelles chaînes.

Option 2 : Traducteurs Professionnels

La traduction professionnelle coûte généralement entre 0,10 $ et 0,25 $ par mot. Une application Django avec 500 chaînes de 8 mots en moyenne représente environ 4 000 mots. À 0,15 $/mot, cela fait 600 $ par langue, soit 3 000 $ pour cinq langues.

Pour une startup financée par du capital-risque, c'est une erreur d'arrondi. Pour un développeur solo qui facture 9 $/mois par utilisateur, cela peut engloutir la totalité de vos revenus du trimestre.

Option 3 : Fiverr et les Places de Marché Freelance

Vous pouvez trouver des traducteurs sur Fiverr pour 20-50 $ par langue. Certains sont véritablement compétents. Beaucoup se contentent de coller votre texte dans Google Translate et vous facturent pour le privilège. Vous vous retrouvez avec la même qualité que l'Option 1, plus un aller-retour de communication supplémentaire et une semaine d'attente.

Option 4 : Crowdin, Transifex ou Weblate

Ces plateformes sont puissantes, mais elles sont conçues pour des projets avec des équipes de traduction dédiées. Les coûts de mise en place (synchronisation des dépôts, configuration de la mémoire de traduction, gestion des accès contributeurs) sont excessifs quand vous êtes la seule personne sur le projet. Les abonnements mensuels commencent à 30-150 $/mois pour les niveaux payants, et même les niveaux gratuits vous obligent à maintenir encore une autre intégration tierce.

Option 5 : Tout Coller dans ChatGPT

Cela fonctionne en fait étonnamment bien en termes de qualité. Vous collez le contenu de votre fichier .po dans ChatGPT ou Claude, demandez des traductions, et obtenez des résultats raisonnables. Le problème est que ça ne passe pas à l'échelle. Vous devez extraire manuellement les chaînes non traduites, formater le prompt, parser la réponse au format .po, et gérer le découpage quand vous dépassez les limites de contexte. Ça marche une fois. Ça s'effondre en tant que workflow reproductible.

L'Approche par l'Automatisation

Et si toute l'étape de traduction se résumait à une seule commande ? C'est l'idée derrière TranslateBot, une commande de gestion Django open source qui lit vos fichiers .po, envoie les chaînes non traduites à un fournisseur d'IA, et réécrit les traductions dans le bon format.

Voici comment le mettre en place.

Étape 1 : Installer TranslateBot

uv add --dev translatebot-django

Ou avec pip :

pip install translatebot-django

Ajoutez-le à vos applications installées :

# settings.py
INSTALLED_APPS = [
    # ...
    'translatebot_django',
]

Étape 2 : Configurer Votre Fournisseur d'IA

Ajoutez deux paramètres :

# settings.py
import os

TRANSLATEBOT_API_KEY = os.getenv("OPENAI_API_KEY")
TRANSLATEBOT_MODEL = "gpt-4o-mini"

TranslateBot fonctionne avec OpenAI, Anthropic Claude, Google Gemini, et plus de 100 autres modèles via LiteLLM. Il prend également en charge DeepL comme backend de traduction dédié.

Étape 3 : Créer un TRANSLATING.md (Optionnel mais Recommandé)

Un fichier TRANSLATING.md à la racine de votre projet donne à l'IA du contexte sur votre application. C'est ce qui distingue la traduction automatique générique des traductions qui correspondent réellement à votre produit :

# Translation Context

## About This Project
A personal finance tracker for freelancers. Users track invoices,
expenses, and tax obligations.

## Tone
- Friendly and informal
- Use "du" in German, "tu" in French
- Keep financial terms precise

## Terminology
- "invoice" = "Rechnung" (German), "facture" (French)
- "dashboard" = keep as English loanword in all languages
- "freelancer" = keep as English loanword in German

Ce fichier est envoyé avec chaque demande de traduction, afin que l'IA utilise systématiquement le bon ton et la bonne terminologie.

Étape 4 : Traduire

python manage.py makemessages -l de -l fr -l nl -l es -l ja
python manage.py translate
python manage.py compilemessages

Trois commandes. C'est tout. TranslateBot trouve toutes les chaînes non traduites dans tous vos fichiers .po, les traduit par lots, et réécrit les résultats. Par défaut, seules les entrées vides sont traduites, donc relancer la commande après avoir ajouté de nouvelles chaînes ne traduit que les nouvelles.

Ce Que Cela Donne en Pratique

Voici un workflow de sprint réaliste pour un développeur solo gérant cinq langues :

Lundi : Vous développez une nouvelle fonctionnalité. Vous ajoutez quelques nouvelles chaînes traduisibles en utilisant gettext() et {% trans %} au fil du développement.

from django.utils.translation import gettext_lazy as _

class InvoiceView(View):
    def post(self, request):
        # New string added during development
        messages.success(request, _("Invoice sent successfully."))

Avant de commiter : Vous exécutez trois commandes :

python manage.py makemessages -a --no-obsolete
python manage.py translate
python manage.py compilemessages

La commande translate détecte les nouvelles entrées non traduites et ne traduit que celles-ci. Si vous avez ajouté 5 nouvelles chaînes et que vous gérez 5 langues, elle effectue 25 traductions en un seul appel API. L'ensemble du processus prend moins d'une minute.

Vous commitez votre code, vos templates et vos fichiers .po/.mo mis à jour ensemble. Les traductions font partie de votre flux de développement normal, pas d'un projet séparé.

Aperçu Avant de Commiter

Si vous voulez voir les traductions avant qu'elles ne soient écrites sur le disque, utilisez le mode dry-run :

python manage.py translate --dry-run

Cela affiche chaque traduction dans le terminal sans modifier aucun fichier.

La Comparaison des Coûts

C'est ici que l'automatisation devient difficile à contester.

Une application Django de petite à moyenne taille avec environ 500 chaînes traduisibles coûte généralement moins de 0,01 $ par langue avec gpt-4o-mini. Pour la plupart des projets solo, le niveau gratuit de DeepL (500 000 caractères/mois) couvre tout à coût zéro.

Soyons clairs : les traductions par IA ne sont pas parfaites. Les traductions humaines à petit budget non plus. La différence, c'est que les traductions par IA ne coûtent presque rien, arrivent instantanément, et peuvent être relancées quand vous voulez.

Intégration CI : Ne Livrez Jamais de Chaînes Non Traduites

L'un des patterns les plus utiles que j'ai trouvés en tant que développeur solo est d'ajouter une vérification des traductions dans le CI. TranslateBot inclut une commande check_translations qui échoue si un fichier .po contient des entrées non traduites ou floues :

# .github/workflows/ci.yml
jobs:
  translations:
    runs-on: ubuntu-latest
    steps:
      - uses: actions/checkout@v4
      - uses: astral-sh/setup-uv@v4
        with:
          enable-cache: true
      - run: uv python install
      - run: uv sync --frozen
      - name: Install gettext
        run: sudo apt-get update && sudo apt-get install -y --no-install-recommends gettext
      - name: Check translations
        run: uv run python manage.py check_translations --makemessages

Si vous ajoutez un nouveau tag {% trans %} dans un template et oubliez de lancer translate, le CI le détectera :

locale/de/LC_MESSAGES/django.po: 1 untranslated, 0 fuzzy
locale/fr/LC_MESSAGES/django.po: 1 untranslated, 0 fuzzy
CommandError: Translation check failed

Cela transforme les traductions de quelque chose qu'on doit penser à faire en quelque chose qu'on ne peut pas oublier.

Conseils Pratiques

Commencez par deux ou trois langues. Vous n'avez pas besoin de lancer dans 15 langues le premier jour. Choisissez celles où vous avez le plus d'utilisateurs ou le plus grand marché adressable. L'allemand, le français et l'espagnol couvrent beaucoup de terrain pour les marchés européens.

Faites relire les chaînes critiques par des locuteurs natifs. Les traductions par IA sont suffisamment bonnes pour la plupart des textes d'interface, mais le titre de votre page d'accueil et le flux d'onboarding méritent un regard humain. Demandez à un ami, un utilisateur ou quelqu'un dans un forum communautaire de passer 10 minutes à relire les chaînes les plus visibles.

Utilisez dry-run avant d'écraser. Si vous avez besoin de tout retraduire (par exemple, après avoir mis à jour votre TRANSLATING.md avec de meilleures directives terminologiques), prévisualisez d'abord les changements :

python manage.py translate --overwrite --dry-run

Gardez TRANSLATING.md dans le contrôle de version. C'est une partie de la configuration de traduction de votre projet. Quand vous mettez à jour les directives de terminologie ou de ton, la prochaine exécution de translate reflétera ces changements pour toutes les nouvelles chaînes.

Traduisez par application si nécessaire. Si vous n'avez modifié des chaînes que dans une seule application, vous pouvez limiter la portée de la traduction :

python manage.py translate --app billing

De Semaines à Minutes

Le framework d'internationalisation de Django est l'un des meilleurs de tous les frameworks web. Les outils pour makemessages, les répertoires de locale et compilemessages sont matures et fiables. La seule pièce manquante était l'étape de traduction elle-même. C'était la partie coûteuse et lente.

Avec TranslateBot, le workflow devient :

1. Écrire du code avec gettext() et {% trans %} comme d'habitude
2. Lancer makemessages pour extraire les chaînes
3. Lancer translate pour remplir les traductions
4. Lancer compilemessages pour compiler
5. Tout commiter ensemble

Pour un développeur solo, cela signifie que la localisation n'est plus un projet que vous planifiez pour "un jour". C'est quelque chose que vous pouvez faire aujourd'hui, le temps de préparer une tasse de café.

TranslateBot est open source et disponible sur PyPI et GitHub. Installez-le, lancez la commande, et voyez votre application dans une nouvelle langue en quelques minutes.