---
title: "Translate i18n JSON to Arabic with an LLM: plurals | BroadRouter"
description: "Translate i18n JSON files to Arabic with an LLM API: freeze placeholders, generate all six Arabic plural forms, validate ICU syntax in CI and isolate inserted names."
url: https://broadrouter.com/blog/translate-app-strings-to-arabic-llm/
lang: en
updated: 2026-11-15
publisher: BroadRouter (a BroadNet site); API by BroadNet Inference, https://inference.broadnet.ai
---

# Translate app strings to Arabic with an LLM: placeholders and plurals

By the BroadNet Inference team · 7 min read · Published 2026-11-15

Send the strings as JSON with every placeholder swapped for a marker, ask for all six Arabic plural forms (zero, one, two, few, many, other), and build the ICU plural in code, not in the model. Validate in CI: same keys, same arguments and tags, all six forms present. Wrap inserted names in Unicode isolates so right-to-left text displays correctly.

## Key takeaways

-   Arabic has six cardinal plural categories in CLDR. English source files have two, so the model must write four forms that do not exist in the source.
-   A missing Arabic form fails silently. In our test, an ICU message with only one and other rendered "2 ملف" for 2 files instead of the dual ملفان, with no error.
-   Swap placeholders and tags for markers like ⟦0⟧ before the request and restore them after. The model cannot translate what it cannot see.
-   Let code assemble the ICU plural syntax from six plain strings. Then parse every message with the FormatJS parser in CI and fail the build on any gap.
-   Interpolated names and Latin product names inside Arabic need bidi isolation: bdi or dir="auto" in HTML, U+2068 and U+2069 in plain text.

**On this page**

1.  Why do Arabic plurals break machine-translated string files?
2.  How should you send strings to the model?
3.  The translation script
4.  How do you validate the Arabic file in CI?
5.  What about right-to-left display?
6.  Who should review the output?
7.  What does it cost?
8.  Where BroadNet Inference fits

Translating an app’s string files is a different job from translating prose. Each value is short, often has no context, and carries syntax the model must not touch: placeholders, HTML tags and plural rules. Arabic makes the last one hard. English files hold two plural forms; Arabic needs six. This post builds a small pipeline on an OpenAI-compatible LLM: freeze placeholders, ask for six plain plural strings, assemble the ICU syntax in code, then validate everything in CI.

For translating documents, tickets and contracts, see [Arabic–English translation with LLMs](https://broadrouter.com/blog/arabic-english-translation-llm/), which covers tone, glossaries and evaluation for prose.

## Why do Arabic plurals break machine-translated string files?

Unicode CLDR, which `Intl.PluralRules`, ICU and i18next all follow, gives Arabic six cardinal categories:

| Category | CLDR rule | Example numbers | Example: “file” |
| --- | --- | --- | --- |
| 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, accusative) |
| other | everything else | 100–102, 1000, 0.5 | 100 ملف (singular) |

Two details catch people out. First, the categories are not the numbers: 103 is few and 111 is many. Second, an English source gives the model only `one` and `other`, so it has to invent four forms from grammar alone. Most failures come from the model copying the English pair.

The failure is silent. We rendered an Arabic message that had only `one` and `other` with intl-messageformat 12.1.5: 0, 2 and 11 files all came out as “N ملف”. i18next 27.1.2 behaved the same way when the `_many` key was missing: 11 files showed the `_other` text. No error, no warning, just wrong Arabic.

## How should you send strings to the model?

Batch them. One request per string wastes tokens on the system prompt and loses context between related strings. Send 50 to 200 keys at a time as a JSON object, grouped by screen or feature so “Save” next to “Cancel” reads as a button.

Three rules make the reply checkable:

1.  **Freeze placeholders.** Replace `{name}`, double-brace i18next placeholders, `%s`, `%1$s` and tags such as `<b>` with markers like ⟦0⟧. The model sees “Welcome back, ⟦0⟧!” and cannot translate `name` into اسم.
2.  **Ask for plural forms as plain strings.** Send the English `one` and `other` texts and ask for six Arabic strings. Code builds the ICU syntax. The model never writes a brace.
3.  **Give a glossary and a do-not-translate list.** Product names, plan names and terms your support team uses. The [glossary section of the translation post](https://broadrouter.com/blog/arabic-english-translation-llm/) explains why this matters more than model choice.

## The translation script

The source file uses ICU MessageFormat, the syntax FormatJS documents. The same freezing works for i18next’s own JSON format, whose plural keys end `_zero`, `_one`, `_two`, `_few`, `_many` and `_other`.

```json
{
  "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}}"
}
```

```python
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)
```

We ran it with the OpenAI Python SDK against a local mock server, not the live API, with a canned Arabic reply. The request the model would see held “Welcome back, ⟦0⟧!” and “⟦0⟧⟦1⟧⟦2⟧ invited you to the ⟦3⟧ workspace”, and the script wrote this `ar.json`:

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

Notes on the code:

-   **Markers move, they don’t vanish.** Arabic often puts the verb first, so ⟦0⟧ can move. The check below counts markers; it does not care where they sit.
-   **Nested ICU goes to a person.** A `select` inside a `plural` is rare and easy to break. The script refuses it rather than guessing.
-   **`max_tokens=4000` leaves room for reasoning.** BroadNet’s docs say DeepSeek V4.1 Flash, GLM 5.3 and Qwen3.8 27B reason before answering, and the reasoning counts toward [max\_tokens](https://broadrouter.com/glossary/max-tokens/). See [empty responses from reasoning models](https://broadrouter.com/guides/reasoning-tokens-empty-response/).
-   **`json.loads` can fail.** Wrap it and resend once with the error; [fixing invalid JSON from an LLM](https://broadrouter.com/blog/fix-invalid-json-from-llm/) has a tested repair function. On GLM 5.3 and Qwen3.8 27B, the two BroadNet models documented with [structured output](https://broadrouter.com/glossary/structured-output/), add a `response_format` schema too. The check below stays either way.

## How do you validate the Arabic file in CI?

Parse every message with the same parser your app uses at runtime, and compare it with the source. This Node script uses `@formatjs/icu-messageformat-parser` (version 3.5.23 in our test):

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

On the file above it printed `ok`. We then made the mock reply drop the `many` form and the `{workspace}` marker. The script exited with code 1 and printed:

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

The “no Arabic letters” rule flags strings the model left in English. It also flags values that are only a product name or a number, so keep an allow-list for those. For i18next’s own format, apply the same checks per key: every `_one`/`_other` pair in English needs all six suffixed keys in Arabic, and each needs the same placeholders, except that `_zero`, `_one` and `_two` may drop the count.

Finally, render a few numbers through your real formatter. With intl-messageformat 12.1.5, the `files` message above gave 0 → لا توجد ملفات, 2 → ملفان, 5 → 5 ملفات, 11 → 11 ملفًا, 102 → 102 ملف and 111 → 111 ملفًا. That spot check catches a form that parses but uses the wrong noun.

## What about right-to-left display?

Translation gets the words right; the browser still has to order them. When a Latin name or a number is inserted into an Arabic sentence, the Unicode bidirectional algorithm can move punctuation or swap neighbouring runs. The W3C’s advice is to isolate inserted text: wrap it in `<bdi>` or an element with `dir="auto"` in HTML, or surround it with U+2068 FIRST STRONG ISOLATE and U+2069 POP DIRECTIONAL ISOLATE in plain text, such as push notifications.

Do this where you interpolate, not in the translation. In our test, formatting the welcome message with the name wrapped in U+2068 and U+2069 kept both characters in the output and left the Arabic untouched. Set `dir="rtl"` and `lang="ar"` on the page or container too. [Arabic prompt engineering](https://broadrouter.com/blog/arabic-prompt-engineering/) has a short checklist for RTL display bugs.

Digits are a formatter choice, not a translation choice. Keep `#` or the argument in the string. In Node 24 (ICU 78.3), `Intl.NumberFormat` wrote 1234 as 1,234 for `ar` and as ١٬٢٣٤ for `ar-EG` and `ar-SA`. Pick the locale tag that matches your market. For the wider product questions (interface locale versus model language, chat bubbles with mixed directions, language detection and per-language cost), see [designing an AI experience for multiple languages](https://broadrouter.com/blog/multilingual-product-design/).

## Who should review the output?

An LLM pipeline with these checks guarantees the file is well-formed. It does not guarantee the Arabic is right. Have an Arabic speaker review:

-   **New and changed strings only.** Diff `en.json` against the last release and translate only what changed. Reviews stay small, and approved strings never move.
-   **Plural forms, word by word.** Agreement with numbers is where the model most often slips, especially the accusative after 11 to 99.
-   **Gender.** “You” and verbs change with the reader’s gender in Arabic. If your UI addresses users directly, decide on a convention, such as a fixed form or a neutral rephrasing, and put it in the system prompt.
-   **Length.** Arabic strings can run longer or shorter than English. Check buttons and tabs in the real layout at mobile width.

Keep a reviewed glossary file in the repo and send it with every request, so approved terms stay fixed.

## What does it cost?

String files are small. Output is about as long as the input, and Arabic usually needs more tokens per word than English; [tokens per word in Arabic and English](https://broadrouter.com/blog/tokens-per-word-arabic-english/) has measured ratios. Paste a batch into the [Arabic token counter](https://broadrouter.com/tools/arabic-token-counter/), multiply by the number of batches, and add the system prompt to each one. Reasoning models also spend tokens thinking; BroadNet reports them in `usage` as `completion_tokens_details.reasoning_tokens`, so read `usage` from a real request before you extrapolate.

| Model | Notes for this job | Input / output per 1M tokens |
| --- | --- | --- |
| [Qwen3.8 27B](https://broadrouter.com/models/qwen3.8-27b/) | Structured output documented | $0.175 / $2.17 |
| [GLM 5.3](https://broadrouter.com/models/glm-5.3/) | Structured output documented; 1,048,576-token context | $0.78 / $3.46 |
| [Gemma 4 VL 26B](https://broadrouter.com/models/gemma-4-vl-26b/) | Runs on the $5 starting credit; prompt-only JSON, so the validator matters more | $0.10 / $0.22 |
| [DeepSeek V4.1 Flash](https://broadrouter.com/models/deepseek-v4.1-flash/) | Also on flat plans, such as $15 a week per session, one request at a time per session | $0.175 / $0.52 |

Prices are from BroadNet’s pricing feed, updated 2026-11-14. Translate the same 100 strings with two models and have your reviewer compare them before you pick one; price per token matters less than the number of fixes. For thousands of keys across many languages, [batch processing without a Batch API](https://broadrouter.com/blog/llm-batch-processing-without-batch-api/) covers concurrency and retries.

## Where BroadNet Inference fits

BroadRouter is BroadNet’s own site. BroadNet Inference gives OpenAI-compatible access to the models above, so the script runs with the [OpenAI Python SDK](https://broadrouter.com/guides/openai-python-sdk/) after changing the base URL and model ID; check the [API reference](https://inference.broadnet.ai/docs?utm_source=broadrouter&utm_medium=referral&utm_campaign=blog-translate-app-strings-to-arabic-llm&utm_content=body) for parameters each model supports. It has no translation endpoint and publishes no localisation benchmark, so the validator and a human reviewer remain your quality gate. Dedicated localisation platforms add translation memory, reviewer workflows and in-context screenshots; if you need those, use one and keep the CI check above as a second line.

Free tools for this

-   [Arabic token counter](https://broadrouter.com/tools/arabic-token-counter/) Arabic vs English token counts per tokenizer: the "Arabic tax" in tokens and money.
-   [Arabic text normalizer](https://broadrouter.com/tools/arabic-text-normalizer/) Tashkeel, tatweel, alef, ya, ta marbuta, digits and invisible characters, with a matching Python function.
-   [Speech-to-text cost calculator](https://broadrouter.com/tools/speech-to-text-cost-calculator/) Hours, calls or voice notes to a monthly transcription bill, against your current provider.

[All free tools](https://broadrouter.com/tools/)

## Terms in this article

[Token](https://broadrouter.com/glossary/token/)

A token is the unit of text a language model reads and writes: a word, part of a word, a punctuation mark or a byte sequence produced by the model's tokenizer. LLM APIs count, limit and usually bill usage in tokens.

[Structured output](https://broadrouter.com/glossary/structured-output/)

Structured output is an LLM API feature that constrains a model's reply to a format the developer specifies, usually a JSON Schema, so code can parse it reliably. It is stricter than JSON mode, which guarantees valid JSON but not a particular shape.

[System prompt](https://broadrouter.com/glossary/system-prompt/)

A system prompt is the instruction text an application sends to a language model ahead of the conversation, usually as a message with the system or developer role. It sets the model's role, rules, tone and output format, and the model is meant to follow it over conflicting user messages.

[Right-to-left (RTL) text](https://broadrouter.com/glossary/rtl-text/)

Right-to-left (RTL) text is writing, such as Arabic or Hebrew, displayed from right to left. Computers store it in logical reading order, and the Unicode Bidirectional Algorithm decides display order when RTL text mixes with left-to-right text, digits, model names or code.

[Base URL](https://broadrouter.com/glossary/base-url/)

A base URL is the fixed root address of an API, such as https://api.example.com/v1, that a client puts in front of every endpoint path, such as /chat/completions. In OpenAI-compatible SDKs, changing the base URL, together with the API key and model ID, points the same code at a different provider.

[Batch API](https://broadrouter.com/glossary/batch-api/)

A batch API is an asynchronous LLM endpoint that accepts many requests at once, usually as a file, processes them within a set window instead of immediately, and returns the results together. Providers such as OpenAI and Anthropic price batch requests at a discount to their standard APIs.

[Concurrency](https://broadrouter.com/glossary/concurrency/)

Concurrency is the number of requests a client has in flight at the same time. LLM APIs often cap it per key or plan, separately from requests per minute, because each open request holds GPU capacity until its response has finished.

[max\_tokens](https://broadrouter.com/glossary/max-tokens/)

max\_tokens is an LLM API parameter that sets the most tokens a model may generate in one response. When generation reaches the limit, it stops and the response is marked as cut off, for example with finish\_reason set to "length".

## Questions

### How many plural forms does Arabic have?

Six cardinal categories in Unicode CLDR: zero (0), one (1), two (2), few (numbers ending 03 to 10, such as 3 to 10 and 103), many (ending 11 to 99) and other (100 to 102, 1000, and decimals such as 0.5). An English file has only one and other.

### Can ChatGPT or another LLM translate my i18n JSON file to Arabic?

Yes, if you control the format. Send only the values, replace placeholders with markers, ask for six plural forms, and check the result in code: keys, arguments, tags and plural categories. Have an Arabic speaker review new strings before release.

### What happens if an Arabic translation is missing a plural form?

Usually nothing visible fails. i18next and intl-messageformat fall back to the other form, so 2 files shows as "2 ملف" instead of the dual ملفان. Only a validator that requires all six forms catches it before users do.

### Should the LLM write ICU MessageFormat syntax itself?

Better not. Ask for six plain strings per plural message and assemble the ICU syntax in code. Models occasionally drop a brace or translate the argument name, and a parser error then breaks the whole bundle at runtime.

### Which digits should Arabic UI strings use?

Let the number formatter decide, not the translation. Keep # or the argument in the string. In our Node 24 test, Intl.NumberFormat formatted 1234 as 1,234 for ar and ١٬٢٣٤ for ar-EG and ar-SA, so the locale tag sets the digits.

## Keep reading

-   [Arabic–English translation with LLMs: prompts, glossaries, evaluation](https://broadrouter.com/blog/arabic-english-translation-llm/)
-   [Arabic prompt engineering: register, RTL, numerals and mixed text](https://broadrouter.com/blog/arabic-prompt-engineering/)
-   [JSON mode vs json\_schema: structured output that holds up](https://broadrouter.com/blog/structured-output-json-schema/)
-   [How to fix invalid JSON from an LLM: causes, repair, retry](https://broadrouter.com/blog/fix-invalid-json-from-llm/)
-   [Tokens per word in Arabic vs English: why Arabic costs more](https://broadrouter.com/blog/tokens-per-word-arabic-english/)
-   [LLM batch processing without a Batch API: a resumable runner](https://broadrouter.com/blog/llm-batch-processing-without-batch-api/)
-   [Design an AI experience for multiple languages](https://broadrouter.com/blog/multilingual-product-design/)
-   [Add diacritics to Arabic text with an LLM: prompt, checks, DER](https://broadrouter.com/blog/arabic-diacritization-llm/)
-   [Arabic grammar and spelling correction with an LLM: a how-to](https://broadrouter.com/blog/arabic-grammar-spelling-correction-llm/)
-   [Guide: Use the OpenAI Python SDK with BroadNet Inference](https://broadrouter.com/guides/openai-python-sdk/)
-   [Guide: Why a reasoning model returns an empty answer](https://broadrouter.com/guides/reasoning-tokens-empty-response/)

Try it on your real workload. New accounts start with $5 of credit for Gemma and transcription. DeepSeek, GLM and Qwen3.8 need a top-up.

[Get started](https://inference.broadnet.ai/account/?utm_source=broadrouter&utm_medium=referral&utm_campaign=blog-translate-app-strings-to-arabic-llm&utm_content=page-cta) ·

**Sources**

-   [Unicode CLDR, Language Plural Rules chart: Arabic cardinal categories zero, one, two, few (n % 100 = 3..10), many (n % 100 = 11..99), other (checked 2026-11-15)](https://www.unicode.org/cldr/charts/latest/supplemental/language_plural_rules.html)
-   [MDN, Intl.PluralRules.prototype.select(): Arabic has 6 forms for cardinal numbers (checked 2026-11-15)](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Intl/PluralRules/select)
-   [FormatJS, Message syntax: plural categories, exact =value matches, the # symbol, other is required, apostrophe escaping (checked 2026-11-15)](https://formatjs.github.io/docs/core-concepts/icu-syntax)
-   [i18next documentation, Plurals: \_zero, \_one, \_two, \_few, \_many, \_other suffixes, Arabic example, Intl.PluralRules, count variable (checked 2026-11-15)](https://www.i18next.com/translation-function/plurals)
-   [i18next documentation, JSON format: v4 plural keys and interpolation (checked 2026-11-15)](https://www.i18next.com/misc/json-format)
-   [W3C Internationalization, Inline markup and bidirectional text in HTML: dir, bdi, FSI U+2068 and PDI U+2069 (checked 2026-11-15)](https://www.w3.org/International/articles/inline-bidi-markup/)
-   [BroadNet Inference API reference: model IDs, structured output for GLM 5.3 and Qwen3.8 27B, reasoning counts toward max\_tokens (checked 2026-11-15)](https://inference.broadnet.ai/docs?utm_source=broadrouter&utm_medium=referral&utm_campaign=blog-translate-app-strings-to-arabic-llm&utm_content=sources)
