How to translate a Kirikiri / KAG visual novel to English

Kirikiri (吉里吉里) and its KAG scenario layer power a huge slice of Japanese visual novels — including most of the commercial bishoujo catalogue. The catch: Kirikiri packs its scripts, art, and audio into encrypted .xp3archives, and many studios apply a per-game encryption scheme on top. That's why Kirikiri has a reputation for being hard to translate. This guide walks through doing it end-to-end with RuneTranslate: reading the .xp3, handling encryption, translating the KAG .ks scenarios, and exporting a patch the game loads automatically.

What you need

• RuneTranslate for Windows— free, every engine and provider unlocked.
• A Kirikiri game folder — the directory with the game .exe and one or more .xp3 archives (commonly data.xp3, scenario.xp3, etc.). Signed KirikiriZ builds with .exe.emb / .xp3.sig files are recognised too.
• A target language — English, Spanish, French, German, Portuguese, Russian, Chinese, Italian, Turkish, Vietnamese, and 20+ more.
• One translation provider. Visual novels are dialogue-heavy, so an LLM (OpenAI / Anthropic) or DeepL usually reads best; free Google Translate works out of the box.

Step 1: Open the game and unpack the XP3

Launch RuneTranslate, click New project, and point it at the Kirikiri game directory. Engine detection runs automatically. The built-in XP3 reader opens the archive index — including the 17-byte compressed-index header large archives use — and pulls out the scenario files. Your original archives are never modified.

If the archive is encrypted, RuneTranslate tries to decrypt it with a library of roughly two dozen ported GARbroencryption schemes, plus a generic single-byte-XOR brute solver for simpler per-file scrambles. Most retail games fall into one of these. Schemes that need per-archive runtime state or a studio-held key remain unsupported — those are the genuinely locked outliers.

Step 2: How Kirikiri dialogue is extracted

Kirikiri stores dialogue in KAG .ks scenario scripts. RuneTranslate parses them and lists the translatable text in the editor:

• Dialogue and narration— the raw scenario lines.
• Smart attribute extraction— readable text inside tags like [ruby/], [ch text="..."], [name text="..."], and [button text="..."] is pulled out and translated, while the tag structure itself is preserved.

KAG inline control tags are masked behind numeric [[K#]]placeholders before anything reaches the provider, so the machine can't break the engine's formatting. Some KirikiriZ games also ship their scenario as a compiled PSB .scn binary (the PSB\0format) — RuneTranslate parses and repacks unencrypted PSB scenarios (format versions 1 through 4) too, so those games translate just like text scripts.

Step 3: Translate and review

Pick a provider and run. For character voice and stylized speech, an LLM like OpenAI or Anthropic reads best; DeepL is fast and clean for narration; free Google Translate covers menus. Glossary your cast and recurring terms first so every route renders names identically — see Glossary 101. On the free tier translation is modestly throttled — roughly 2x slower on the AI providers, less on the free scrapers — with identical output quality; paid tiers run at full speed and add translation memory.

Every line lands in the editor next to its source. Edit inline (saves on blur or Ctrl+Enter), use find & replace, or run the optional AI refinerfor a context-aware second-pass proofread — valuable on long VN routes.

Step 4: Export a patch

Click Export. RuneTranslate writes the translated scenario as loose files plus a startup hook and, where it helps, a flat patch.xp3. It uses two override paths because no single one is universal:

• Loose files + startup hook — the hook's addAutoPathcall boosts loose files above the game's archives. Because different builds run a different init entry point, RuneTranslate writes the hook under all three names games use — AfterInit2.tjs, xAfterInit2.tjs, and xAfterInit.tjs— so whichever one the game calls picks it up.
• patch.xp3 — Kirikiri auto-mounts patch.xp3 / patch2.xp3with higher priority than the game's own archives ("later paths win"), so it overrides even when a game disables the startup hook. On encrypted builds its entries are pre-encrypted with the game's own scheme. Note that builds which enforce archive signatures reject an extra patch.xp3, so on those the loose-file hook is the path that carries the translation.

The output is your translation dropped next to the original game. Launch the .exe and it plays in your target language.

Known limitations

• Encrypted XP3 with a per-game scheme that needs runtime state, lookup tables, or a studio-held key is not supported — roughly two dozen GARbro schemes plus an XOR brute solver are built in, which covers most retail games but not every outlier.
• Encrypted / MDF-compressed PSB .scnscenarios are skipped; only unencrypted PSB (versions 1–4) is supported.
• Compiled or tokenized KAG .ks bytecode (binary / jkmagic that doesn't descramble to text) is skipped — only readable KAG scripts and unencrypted PSB scenarios are parsed.
• Image text (logos, hand-drawn UI, CG captions) is not translated — outside machine-translation scope.

Why this is easier than the old way

The manual route meant identifying the encryption scheme, extracting the XP3 with GARbro, hand-finding the readable text inside KAG tags, translating it without breaking the markup, then re-packing or wiring up an override path correctly. RuneTranslate folds the whole chain — decrypt, extract, mask tags, translate, build both the loose hook and patch.xp3— into a few clicks, with the editor open so you control the wording.

See the Kirikiri engine page for the full feature list, read the Ren'Py guide for another visual-novel engine, or download RuneTranslate and try it on a real game.