BroadRouter

App-Strings per LLM ins Arabische übersetzen: Platzhalter und Plurale

Vom Team von BroadNet Inference · 7 Min. Lesezeit · Veröffentlicht

Senden Sie die Strings als JSON, ersetzen Sie jeden Platzhalter durch einen Marker, fordern Sie alle sechs arabischen Pluralformen an (zero, one, two, few, many, other) und bauen Sie den ICU-Plural im Code, nicht im Modell. Prüfen Sie in CI: gleiche Schlüssel, gleiche Argumente und Tags, alle sechs Formen vorhanden. Umschließen Sie eingefügte Namen mit Unicode-Isolates, damit rechtsläufiger Text korrekt angezeigt wird.

Die String-Dateien einer App zu übersetzen ist eine andere Aufgabe als Fließtext zu übersetzen. Jeder Wert ist kurz, hat oft keinen Kontext und enthält Syntax, die das Modell nicht anrühren darf: Platzhalter, HTML-Tags und Pluralregeln. Arabisch macht Letzteres schwer. Englische Dateien enthalten zwei Pluralformen, Arabisch braucht sechs. Dieser Beitrag baut eine kleine Pipeline auf einem OpenAI-kompatiblen LLM: Platzhalter einfrieren, sechs einfache Plural-Strings anfordern, die ICU-Syntax im Code zusammensetzen und dann alles in CI prüfen.

Für die Übersetzung von Dokumenten, Tickets und Verträgen siehe Übersetzung Arabisch–Englisch mit LLMs; dort geht es um Tonfall, Glossare und Bewertung bei Fließtext.

Warum zerbrechen arabische Plurale maschinell übersetzte String-Dateien?

Unicode CLDR, dem Intl.PluralRules, ICU und i18next alle folgen, gibt Arabisch sechs Kardinalkategorien:

Kategorie CLDR-Regel Beispielzahlen Beispiel: „Datei“
zero n = 0 0 لا توجد ملفات
one n = 1 1 ملف واحد
two n = 2 2 ملفان (Dual)
few n % 100 = 3..10 3–10, 103–110 5 ملفات (Plural)
many n % 100 = 11..99 11–99, 111 11 ملفًا (Singular, Akkusativ)
other alles andere 100–102, 1000, 0.5 100 ملف (Singular)

Zwei Details bringen Leute ins Stolpern. Erstens sind die Kategorien nicht die Zahlen: 103 ist few und 111 ist many. Zweitens gibt eine englische Quelle dem Modell nur one und other, es muss also vier Formen allein aus der Grammatik erfinden. Die meisten Fehler entstehen, weil das Modell das englische Paar kopiert.

Der Fehler ist lautlos. Wir haben eine arabische Nachricht mit nur one und other mit intl-messageformat 12.1.5 gerendert: 0, 2 und 11 Dateien kamen alle als „N ملف“ heraus. i18next 27.1.2 verhielt sich genauso, als der Schlüssel _many fehlte: 11 Dateien zeigten den Text von _other. Kein Fehler, keine Warnung, nur falsches Arabisch.

Wie sollten Sie Strings an das Modell senden?

Bündeln Sie sie. Eine Anfrage pro String verschwendet Tokens für den System-Prompt und verliert den Kontext zwischen zusammengehörigen Strings. Senden Sie 50 bis 200 Schlüssel auf einmal als JSON-Objekt, gruppiert nach Bildschirm oder Funktion, damit „Save“ neben „Cancel“ als Button gelesen wird.

Drei Regeln machen die Antwort prüfbar:

  1. Platzhalter einfrieren. Ersetzen Sie {name}, i18next-Platzhalter mit doppelten Klammern, %s, %1$s und Tags wie <b> durch Marker wie ⟦0⟧. Das Modell sieht „Welcome back, ⟦0⟧!“ und kann name nicht in اسم übersetzen.
  2. Pluralformen als einfache Strings anfordern. Senden Sie die englischen Texte für one und other und fordern Sie sechs arabische Strings an. Der Code baut die ICU-Syntax. Das Modell schreibt nie eine Klammer.
  3. Ein Glossar und eine Liste nicht zu übersetzender Begriffe mitgeben. Produktnamen, Plannamen und Begriffe, die Ihr Support verwendet. Der Glossar-Abschnitt des Übersetzungsbeitrags erklärt, warum das mehr zählt als die Modellwahl.

Das Übersetzungsskript

Die Quelldatei verwendet ICU MessageFormat, die Syntax, die FormatJS dokumentiert. Dasselbe Einfrieren funktioniert für das eigene JSON-Format von i18next, dessen Pluralschlüssel auf _zero, _one, _two, _few, _many und _other enden.

{
  "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)

Wir haben es mit dem OpenAI Python SDK gegen einen lokalen Mock-Server ausgeführt, nicht gegen die Live-API, mit einer vorgefertigten arabischen Antwort. Die Anfrage, die das Modell sehen würde, enthielt „Welcome back, ⟦0⟧!“ und „⟦0⟧⟦1⟧⟦2⟧ invited you to the ⟦3⟧ workspace“, und das Skript schrieb diese ar.json:

{
  "save": "حفظ",
  "welcome": "مرحبًا بعودتك يا {name}!",
  "invite": "دعاك <b>{inviter}</b> إلى مساحة العمل {workspace}",
  "billing": "ادفع عبر AcmePay",
  "files": "{count, plural, zero {لا توجد ملفات} one {ملف واحد} two {ملفان} few {# ملفات} many {# ملفًا} other {# ملف}}"
}

Hinweise zum Code:

  • Marker wandern, sie verschwinden nicht. Im Arabischen steht das Verb oft vorn, ⟦0⟧ kann sich also verschieben. Die Prüfung unten zählt Marker; wo sie stehen, ist ihr egal.
  • Verschachteltes ICU geht an einen Menschen. Ein select innerhalb eines plural ist selten und leicht zu zerstören. Das Skript lehnt es ab, statt zu raten.
  • max_tokens=4000 lässt Raum für Reasoning. Laut der Dokumentation von BroadNet denken DeepSeek V4.1 Flash, GLM 5.3 und Qwen3.8 27B vor der Antwort nach, und das Reasoning zählt zu max_tokens. Siehe leere Antworten von Reasoning-Modellen.
  • json.loads kann fehlschlagen. Fangen Sie das ab und senden Sie einmal erneut mit dem Fehler; ungültiges JSON aus einem LLM reparieren enthält eine getestete Reparaturfunktion. Bei GLM 5.3 und Qwen3.8 27B, den beiden BroadNet-Modellen mit dokumentierter strukturierter Ausgabe, ergänzen Sie zusätzlich ein Schema in response_format. Die Prüfung unten bleibt in jedem Fall.

Wie prüfen Sie die arabische Datei in CI?

Parsen Sie jede Nachricht mit demselben Parser, den Ihre App zur Laufzeit nutzt, und vergleichen Sie sie mit der Quelle. Dieses Node-Skript verwendet @formatjs/icu-messageformat-parser (in unserem Test Version 3.5.23):

// 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);

Für die Datei oben gab es ok aus. Dann ließen wir die Mock-Antwort die Form many und den Marker für {workspace} weglassen. Das Skript endete mit Code 1 und gab aus:

invite: arguments differ: [<b> {inviter} {workspace}] vs [<b> {inviter}]
files: plural {count} lacks many

Die Regel „no Arabic letters“ markiert Strings, die das Modell auf Englisch gelassen hat. Sie markiert auch Werte, die nur aus einem Produktnamen oder einer Zahl bestehen; führen Sie für diese eine Allow-List. Für das eigene Format von i18next wenden Sie dieselben Prüfungen pro Schlüssel an: Jedes Paar _one/_other im Englischen braucht im Arabischen alle sechs Schlüssel mit Suffix, und jeder braucht dieselben Platzhalter, nur dass _zero, _one und _two den count weglassen dürfen.

Rendern Sie zum Schluss einige Zahlen mit Ihrem echten Formatierer. Mit intl-messageformat 12.1.5 ergab die Nachricht files oben 0 → لا توجد ملفات, 2 → ملفان, 5 → 5 ملفات, 11 → 11 ملفًا, 102 → 102 ملف und 111 → 111 ملفًا. Diese Stichprobe fängt eine Form ab, die zwar parst, aber das falsche Nomen verwendet.

Die Übersetzung sorgt für die richtigen Wörter; ordnen muss sie trotzdem der Browser. Wird ein lateinischer Name oder eine Zahl in einen arabischen Satz eingefügt, kann der bidirektionale Unicode-Algorithmus Satzzeichen verschieben oder benachbarte Abschnitte vertauschen. Das W3C rät, eingefügten Text zu isolieren: in HTML mit <bdi> oder einem Element mit dir="auto" umschließen, in reinem Text wie Push-Benachrichtigungen mit U+2068 FIRST STRONG ISOLATE und U+2069 POP DIRECTIONAL ISOLATE einrahmen.

Tun Sie das beim Interpolieren, nicht in der Übersetzung. In unserem Test behielt die Begrüßungsnachricht, mit dem Namen in U+2068 und U+2069 eingeschlossen formatiert, beide Zeichen in der Ausgabe, und das Arabische blieb unberührt. Setzen Sie außerdem dir="rtl" und lang="ar" auf der Seite oder dem Container. Prompt Engineering für Arabisch enthält eine kurze Checkliste für RTL-Anzeigefehler.

Ziffern sind eine Entscheidung des Formatierers, nicht der Übersetzung. Behalten Sie # oder das Argument im String. In Node 24 (ICU 78.3) schrieb Intl.NumberFormat 1234 für ar als 1,234 und für ar-EG und ar-SA als ١٬٢٣٤. Wählen Sie das Locale-Tag, das zu Ihrem Markt passt. Für die übergreifenden Produktfragen (Oberflächensprache vs. Modellsprache, Chat-Blasen mit gemischter Laufrichtung, Spracherkennung und Kosten pro Sprache) siehe ein KI-Erlebnis für mehrere Sprachen gestalten.

Wer sollte die Ausgabe prüfen?

Eine LLM-Pipeline mit diesen Prüfungen garantiert, dass die Datei wohlgeformt ist. Sie garantiert nicht, dass das Arabisch stimmt. Lassen Sie eine arabischsprachige Person prüfen:

  • Nur neue und geänderte Strings. Vergleichen Sie en.json mit dem letzten Release und übersetzen Sie nur, was sich geändert hat. Reviews bleiben klein, und freigegebene Strings bewegen sich nie.
  • Pluralformen, Wort für Wort. Bei der Kongruenz mit Zahlen rutscht das Modell am häufigsten aus, besonders beim Akkusativ nach 11 bis 99.
  • Genus. „Du/Sie“ und Verben ändern sich im Arabischen mit dem Geschlecht der lesenden Person. Spricht Ihre UI Nutzer direkt an, legen Sie eine Konvention fest, etwa eine feste Form oder eine neutrale Umformulierung, und schreiben Sie sie in den System-Prompt.
  • Länge. Arabische Strings können länger oder kürzer als englische ausfallen. Prüfen Sie Buttons und Tabs im echten Layout in Mobilbreite.

Führen Sie eine geprüfte Glossardatei im Repository und senden Sie sie mit jeder Anfrage, damit freigegebene Begriffe fest bleiben.

Was kostet das?

String-Dateien sind klein. Die Ausgabe ist etwa so lang wie die Eingabe, und Arabisch braucht pro Wort meist mehr Tokens als Englisch; Tokens pro Wort auf Arabisch und Englisch enthält gemessene Verhältnisse. Fügen Sie einen Batch in den Token-Zähler für Arabisch ein, multiplizieren Sie mit der Anzahl der Batches und rechnen Sie bei jedem den System-Prompt hinzu. Reasoning-Modelle verbrauchen außerdem Tokens fürs Nachdenken; BroadNet meldet sie in usage als completion_tokens_details.reasoning_tokens, lesen Sie usage also aus einer echten Anfrage aus, bevor Sie hochrechnen.

Modell Hinweise für diese Aufgabe Input / Output pro 1 Mio. Tokens
Qwen3.8 27B Strukturierte Ausgabe dokumentiert $0.175 / $2.17
GLM 5.3 Strukturierte Ausgabe dokumentiert; Kontext von 1.048.576 Tokens $0.78 / $3.46
Gemma 4 VL 26B Läuft mit dem Startguthaben von $5; JSON nur per Prompt, der Validator zählt also mehr $0.10 / $0.22
DeepSeek V4.1 Flash Auch mit Pauschalplänen, etwa $15 pro Woche und Session, jeweils eine Anfrage pro Session $0.175 / $0.52

Die Preise stammen aus dem Preis-Feed von BroadNet, aktualisiert am 2026-11-14. Übersetzen Sie dieselben 100 Strings mit zwei Modellen und lassen Sie Ihre Prüferin oder Ihren Prüfer vergleichen, bevor Sie sich entscheiden; der Preis pro Token zählt weniger als die Anzahl der Korrekturen. Für Tausende Schlüssel in vielen Sprachen behandelt Batch-Verarbeitung ohne Batch API Parallelität und Wiederholungen.

Wo BroadNet Inference ins Bild passt

BroadRouter ist BroadNets eigene Website. BroadNet Inference bietet OpenAI-kompatiblen Zugriff auf die Modelle oben, das Skript läuft also mit dem OpenAI Python SDK, nachdem Sie Base-URL und Modell-ID geändert haben; welche Parameter jedes Modell unterstützt, steht in der API-Referenz. Es hat keinen Übersetzungs-Endpoint und veröffentlicht keinen Lokalisierungs-Benchmark, Validator und menschliche Prüfung bleiben also Ihr Qualitäts-Gate. Spezialisierte Lokalisierungsplattformen bieten zusätzlich Translation Memory, Review-Workflows und Screenshots im Kontext; brauchen Sie das, nutzen Sie eine und behalten Sie die CI-Prüfung oben als zweite Verteidigungslinie.

Häufige Fragen

Wie viele Pluralformen hat Arabisch?

Sechs Kardinalkategorien in Unicode CLDR: zero (0), one (1), two (2), few (Zahlen, die auf 03 bis 10 enden, etwa 3 bis 10 und 103), many (Endung 11 bis 99) und other (100 bis 102, 1000 sowie Dezimalzahlen wie 0,5). Eine englische Datei hat nur one und other.

Kann ChatGPT oder ein anderes LLM meine i18n-JSON-Datei ins Arabische übersetzen?

Ja, wenn Sie das Format kontrollieren. Senden Sie nur die Werte, ersetzen Sie Platzhalter durch Marker, fordern Sie sechs Pluralformen an und prüfen Sie das Ergebnis im Code: Schlüssel, Argumente, Tags und Pluralkategorien. Lassen Sie neue Strings vor dem Release von einer arabischsprachigen Person prüfen.

Was passiert, wenn einer arabischen Übersetzung eine Pluralform fehlt?

Meist schlägt nichts sichtbar fehl. i18next und intl-messageformat greifen auf die Form other zurück, sodass 2 Dateien als „2 ملف“ statt des Duals ملفان erscheinen. Nur ein Validator, der alle sechs Formen verlangt, bemerkt das vor den Nutzern.

Sollte das LLM die ICU-MessageFormat-Syntax selbst schreiben?

Besser nicht. Fordern Sie pro Pluralnachricht sechs einfache Strings an und setzen Sie die ICU-Syntax im Code zusammen. Modelle lassen gelegentlich eine Klammer weg oder übersetzen den Argumentnamen, und ein Parserfehler legt dann zur Laufzeit das ganze Bundle lahm.

Welche Ziffern sollten arabische UI-Strings verwenden?

Das entscheidet der Zahlenformatierer, nicht die Übersetzung. Behalten Sie # oder das Argument im String. In unserem Test mit Node 24 formatierte Intl.NumberFormat 1234 für ar als 1,234 und für ar-EG und ar-SA als ١٬٢٣٤; das Locale-Tag bestimmt also die Ziffern.

Als Markdown lesenChatGPT fragenClaude fragenPerplexity fragen