Traducir los archivos de cadenas de una app es un trabajo distinto de traducir prosa. Cada valor es corto, a menudo no tiene contexto y lleva sintaxis que el modelo no debe tocar: placeholders, etiquetas HTML y reglas de plural. El árabe complica esto último: los archivos en inglés tienen dos formas de plural y el árabe necesita seis. Este artículo construye un pequeño pipeline sobre un LLM compatible con OpenAI: congelar los placeholders, pedir seis cadenas de plural simples, armar la sintaxis ICU en código y validarlo todo en CI.
Para traducir documentos, tickets y contratos, consulte traducción árabe–inglés con LLM, que cubre el tono, los glosarios y la evaluación para prosa.
¿Por qué los plurales árabes rompen los archivos de cadenas traducidos automáticamente?
Unicode CLDR, que siguen Intl.PluralRules, ICU e i18next, asigna al árabe seis categorías cardinales:
| Categoría | Regla de CLDR | Números de ejemplo | Ejemplo: “archivo” |
|---|---|---|---|
| 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, acusativo) |
| other | todo lo demás | 100–102, 1000, 0.5 | 100 ملف (singular) |
Dos detalles confunden a la gente. Primero, las categorías no son los números: 103 es few y 111 es many. Segundo, un original en inglés solo da al modelo one y other, así que tiene que inventar cuatro formas a partir de la gramática. La mayoría de los fallos vienen de que el modelo copia el par inglés.
El fallo es silencioso. Renderizamos un mensaje árabe que solo tenía one y other con intl-messageformat 12.1.5: 0, 2 y 11 archivos salieron todos como «N ملف». i18next 27.1.2 se comportó igual cuando faltaba la clave _many: 11 archivos mostraron el texto de _other. Ni error ni aviso, solo árabe incorrecto.
¿Cómo debe enviar las cadenas al modelo?
Agrúpelas en lotes. Una solicitud por cadena desperdicia tokens en el prompt de sistema y pierde el contexto entre cadenas relacionadas. Envíe de 50 a 200 claves a la vez como un objeto JSON, agrupadas por pantalla o por función, para que “Save” junto a “Cancel” se lea como un botón.
Tres reglas hacen que la respuesta sea verificable:
- Congele los placeholders. Sustituya
{name}, los placeholders de i18next con llaves dobles,%s,%1$sy etiquetas como<b>por marcadores como ⟦0⟧. El modelo ve “Welcome back, ⟦0⟧!” y no puede traducirnamepor اسم. - Pida las formas de plural como cadenas simples. Envíe los textos
oneyotheren inglés y pida seis cadenas en árabe. El código construye la sintaxis ICU. El modelo nunca escribe una llave. - Dé un glosario y una lista de términos que no se traducen. Nombres de producto, nombres de planes y términos que usa su equipo de soporte. La sección de glosario del artículo sobre traducción explica por qué esto importa más que la elección del modelo.
El script de traducción
El archivo fuente usa ICU MessageFormat, la sintaxis que documenta FormatJS. La misma congelación funciona con el formato JSON propio de i18next, cuyas claves de plural terminan en _zero, _one, _two, _few, _many y _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)
Lo ejecutamos con el SDK de OpenAI para Python contra un servidor simulado local, no contra la API real, con una respuesta en árabe predefinida. La solicitud que vería el modelo contenía “Welcome back, ⟦0⟧!” y “⟦0⟧⟦1⟧⟦2⟧ invited you to the ⟦3⟧ workspace”, y el script escribió este ar.json:
{
"save": "حفظ",
"welcome": "مرحبًا بعودتك يا {name}!",
"invite": "دعاك <b>{inviter}</b> إلى مساحة العمل {workspace}",
"billing": "ادفع عبر AcmePay",
"files": "{count, plural, zero {لا توجد ملفات} one {ملف واحد} two {ملفان} few {# ملفات} many {# ملفًا} other {# ملف}}"
}
Notas sobre el código:
- Los marcadores se mueven, no desaparecen. El árabe suele poner el verbo primero, así que ⟦0⟧ puede cambiar de sitio. El control de abajo cuenta los marcadores; no le importa dónde estén.
- El ICU anidado va a una persona. Un
selectdentro de unplurales raro y fácil de romper. El script lo rechaza en lugar de adivinar. max_tokens=4000deja margen para el razonamiento. La documentación de BroadNet indica que DeepSeek V4.1 Flash, GLM 5.3 y Qwen3.8 27B razonan antes de responder, y que el razonamiento cuenta para max_tokens. Consulte respuestas vacías de los modelos de razonamiento.json.loadspuede fallar. Envuélvalo y reenvíe una vez con el error; cómo arreglar JSON no válido de un LLM tiene una función de reparación probada. En GLM 5.3 y Qwen3.8 27B, los dos modelos de BroadNet documentados con salida estructurada, añada también un esquemaresponse_format. El control de abajo se mantiene en ambos casos.
¿Cómo se valida el archivo árabe en CI?
Analice cada mensaje con el mismo parser que usa su app en tiempo de ejecución y compárelo con el original. Este script de Node usa @formatjs/icu-messageformat-parser (versión 3.5.23 en nuestra prueba):
// 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);
Con el archivo anterior imprimió ok. Luego hicimos que la respuesta simulada omitiera la forma many y el marcador {workspace}. El script terminó con código 1 e imprimió:
invite: arguments differ: [<b> {inviter} {workspace}] vs [<b> {inviter}]
files: plural {count} lacks many
La regla “no Arabic letters” detecta las cadenas que el modelo dejó en inglés. También marca valores que son solo un nombre de producto o un número, así que mantenga una lista de excepciones para ellos. Para el formato propio de i18next, aplique los mismos controles por clave: cada par _one/_other en inglés necesita las seis claves con sufijo en árabe, y cada una necesita los mismos placeholders, salvo que _zero, _one y _two pueden prescindir del número.
Por último, renderice unos cuantos números con su formateador real. Con intl-messageformat 12.1.5, el mensaje files de arriba dio 0 → لا توجد ملفات, 2 → ملفان, 5 → 5 ملفات, 11 → 11 ملفًا, 102 → 102 ملف y 111 → 111 ملفًا. Esa comprobación puntual detecta una forma que se analiza bien pero usa el sustantivo equivocado.
¿Y la visualización de derecha a izquierda?
La traducción acierta con las palabras; el navegador todavía tiene que ordenarlas. Cuando se inserta un nombre latino o un número en una oración árabe, el algoritmo bidireccional de Unicode puede mover la puntuación o intercambiar tramos contiguos. El consejo del W3C es aislar el texto insertado: envolverlo en <bdi> o en un elemento con dir="auto" en HTML, o rodearlo con U+2068 FIRST STRONG ISOLATE y U+2069 POP DIRECTIONAL ISOLATE en texto plano, como en las notificaciones push.
Hágalo donde interpola, no en la traducción. En nuestra prueba, formatear el mensaje de bienvenida con el nombre envuelto en U+2068 y U+2069 conservó ambos caracteres en la salida y dejó intacto el árabe. Configure también dir="rtl" y lang="ar" en la página o el contenedor. Ingeniería de prompts para árabe tiene una breve lista de comprobación para errores de visualización RTL.
Los dígitos son una decisión del formateador, no de la traducción. Mantenga # o el argumento en la cadena. En Node 24 (ICU 78.3), Intl.NumberFormat escribió 1234 como 1,234 para ar y como ١٬٢٣٤ para ar-EG y ar-SA. Elija la etiqueta de configuración regional que corresponda a su mercado. Para las cuestiones de producto más amplias (idioma de la interfaz frente a idioma del modelo, burbujas de chat con direcciones mezcladas, detección de idioma y costo por idioma), consulte diseñar una experiencia de IA en varios idiomas.
¿Quién debe revisar la salida?
Un pipeline de LLM con estos controles garantiza que el archivo esté bien formado. No garantiza que el árabe sea correcto. Pida a un hablante de árabe que revise:
- Solo las cadenas nuevas y modificadas. Compare
en.jsoncon la última versión y traduzca solo lo que cambió. Las revisiones se mantienen pequeñas y las cadenas aprobadas no se mueven. - Las formas de plural, palabra por palabra. La concordancia con los números es donde el modelo falla más a menudo, sobre todo el acusativo tras 11 a 99.
- El género. En árabe, “tú” y los verbos cambian según el género del lector. Si su interfaz se dirige directamente a los usuarios, decida una convención, como una forma fija o una reformulación neutra, y póngala en el prompt de sistema.
- La longitud. Las cadenas en árabe pueden ser más largas o más cortas que en inglés. Revise botones y pestañas en el diseño real con ancho de móvil.
Mantenga un archivo de glosario revisado en el repositorio y envíelo con cada solicitud, para que los términos aprobados no cambien.
¿Cuánto cuesta?
Los archivos de cadenas son pequeños. La salida es casi tan larga como la entrada, y el árabe suele necesitar más tokens por palabra que el inglés; tokens por palabra en árabe e inglés tiene proporciones medidas. Pegue un lote en el contador de tokens en árabe, multiplique por el número de lotes y añada el prompt de sistema a cada uno. Los modelos de razonamiento también gastan tokens pensando; BroadNet los reporta en usage como completion_tokens_details.reasoning_tokens, así que lea usage de una solicitud real antes de extrapolar.
| Modelo | Notas para este trabajo | Entrada / salida por 1M de tokens |
|---|---|---|
| Qwen3.8 27B | Salida estructurada documentada | $0.175 / $2.17 |
| GLM 5.3 | Salida estructurada documentada; contexto de 1,048,576 tokens | $0.78 / $3.46 |
| Gemma 4 VL 26B | Funciona con el crédito inicial de $5; JSON solo por prompt, así que el validador importa más | $0.10 / $0.22 |
| DeepSeek V4.1 Flash | También en planes de tarifa plana, como $15 a la semana por sesión, una solicitud a la vez por sesión | $0.175 / $0.52 |
Los precios proceden del feed de precios de BroadNet, actualizado el 2026-11-14. Traduzca las mismas 100 cadenas con dos modelos y pida a su revisor que las compare antes de elegir; el precio por token importa menos que el número de correcciones. Para miles de claves en muchos idiomas, procesamiento por lotes sin una Batch API cubre la concurrencia y los reintentos.
Dónde encaja BroadNet Inference
BroadRouter es el sitio de la propia BroadNet. BroadNet Inference ofrece acceso compatible con OpenAI a los modelos anteriores, así que el script funciona con el SDK de OpenAI para Python tras cambiar la URL base y el ID del modelo; consulte la referencia de la API para los parámetros que admite cada modelo. No tiene endpoint de traducción y no publica un benchmark de localización, así que el validador y un revisor humano siguen siendo su control de calidad. Las plataformas de localización dedicadas añaden memoria de traducción, flujos de revisión y capturas de pantalla en contexto; si las necesita, use una y mantenga el control de CI anterior como segunda línea.
