Cómo traducir juegos de Unreal Engine

Un juego de Unreal Engine parece lo más difícil de traducir que hay en tu disco. No hay carpeta data, ni archivos de script, ni un .json que puedas abrir: solo un ejecutable, un directorio Content/Paks con uno o dos archivos .pak enormes y quizá un par de contenedores .utoc/.ucas. La buena noticia es que el texto que de verdad quieres no suele estar escondido dentro de esos archivos por diseño. Unreal tiene un sistema de localización de primera clase, y la mayoría de los juegos publicados lo usa. Tu trabajo es encontrar la tabla, sustituir las cadenas y entregarle al motor un archivo pequeño que tenga prioridad sobre el original.

Esa última parte es lo que hace agradable a Unreal una vez lo entiendes. No reconstruyes un juego de 60 GB. Produces un archivo de sobrescritura que se mide en kilobytes y lo dejas junto a los originales.

Una cosa antes de los pasos: el soporte de Unreal en RuneTranslate es de mejor esfuerzo y más reciente que el de motores como RPG Maker o Ren’Py. Se ha confirmado jugable en títulos reales de UE4, pero la superficie del formato es enorme y cada estudio empaqueta de forma distinta. Verifica una compilación exportada dentro del juego antes de comprometerte con una tirada de traducción larga.

Qué publica en realidad un juego de Unreal

Unreal guarda el texto visible para el jugador en archivos `.locres`, la forma compilada de FTextLocalizationResource. Hay uno por cultura, situado en una ruta del estilo <Game>/Content/Localization/Game/ja/Game.locres, con hermanos para en, zh-Hans y lo que el estudio haya publicado. Un juego sin ninguna traducción normalmente tiene uno igualmente, para la cultura en la que se escribió.

Un .locres no es un archivo de texto ni una lista simple de clave/valor. Es una tabla binaria organizada en namespaces, cada uno con claves, y cada clave apuntando a una cadena. En las versiones modernas, el namespace y la clave se guardan como hashes (CRC32 en la versión 2, CityHash64 sobre UTF-16 en la versión 3) en lugar de como nombres legibles, y las cadenas viven en una tabla de búsqueda compartida y deduplicada con recuentos de referencias. El motor de ejecución nunca busca una cadena por su texto en inglés: la busca por ese par namespace/clave, que se compila dentro de los Blueprints y el C++ del juego al construirlo.

Esa estructura dicta la única forma segura de editar uno. RuneTranslate conserva cada hash de namespace, de clave y de cadena de origen byte a byte y cambia solo el valor, y luego reconstruye la tabla de cadenas deduplicada y sus recuentos. Nada recalcula un hash, así que nada puede producir una clave que el juego no encuentre. Las traducciones pueden ser más largas o más cortas que el original sin problema.

Esos archivos .locres van luego empaquetados dentro de archivos .pak — identificados por un valor mágico 0x5A6F12E1 en un pie al final del archivo — o, en los títulos modernos de UE5, dentro de contenedores IoStore .utoc/.ucas.

Comprueba el alcance antes de gastar una hora

.locres cubre la interfaz, los menús, los mensajes de sistema, el texto de tutorial, los nombres de objetos y habilidades, y los subtítulos — pongamos que en torno al 90% del texto visible de un juego típico. Esa es la parte que RuneTranslate lee y escribe.

Lo que no cubre: el texto compilado en DataTables o incrustado en paquetes `.uasset` cocinados. Algunos estudios — sobre todo en proyectos pequeños o muy orientados a Blueprints — guardan ahí el diálogo en lugar de en el sistema de localización. Esas cadenas están direccionadas por hash dentro de paquetes cocinados, sin índice de directorio legible, y leerlas como es debido necesita un archivo de mapeo .usmap que el juego publicado no incluye. Si tu juego guarda ahí su guion, la extracción volverá con menús y botones y nada de diálogo, y RuneTranslate lo informa como un resultado explícito de fuera de alcance en lugar de fingir que ha salido bien.

Conviene saberlo pronto: la forma más rápida de comprobarlo es ejecutar el paso de creación del proyecto y mirar qué ha salido. Unos pocos cientos de cadenas cortas, todas del estilo Continue, Options, Are you sure?, significa que la interfaz está localizada y el guion no. Varios miles de cadenas con frases completas significa que estás en buena forma.

La clave AES, y por qué no es un muro

Buena parte de los paks publicados van cifrados con AES-256 — en concreto en modo ECB sin IV, aplicado al índice del archivo y a menudo también a las entradas individuales. Sin la clave, el archivo es opaco: no puedes ni listar lo que hay dentro.

La clave se puede recuperar por una razón sencilla. El juego tiene que leer sus propios archivos en tiempo de ejecución, en una máquina sin red y sin servidor de licencias, así que la clave está presente en el binario publicado como un dato corriente. RuneTranslate escanea el ejecutable y sus DLL buscando ventanas de 32 bytes, las poda con un filtro de entropía (una clave AES real tiene al menos 25 bytes distintos de 32), hace una comprobación barata descifrando el primer bloque del índice y preguntando si el valor inicial se lee como una longitud de cadena plausible, y luego verifica a las supervivientes en serio: descifra el índice entero y compara su SHA-1 con el hash que registra el propio pie del pak. Ese último paso es la diferencia entre esto y los buscadores de claves por ranking de entropía que circulan por ahí: una candidata o reproduce el hash que el propio archivo registra, o se rechaza. Una clave equivocada no puede aceptarse nunca.

Algunos juegos guardan la clave como texto en lugar de como bytes en crudo, y otros la reparten entre instrucciones separadas del binario; ambos casos están cubiertos. Si nada de eso funciona, el diálogo de Nuevo proyecto acepta una clave pegada en hexadecimal (0x… o 64 caracteres hexadecimales) o en base64, y una vez recuperada la clave se guarda en caché por proyecto para que no vuelvas a escanear un ejecutable de 85 MB en cada exportación.

El IoStore de UE5 es distinto, y la extracción va dirigida

Los títulos de UE5 publican cada vez más contenedores IoStore en lugar de paks normales: un directorio .utoc emparejado con un blob de datos .ucas, con compresión Oodle y su propio cifrado. El enfoque ingenuo aquí es desempaquetarlo todo, lo que en un juego de 105 GB no es un enfoque en absoluto.

RuneTranslate incluye retoc (con licencia MIT) y le pide que convierta los contenedores a un pak heredado filtrado solo a los archivos de localización — el equivalente de to-legacy -f locres --no-shaders --no-script-objects. Un título IoStore de 105 GB se reduce a unos pocos kilobytes de .locres, en segundos en vez de horas. retoc también se encarga del AES y del Oodle propios del contenedor, que es por lo que los juegos IoStore esquivan el problema de Oodle con el que sí pueden toparse los paks sueltos.

La mitad importante de esto es que IoStore solo complica la lectura. La escritura es universal, y de eso va la siguiente sección.

La salida es un pak de sobrescritura, no un juego reconstruido

Esta es la parte que ninguna otra guía explica como es debido, y es la razón por la que traducir Unreal sale barato en cuanto funciona.

Unreal monta los archivos pak en un orden definido, y cualquier archivo cuyo nombre termine en `_P` se monta el último. Los montajes posteriores ganan. Así que un archivo pequeño que no contenga más que tu .locres modificado, en la misma ruta virtual que usa el juego base, simplemente tapa al original: el gestor de localización carga el tuyo y nunca ve el publicado.

• Sin volver a firmar. La firma de paks es un mecanismo RSA completamente aparte y rara vez se exige en los títulos comerciales publicados; la sobrescritura no lo toca.
• Sin clave AES para la salida. La sobrescritura se escribe sin cifrar y sin comprimir. La clave solo hacía falta para leer el original.
• Sin reempaquetar el juego. Los archivos base quedan intactos. Una instalación de 60 GB sigue ocupando 60 GB; tu traducción es un archivo que se mide en kilobytes.
• También funciona con los juegos IoStore. El .locres se lee a través del sistema de archivos pak y no del cargador de paquetes Zen, así que un _P.pak suelto se recoge incluso en un juego de UE5 cuyos recursos viven todos en .utoc/.ucas.

Lo instalas copiando el _P.pak producido en <Game>/Content/Paks/, la misma carpeta donde están los originales. Algunos juegos montan además una subcarpeta ~mods/, que funciona igual de bien. Quitar la traducción es borrar ese único archivo, lo que hace trivial volver atrás y seguro probar pronto.

Los pasos

1. Instala RuneTranslate desde la página de descarga e inicia sesión. Se requiere un inicio de sesión gratuito con Patreon en el primer arranque; el nivel gratuito desbloquea todos los motores y todos los proveedores — limita el rendimiento y mantiene un proyecto a la vez.
2. Crea un proyecto nuevo y apúntalo a la carpeta raíz del juego, la que contiene el ejecutable y el directorio <Game>. La detección busca Content/Paks y el valor mágico del pie del pak, o los .utoc/.ucas.
3. Si los archivos están cifrados, deja que se ejecute la recuperación de la clave. Escanea los binarios publicados y verifica cada candidata contra el hash del propio índice del pak. Si se queda sin resultados, pega una clave en el diálogo.
4. Deja terminar la extracción. Obtienes las entradas .locres de la cultura de origen, agrupadas por destino de localización, listas para revisar.
5. Elige un proveedor y traduce. Las cadenas cortas de interfaz y el diálogo largo se pueden enrutar a proveedores distintos si quieres gastar dinero solo donde importa.
6. Revisa lo que ha vuelto. Las cadenas de menú son donde la traducción automática es más floja: un Save o un Load a secas no tienen contexto, y un botón de dos palabras que vuelve convertido en una frase desbordará su widget.
7. Exporta. RuneTranslate escribe un único _P.pak sin cifrar con tu .locres modificado en la ruta correcta relativa al motor.
8. Copia ese archivo en <Game>/Content/Paks/ y lanza el juego.

Prueba después del paso 8 con un puñado de cadenas traducidas, antes de pasar el juego entero por un proveedor. Si la sobrescritura va a ignorarse — carpeta equivocada, cultura equivocada, un montaje poco habitual — quieres enterarte en cinco minutos, no después de pagar por 9.000 cadenas.

Marcadores de posición y texto enriquecido

El formateo de FText de Unreal usa {0}, {1} para argumentos posicionales y {PlayerName}, {Count} para los nombrados, además del marcado <RichText> con cierres </> para el estilo en línea. Si un proveedor de traducción pierde o estropea uno de esos, el juego no muestra una frase ligeramente mal: muestra una cadena de formato rota, o el argumento desaparece de la línea sin más.

RuneTranslate enmascara todos ellos tras un marcador de posición neutro antes de que el proveedor vea la cadena, y los restaura después. El proveedor traduce alrededor de los marcadores y no a través de ellos, así que un modelo que decidió que las llaves parecían una errata no puede borrar un argumento. Si quieres ir más lejos y dejar ciertas cadenas fuera de la traducción por completo, los filtros de exclusión con expresiones regulares funcionan en cualquier motor, y un glosario mantiene estables los nombres propios en todo el juego.

La trampa de los acentos, que es un fallo de codificación y no una fuente

Esta merece documentarse aparte porque el síntoma apunta exactamente en la dirección equivocada. Unreal serializa una cadena con un prefijo de longitud: una longitud positiva significa un byte por carácter, una negativa significa UTF-16. El motor elige la forma estrecha solo cuando todos los caracteres son ASCII de 7 bits — su comprobación rechaza cualquier cosa por encima de 0x7F. Su cargador está hecho igual, así que si le entregas una cadena estrecha que contiene un byte alto, sustituye cada uno por un ? literal.

La consecuencia práctica: una traducción que contiene poción mágica escrita en la forma estrecha llega al jugador como poci?n m?gica. Y la banda afectada es U+0080–U+00FF, que es justamente la de las letras acentuadas del español, el francés, el alemán, el portugués, el italiano y las lenguas nórdicas. El polaco, el turco, el checo, el griego, el cirílico, el japonés y el chino están todos por encima de U+00FF, toman la rama ancha automáticamente y no se ven afectados nunca.

Así que la huella es: los acentos se rompen en español pero el ruso va bien. Si ves eso, es un fallo de codificación en lo que sea que escribió el archivo, no un glifo que falta en la fuente del juego — un glifo que falta se renderiza como un recuadro o como nada, nunca como un signo de interrogación. RuneTranslate tenía exactamente este fallo y lo corrigió en 0.49.4; el codificador vive ahora en un solo sitio y escribe la forma ancha para cualquier cosa fuera de ASCII. Vale la pena conocerlo porque otras herramientas de este terreno lo siguen haciendo mal.

Elegir un proveedor

Tres de los nueve proveedores no necesitan clave de API en absoluto — Google, el DeepL gratuito y los modelos Classic/Next-gen de DeepL — y el nivel gratuito te da todos. Para un juego que es sobre todo interfaz, un proveedor gratuito va perfectamente bien. Para títulos con mucho diálogo, un proveedor LLM maneja el contexto mucho mejor; OpenAI, Anthropic, DeepSeek, cualquier endpoint compatible con OpenAI y un modelo local con Ollama o LM Studio están todos disponibles. La comparativa de proveedores repasa en qué es bueno y malo cada uno, con cifras de coste reales.

Resolución de problemas

El juego se ejecuta pero no hay nada traducido

Casi siempre es una de tres cosas. El archivo no está en <Game>/Content/Paks/ — ponerlo junto al ejecutable no hace nada. El nombre del archivo perdió el sufijo _P, en cuyo caso se monta en el orden alfabético normal y el pak base puede ganar. O el juego se está ejecutando en una cultura que no tradujiste: carga el .locres de la cultura que haya resuelto al arrancar, así que un juego que fuerza en ignorará una sobrescritura escrita solo para ja. Comprueba primero el ajuste de idioma del juego.

La extracción falla en un pak suelto comprimido con Oodle

Un .pak suelto comprimido con Oodle necesita un descompresor que no se puede incluir. Si el juego publica además contenedores IoStore, la ruta de retoc se encarga de Oodle y no hay problema. Si son solo paks sueltos, esto es una parada en firme por ahora, informada de forma explícita en lugar de como un resultado vacío en silencio.

El juego no tiene ningún .locres

Entonces su texto está compilado en recursos cocinados, y esta ruta no lo alcanza. El ejemplo más claro es un gran título de servicio en vivo de UE5 cuyo índice IoStore está reducido a hashes de contenido, sin ningún nombre de archivo: cientos de miles de fragmentos y cero .locres. RuneTranslate lo dice en lugar de machacar el contenedor entero.

La detección no salta

Apunta a la carpeta que contiene el ejecutable, no a Content/Paks en sí ni a una carpeta superior llena de otros juegos. Si aun así no detecta, el empaquetado es poco habitual y vale la pena reportarlo: el formato pak tiene disposiciones de pie específicas por versión, y un dialecto que nadie ha visto todavía es exactamente el tipo de cosa que se acaba añadiendo.

Límites honestos

El soporte de Unreal es de mejor esfuerzo. El .locres dentro de paks sueltos y cifrados y dentro del IoStore de UE5 es la ruta probada, confirmada jugable dentro del juego en un título de UE4 en español. El texto de DataTable y de .uasset cocinados no está cubierto. Los paks sueltos comprimidos con Oodle sin un IoStore que los acompañe no están soportados. Los paks con firma exigida no se pueden sobrescribir, aunque en la práctica son raros. Y como el formato varía tanto entre versiones de motor y entre estudios, trata la primera exportación como una prueba y no como el resultado final.

Con lo que acabas es con una compilación traducida y jugable que te quedas en tu propia máquina: el juego original intacto, más un archivo pequeño que puedes borrar para deshacerlo todo. Si estás comparando motores o comprobando si tu juego está cubierto siquiera, la página del motor Unreal tiene el detalle técnico y todos los motores lista los diecisiete formatos compatibles, incluidos Unity y RPG Maker. Si eres nuevo en todo esto, empieza con el tutorial general y vuelve aquí para las partes específicas de Unreal.