Traduire les fichiers de chaînes d’une application n’a rien à voir avec traduire de la prose. Chaque valeur est courte, souvent sans contexte, et porte une syntaxe que le modèle ne doit pas toucher : variables, balises HTML et règles de pluriel. L’arabe rend la dernière difficile. Les fichiers anglais contiennent deux formes plurielles ; l’arabe en exige six. Cet article construit une petite chaîne sur un LLM compatible OpenAI : figer les variables, demander six chaînes plurielles simples, assembler la syntaxe ICU dans le code, puis tout valider en CI.
Pour traduire des documents, des tickets et des contrats, voir Traduction arabe–anglais avec des LLM, qui traite du ton, des glossaires et de l’évaluation pour la prose.
Pourquoi les pluriels arabes cassent-ils les fichiers de chaînes traduits automatiquement ?
Unicode CLDR, que suivent Intl.PluralRules, ICU et i18next, donne à l’arabe six catégories cardinales :
| Catégorie | Règle CLDR | Exemples de nombres | Exemple : « fichier » |
|---|---|---|---|
| zero | n = 0 | 0 | لا توجد ملفات |
| one | n = 1 | 1 | ملف واحد |
| two | n = 2 | 2 | ملفان (duel) |
| few | n % 100 = 3..10 | 3–10, 103–110 | 5 ملفات (pluriel) |
| many | n % 100 = 11..99 | 11–99, 111 | 11 ملفًا (singulier, accusatif) |
| other | tout le reste | 100–102, 1000, 0.5 | 100 ملف (singulier) |
Deux détails piègent les gens. D’abord, les catégories ne sont pas les nombres : 103 est few et 111 est many. Ensuite, une source anglaise ne donne au modèle que one et other ; il doit donc inventer quatre formes à partir de la seule grammaire. La plupart des échecs viennent d’un modèle qui recopie la paire anglaise.
L’échec est silencieux. Nous avons rendu avec intl-messageformat 12.1.5 un message arabe qui n’avait que one et other : 0, 2 et 11 fichiers sortaient tous en « N ملف ». i18next 27.1.2 s’est comporté de même quand la clé _many manquait : 11 fichiers affichaient le texte de _other. Pas d’erreur, pas d’avertissement, juste un arabe faux.
Comment envoyer les chaînes au modèle ?
Regroupez-les. Une requête par chaîne gaspille des tokens sur le prompt système et perd le contexte entre chaînes liées. Envoyez 50 à 200 clés à la fois sous forme d’objet JSON, groupées par écran ou par fonction, pour que « Save » à côté de « Cancel » se lise comme un bouton.
Trois règles rendent la réponse vérifiable :
- Figer les variables. Remplacez
{name}, les variables i18next à doubles accolades,%s,%1$set les balises comme<b>par des marqueurs comme ⟦0⟧. Le modèle voit « Welcome back, ⟦0⟧! » et ne peut pas traduirenameen اسم. - Demander les formes plurielles en chaînes simples. Envoyez les textes anglais
oneetotheret demandez six chaînes arabes. Le code construit la syntaxe ICU. Le modèle n’écrit jamais d’accolade. - Fournir un glossaire et une liste de termes à ne pas traduire. Noms de produits, noms de forfaits et termes qu’utilise votre support. La section glossaire de l’article sur la traduction explique pourquoi cela compte plus que le choix du modèle.
Le script de traduction
Le fichier source utilise ICU MessageFormat, la syntaxe que documente FormatJS. Le même gel fonctionne pour le format JSON propre à i18next, dont les clés de pluriel se terminent par _zero, _one, _two, _few, _many et _other.
{
"save": "Save",
"welcome": "Welcome back, {name}!",
"invite": "<b>{inviter}</b> invited you to the {workspace} workspace",
"billing": "Pay with AcmePay",
"files": "{count, plural, one {# file} other {# files}}"
}
import json, os, re
from openai import OpenAI
client = OpenAI(base_url="https://inference.broadnet.ai/v1", api_key=os.environ["BROADNET_API_KEY"])
FORMS = ["zero", "one", "two", "few", "many", "other"]
# ICU arguments, double-brace and printf placeholders, HTML-style tags
PH = re.compile(r"\{\{\s*\w+\s*\}\}|\{\w+\}|%(?:\d+\$)?[sdif@]|</?\w+[^>]*>")
PLURAL = re.compile(r"^\{(\w+), plural,(.*)\}$", re.S)
def freeze(text):
"""Replace each placeholder with ⟦n⟧ so the model cannot translate or break it."""
found = PH.findall(text)
for i, p in enumerate(found):
text = text.replace(p, f"⟦{i}⟧", 1)
return text, found
def thaw(text, found):
for i, p in enumerate(found):
text = text.replace(f"⟦{i}⟧", p)
return text
def branches(body):
"""'one {# file} other {# files}' -> {'one': '# file', 'other': '# files'}."""
out, i = {}, 0
while i < len(body):
m = re.compile(r"\s*([=\w]+)\s*\{").match(body, i)
if not m:
break
depth, j = 1, m.end()
while depth:
depth += {"{": 1, "}": -1}.get(body[j], 0)
j += 1
out[m.group(1)] = body[m.end():j - 1]
i = j
return out
SYSTEM = """You translate app interface strings from English to Modern Standard Arabic.
Reply with one JSON object only: {"STRINGS": {key: Arabic}, "PLURALS": {key: {six forms}}}.
Rules:
- ⟦0⟧, ⟦1⟧ ... are placeholders. Keep every one exactly once and unchanged; move it if Arabic word order needs it.
- # stands for the number. Keep it where the number should appear.
- Interface style: short, no full stops on buttons or labels.
- Never translate terms in DO_NOT_TRANSLATE. Use GLOSSARY translations exactly.
- For each PLURALS key, return all six Arabic forms: zero, one, two, few, many, other.
zero = none; one = singular without a number; two = dual without a number;
few = 3-10: # + plural noun; many = 11-99: # + singular noun in the accusative;
other = 100, 1000 and also 0.5 and 1.5: # + singular noun."""
def translate(src, glossary=None, dnt=(), model="broadnet/qwen3.8-27b"):
strings, plurals, frozen = {}, {}, {}
for key, text in src.items():
m = PLURAL.match(text)
if m:
b = branches(m.group(2))
fone, ph = freeze(b.get("one", b["other"]))
fother, _ = freeze(b["other"])
plurals[key] = {"one": fone, "other": fother}
frozen[key] = (m.group(1), ph)
elif "{" in PH.sub("", text):
raise ValueError(f"{key}: nested ICU, send to a human")
else:
strings[key], ph = freeze(text)
frozen[key] = (None, ph)
payload = {"STRINGS": strings, "PLURALS": plurals,
"GLOSSARY": glossary or {}, "DO_NOT_TRANSLATE": list(dnt)}
r = client.chat.completions.create(
model=model, max_tokens=4000, temperature=0.2,
messages=[{"role": "system", "content": SYSTEM},
{"role": "user", "content": json.dumps(payload, ensure_ascii=False)}])
out = json.loads(r.choices[0].message.content)
ar = {k: thaw(v, frozen[k][1]) for k, v in out.get("STRINGS", {}).items() if k in frozen}
for k, forms in out.get("PLURALS", {}).items():
if k not in frozen:
continue
arg, ph = frozen[k]
ar[k] = "{%s, plural, %s}" % (arg, " ".join(
f + " {" + thaw(forms[f], ph) + "}" for f in FORMS if f in forms))
return ar
en = json.load(open("en.json"))
ar = translate(en, glossary={"workspace": "مساحة العمل"}, dnt=["AcmePay"])
json.dump(ar, open("ar.json", "w"), ensure_ascii=False, indent=2)
Nous l’avons exécuté avec le SDK Python d’OpenAI contre un serveur fictif local, pas contre l’API réelle, avec une réponse arabe préenregistrée. La requête que verrait le modèle contenait « Welcome back, ⟦0⟧! » et « ⟦0⟧⟦1⟧⟦2⟧ invited you to the ⟦3⟧ workspace », et le script a écrit ce ar.json :
{
"save": "حفظ",
"welcome": "مرحبًا بعودتك يا {name}!",
"invite": "دعاك <b>{inviter}</b> إلى مساحة العمل {workspace}",
"billing": "ادفع عبر AcmePay",
"files": "{count, plural, zero {لا توجد ملفات} one {ملف واحد} two {ملفان} few {# ملفات} many {# ملفًا} other {# ملف}}"
}
Remarques sur le code :
- Les marqueurs se déplacent, ils ne disparaissent pas. L’arabe place souvent le verbe en tête, donc ⟦0⟧ peut bouger. Le contrôle ci-dessous compte les marqueurs ; leur position lui est indifférente.
- L’ICU imbriqué part chez un humain. Un
selectdans unpluralest rare et facile à casser. Le script le refuse plutôt que de deviner. max_tokens=4000laisse de la place au raisonnement. D’après la documentation de BroadNet, DeepSeek V4.1 Flash, GLM 5.3 et Qwen3.8 27B raisonnent avant de répondre, et ce raisonnement compte dans max_tokens. Voir réponses vides des modèles de raisonnement.json.loadspeut échouer. Encadrez-le et renvoyez une fois avec l’erreur ; réparer un JSON invalide produit par un LLM propose une fonction de réparation testée. Sur GLM 5.3 et Qwen3.8 27B, les deux modèles BroadNet documentés avec sortie structurée, ajoutez aussi un schémaresponse_format. Le contrôle ci-dessous reste nécessaire dans tous les cas.
Comment valider le fichier arabe en CI ?
Analysez chaque message avec le parser qu’utilise votre application à l’exécution, et comparez-le à la source. Ce script Node utilise @formatjs/icu-messageformat-parser (version 3.5.23 dans notre test) :
// node check-ar.mjs en.json ar.json -> exits 1 on any problem
import { readFileSync } from "node:fs";
import { parse, TYPE } from "@formatjs/icu-messageformat-parser";
const AR_FORMS = ["zero", "one", "two", "few", "many", "other"];
const [en, ar] = process.argv.slice(2).map((p) => JSON.parse(readFileSync(p, "utf8")));
const errors = [];
// Collect argument and tag names; return the plural elements too.
function walk(nodes, names = [], plurals = []) {
for (const n of nodes) {
if (n.type === TYPE.literal || n.type === TYPE.pound) continue;
names.push(n.type === TYPE.tag ? `<${n.value}>` : `{${n.value}}`);
if (n.type === TYPE.tag) walk(n.children, names, plurals);
if (n.type === TYPE.plural) plurals.push(n);
if (n.options) for (const o of Object.values(n.options)) walk(o.value, [], plurals);
}
return { names: names.sort().join(" "), plurals };
}
for (const key of Object.keys(en)) {
if (!(key in ar)) { errors.push(`${key}: missing`); continue; }
let src, dst;
try { src = walk(parse(en[key])); dst = walk(parse(ar[key], { requiresOtherClause: true })); }
catch (e) { errors.push(`${key}: ICU syntax error ${e.message}`); continue; }
if (src.names !== dst.names) errors.push(`${key}: arguments differ: [${src.names}] vs [${dst.names}]`);
for (const p of dst.plurals) {
const missing = AR_FORMS.filter((f) => !(f in p.options));
if (missing.length) errors.push(`${key}: plural {${p.value}} lacks ${missing.join(", ")}`);
}
if (!/[-ۿ]/.test(ar[key])) errors.push(`${key}: no Arabic letters`);
if (/⟦\d+⟧/.test(ar[key])) errors.push(`${key}: placeholder marker left in text`);
}
for (const key of Object.keys(ar)) if (!(key in en)) errors.push(`${key}: not in source`);
console.log(errors.join("\n") || "ok");
process.exit(errors.length ? 1 : 0);
Sur le fichier ci-dessus, il a affiché ok. Nous avons ensuite fait omettre au serveur fictif la forme many et le marqueur {workspace}. Le script s’est terminé avec le code 1 et a affiché :
invite: arguments differ: [<b> {inviter} {workspace}] vs [<b> {inviter}]
files: plural {count} lacks many
La règle « no Arabic letters » signale les chaînes que le modèle a laissées en anglais. Elle signale aussi les valeurs qui ne sont qu’un nom de produit ou un nombre ; tenez une liste d’exceptions pour celles-ci. Pour le format propre à i18next, appliquez les mêmes contrôles clé par clé : chaque paire _one/_other en anglais exige les six clés suffixées en arabe, chacune avec les mêmes variables, sauf que _zero, _one et _two peuvent omettre le count.
Enfin, rendez quelques nombres avec votre vrai formateur. Avec intl-messageformat 12.1.5, le message files ci-dessus a donné 0 → لا توجد ملفات, 2 → ملفان, 5 → 5 ملفات, 11 → 11 ملفًا, 102 → 102 ملف et 111 → 111 ملفًا. Ce contrôle ponctuel attrape une forme qui passe l’analyse mais utilise le mauvais nom.
Et l’affichage de droite à gauche ?
La traduction fournit les bons mots ; le navigateur doit encore les ordonner. Quand un nom latin ou un nombre est inséré dans une phrase arabe, l’algorithme bidirectionnel Unicode peut déplacer la ponctuation ou intervertir des segments voisins. Le W3C conseille d’isoler le texte inséré : l’entourer de <bdi> ou d’un élément avec dir="auto" en HTML, ou de U+2068 FIRST STRONG ISOLATE et U+2069 POP DIRECTIONAL ISOLATE en texte brut, par exemple dans les notifications push.
Faites-le là où vous interpolez, pas dans la traduction. Dans notre test, formater le message de bienvenue avec le nom entouré de U+2068 et U+2069 a conservé les deux caractères dans la sortie sans toucher à l’arabe. Placez aussi dir="rtl" et lang="ar" sur la page ou le conteneur. Prompt engineering en arabe propose une courte check-list des bugs d’affichage RTL.
Les chiffres relèvent du formateur, pas de la traduction. Gardez # ou l’argument dans la chaîne. Sous Node 24 (ICU 78.3), Intl.NumberFormat a écrit 1234 en 1,234 pour ar et en ١٬٢٣٤ pour ar-EG et ar-SA. Choisissez la balise de locale qui correspond à votre marché. Pour les questions produit plus larges (langue de l’interface ou langue du modèle, bulles de chat aux sens mélangés, détection de langue et coût par langue), voir concevoir une expérience IA multilingue.
Qui doit relire le résultat ?
Une chaîne LLM dotée de ces contrôles garantit un fichier bien formé. Elle ne garantit pas que l’arabe soit juste. Faites relire par un arabophone :
- Uniquement les chaînes nouvelles ou modifiées. Comparez
en.jsonà la dernière version publiée et ne traduisez que ce qui a changé. Les relectures restent légères, et les chaînes validées ne bougent plus. - Les formes plurielles, mot à mot. L’accord avec les nombres est là où le modèle trébuche le plus, surtout l’accusatif après 11 à 99.
- Le genre. En arabe, « tu/vous » et les verbes changent selon le genre du lecteur. Si votre interface s’adresse directement aux utilisateurs, fixez une convention, comme une forme fixe ou une reformulation neutre, et inscrivez-la dans le prompt système.
- La longueur. Les chaînes arabes peuvent être plus longues ou plus courtes que l’anglais. Vérifiez boutons et onglets dans la vraie mise en page, en largeur mobile.
Conservez un fichier de glossaire relu dans le dépôt et envoyez-le avec chaque requête, pour que les termes validés restent fixes.
Combien ça coûte ?
Les fichiers de chaînes sont petits. La sortie est à peu près aussi longue que l’entrée, et l’arabe demande en général plus de tokens par mot que l’anglais ; tokens par mot en arabe et en anglais donne des rapports mesurés. Collez un lot dans le compteur de tokens arabe, multipliez par le nombre de lots et ajoutez le prompt système à chacun. Les modèles de raisonnement dépensent aussi des tokens à réfléchir ; BroadNet les indique dans usage sous completion_tokens_details.reasoning_tokens : lisez donc usage sur une vraie requête avant d’extrapoler.
| Modèle | Remarques pour ce travail | Entrée / sortie par million de tokens |
|---|---|---|
| Qwen3.8 27B | Sortie structurée documentée | $0.175 / $2.17 |
| GLM 5.3 | Sortie structurée documentée ; contexte de 1 048 576 tokens | $0.78 / $3.46 |
| Gemma 4 VL 26B | Fonctionne avec le crédit de départ de $5 ; JSON par prompt seulement, le validateur compte donc davantage | $0.10 / $0.22 |
| DeepSeek V4.1 Flash | Aussi en forfaits, comme $15 la semaine par session, une requête à la fois par session | $0.175 / $0.52 |
Les prix proviennent du flux tarifaire de BroadNet, mis à jour le 2026-11-14. Traduisez les mêmes 100 chaînes avec deux modèles et faites-les comparer par votre relecteur avant de choisir ; le prix au token compte moins que le nombre de corrections. Pour des milliers de clés dans de nombreuses langues, traitement par lots sans Batch API traite de la concurrence et des relances.
Où se situe BroadNet Inference
BroadRouter est le site de BroadNet. BroadNet Inference donne un accès compatible OpenAI aux modèles ci-dessus ; le script tourne donc avec le SDK Python d’OpenAI après changement de l’URL de base et de l’identifiant de modèle ; consultez la référence de l’API pour les paramètres pris en charge par chaque modèle. Il n’a pas d’endpoint de traduction et ne publie aucun benchmark de localisation : le validateur et un relecteur humain restent votre contrôle qualité. Les plateformes de localisation spécialisées ajoutent mémoire de traduction, circuits de relecture et captures d’écran en contexte ; si vous en avez besoin, utilisez-en une et gardez le contrôle CI ci-dessus comme seconde ligne de défense.
