Arabic Game Localization, Engine-Level

Atlus's Metaphor runs on GFD, Studio Zero's in-house engine — the same family as Persona 5 and Catherine, and neither Unity nor Unreal. Its text lives inside an 85 GB CRIWARE CPK archive under per-file CRILAYLA compression, with dialogue held in AtlusScript .msg files. The engine expects a left-to-right script: it performs no Arabic shaping and no bidirectional reordering, drawing glyphs in raw byte order and honoring literal line breaks top-to-bottom. The usual "flip the font's line metrics" shortcut is dead here — GFD reads usWinAscent/usWinDescent, not signed metrics — so the text has to arrive already correct.

Full localization end-to-end: a custom CPK extractor handles the CRILAYLA decompression (chunks read as encrypted at ~8.0 entropy but were only compressed), and an offline RTL baker shapes each line into presentation forms, wraps it to a per-label box capacity derived from Atlus's own Japanese hand-wrapped line breaks, and reorders it visually — holding Latin islands in place and mirroring brackets — emitting hard line breaks the engine renders correctly. Colour tags, paired markup, and engine tokens survive the reversal intact. The Arabic font is injected into all nine font slots so names and menus render, and UI sprites are round-tripped through BC7 textures. ~1.16 million words translated through the hybrid localization workflow across more than 75,000 message entries.

Delivered as a one-click installer that deploys the build and proxies the engine silently, so players run it without touching a config file. Published on Nexus Mods.

ForzaTech is Playground Games' in-house engine, with a UI layer built on NoesisGUI/AVUI. It had never been publicly reverse-engineered — Arabic requests from the community had sat unanswered for years with no tooling delivered. Strings live in a custom binary string-table format. Fonts aren't TTF: they're a proprietary .vfont/.vfont0 pair that stores every glyph as a pre-built GPU mesh. And nothing in the engine expects a right-to-left script — no Arabic shaping, no BiDi.

Every format was reverse-engineered with byte-identical roundtrip verification — the string tables across all 287 files, and the mesh-font formats from scratch. A TTF-to-mesh generator builds engine-valid Arabic glyphs (395 across the Arabic and Presentation-Forms-B ranges), reshaping and BiDi were added where the engine had none, and the locale archives were repacked slot-preserving around the engine's silent integrity checks. ~387,000 words translated end-to-end through the hybrid localization workflow and shipped inside the build — dialogue, UI, system text, fonts, RTL — not handed back as a CSV. Published on Nexus Mods as a fan project.

After it shipped, translators working in other languages asked how it was done. The engine's text and font formats had no public documentation, so I reverse-engineered and published them as an open toolkit — any language community can now localize a ForzaTech game.

IO Interactive's Glacier engine has no Arabic support and was never built to render a right-to-left script. Its localization lives inside a proprietary, encrypted RPKG archive format — with a custom block layout for UI strings, dialogue, and video subtitles — and its UI fonts run through a Scaleform GFX container where each glyph is baked into a binary font face. Nothing in that stack expects Arabic, and the font container crashes the moment a glyph edit changes the byte length of the tag body around it.

Full localization end-to-end: the RPKG format and its block structure were reverse-engineered for round-trip read and write, the game-specific localization key recovered, and ~165,000 words translated through the hybrid localization workflow across UI, dialogue, and subtitles. Arabic glyphs were injected into six font faces size-neutrally — replacing rare glyph slots and padding each face back to its exact original byte length, so the Scaleform container never shifts and never crashes — with RTL reshaping and bidi applied at the string layer and placeholder and engine tokens masked so they survive reordering. Rather than a separate patch archive, the localized data was injected directly into the game's base chunks. Published as a fan mod.

The engine's RPKG archive format and font container had no public documentation, so I reverse-engineered and published the toolkit on GitHub — any language community can now localize a Glacier-engine game.

Inscryption mixes UI.Text and TMP_Text across its interface — and Unity's two font-loading paths each break the other one. Font.CreateDynamicFontFromOSFont produces a working dynamic atlas that UI.Text needs, but its source-file path is null, so TMP_FontAsset.CreateFontAsset throws. new Font(absolutePath) gives TMP what it needs but kills the dynamic atlas, so UI.Text reports no Arabic glyphs. Either path alone leaves half the game broken.

The fix was a two-font architecture: keep both Font objects alive in parallel and route each consumer to the one it actually works with. TMP integration is registered as a fallback — Latin renders from the host font, Arabic from the registered Arabic fallback — instead of a direct font swap that would have lost Latin entirely. The shaping library was rewritten as cluster-based RTL so tashkeel (U+064B–U+0652) stays attached to its base letter through reversal.

5,807 entries translated through the hybrid localization workflow, integrated via a BepInEx plugin with Harmony patches into the game's Russian language slot. Published on Nexus Mods.

The Outer Worlds 2 ships in twelve official languages — Arabic isn't one of them. Obsidian's UE5.4 build uses Zen Loader / IoStore for game data, plus a parallel legacy pak format the game mounts alongside. Text goes through IoStore; font replacement goes through the legacy pak. Both archives have to ship for Arabic to render correctly.

Full localization end-to-end: ~1.03 million words translated through the hybrid localization workflow, IoStore container repacking via retoc and UAssetGUI for the text layer, and a parallel legacy pak built with UnrealPak for font replacement across six font slots. UE 5.4's native HarfBuzz handles Arabic shaping and bidirectional ordering at runtime — the engine work is in the container plumbing, not the text shaper. Published on Nexus Mods.

Beethoven & Dinosaur's Mixtape ships on UE 5.6 with both Zen Loader / IoStore for cooked assets and a parallel V3 legacy pak holding the .locres, .locmeta, ICU data, and .ufont files. The translatable text is entirely in the legacy pak — but UE 5.6's loader refuses to mount a V3 pak alone for this game. The Arabic build ships the translated locres in a V3 pak alongside empty IoStore stubs (.ucas, .utoc) generated against UE 5.6's specific zen format — UE 5.3 / 5.4 / 5.5 stubs fail the version check.

Full localization end-to-end: ~17,600 words translated through the hybrid localization workflow across 2,721 locres entries spanning 64 namespaces. 64 .ufont files swapped to Noto Kufi Arabic. Translator credit injected directly into the locres (no byte-patching) so it renders on the main menu and pause screen. Feminine grammar applied throughout for the female protagonist's player-directed text. A five-phase audit pass (structural, meta-leak, English-leak, anomalies, and a song-citation phase covering bracket loss in [TRACK] patterns) caught 31 defects before ship. Published on Nexus Mods.

Supergiant ships on a proprietary C++/Lua stack with no Arabic pipeline — strings sit next to game logic, fonts are bound at build time, and the existing localization layer wasn't built for RTL or Arabic glyphs. Going to a full Arabic build meant engine-level integration, not a file swap.

Roughly 456,000 words translated and shipped end-to-end through the hybrid localization workflow, with engine integration running in parallel: dialogue, UI, system messages, fonts, RTL behavior — all of it inside the build, not handed back as a CSV. Published on Nexus Mods as a fan project.

MSBT is Nintendo's proprietary binary format used across first-party Switch titles. No off-the-shelf toolchain handles Arabic inside it — strings are length-prefixed, encoded for Nintendo's runtime, and break the moment you touch them without understanding the structure. Off-the-shelf localization tools don't reach this far.

45,000 entries parsed out of MSBT, translated through the hybrid localization workflow, and reintegrated cleanly so the game loads them at runtime — length-prefix preserved, encoding intact, RTL behavior correct in-build. Published as a fan project.

MegaCrit's Slay the Spire 2 ships on Godot 4.5.1 with C# .NET 9. Localization data is bundled inside a 1.85 GB Godot PCK v3 archive — strings, fonts, scenes, and theme resources all packed into one container. Godot 4 has known RTL quirks: setting LayoutDirection to RTL doesn't right-align RichTextLabel paragraph text, and the engine's font fallback chain doesn't traverse cleanly to Arabic glyphs without engine-level intervention.

Full localization end-to-end: ~45,000 words translated through the hybrid localization workflow, the PCK v3 container reverse-engineered to extract source for analysis, with translations delivered through the game's native localization override directory rather than repacking the bundle. A custom C# Harmony mod injects Arabic font fallback into Godot's ThemeDB and patches MegaLabel and MegaRichTextLabel for runtime RTL alignment. Five Harmony patches in a 14 KB DLL. Published on Nexus Mods.

Unity 6 introduced a ManagedReferencesRegistry v1 metadata block that current open-source bundle writers can't preserve — round-tripping resources.assets through UnityPy or AssetsTools.NET silently loses 9,088 bytes across twelve distinct metadata regions. Static bundle patching isn't viable on this engine version. The Arabic build instead overwrites only the localization string-tables bundle (which round-trips cleanly) and does everything else at runtime: a 9 KB BepInEx 5 plugin creates a Dynamic SDF Arabic TMP_FontAsset, walks every loaded TMP_FontAsset via Resources.FindObjectsOfTypeAll, and appends the Arabic font to each fallback table — with a re-walk on SceneManager.sceneLoaded for fonts spawned later.

Full localization end-to-end: ~57,500 words translated through the hybrid localization workflow across 139 Unity Addressables string tables. A HarmonyX IL transpiler targets the dialogue async state machine (OnScreenDialogueController.<DisplayText>d__15.MoveNext) and rewrites the speaker-line concatenation so the speaker tag survives Arabic shaping. Font work uses sh-blabeloo with a custom cmap mapping Forms-B codepoints (U+FE80–U+FEFC) onto base glyphs; GSUB and GPOS tables stripped to prevent context-dependent substitution corruption against pre-shaped input. Published on Nexus Mods. Ships with Su4enka's BepInEx Unity 6 compatibility patch, included with explicit written permission from the author.

GameMaker Studio 1.x has a deserved reputation for fighting localization. Strings are baked into compiled data files, the runtime doesn't expose a clean text layer, and font handling assumes Latin glyphs. A lot of indie titles still ship on GameMaker, so pretending the engine doesn't exist isn't an option for serious Arabic work.

Full localization end-to-end: string extraction from the data files, font work for Arabic glyphs, RTL handling, translation through the hybrid localization workflow, and clean reintegration into the GameMaker runtime. Published as a fan mod.

Mobius Digital ships Outer Wilds with roughly eleven official languages. Arabic isn't one of them. The localization stack is closed — XML-driven, asset-bundle-bound, with no hook for an RTL language the game was never designed to accept. Adding Arabic meant pushing a non-supported language into that stack from outside.

The work was three-fold: matching Unity 2019.4.27f1 exactly so font asset bundles load (any other build version and they fail), writing a custom RTL fixer function inside the game's XML localization API, and running the full translation through the hybrid localization workflow. Published as a fan project.

Silksong runs on Unity 6 (6000.0.50f1), but its text doesn't go through stock TextMeshPro — it runs through a forked version living in the engine's own TMProOld namespace, with a legacy font schema and no dynamic font fallback. Dialogue, UI, and item text are driven from compiled asset bundles and flat YAML string tables, and none of that pipeline expects a right-to-left language.

Full localization end-to-end: 93,491 words extracted from the string tables and translated through the hybrid localization workflow in Modern Standard Arabic, then a build-time RTL transform that reshapes each line into Presentation Forms, reverses it per segment, masks placeholders and Latin runs, and preserves every engine tag so line breaks and page markers survive intact. A decompile of the game's own assembly settled where line breaks are converted — eight methods inside the game code, not the injector — so wrapping and reordering run at build time instead of fighting the runtime. A gender-consistency pass keeps the female protagonist addressed correctly across thousands of lines, alongside dialect and terminology passes over the full corpus. Reintegrated into the Unity runtime via BepInEx and published on Nexus Mods.