How to translate a Ren’Py game to English (full walkthrough)

Ren'Py is the Python-based engine behind most Western and Japanese visual novels — from tiny itch.io jams to commercial DLsite titles. It's one of the cleanest engines to translate: RuneTranslate never overwrites the original script, it layers the translation on top so the game stays intact. This guide walks through translating a Ren'Py game to English (or any language) end-to-end with RuneTranslate, including the three shapes a Ren'Py game ships in — loose .rpy source, compiled-only .rpyc, and archived .rpa.

What you need

• RuneTranslate for Windows— free, every engine and provider unlocked.
• A Ren'Py game folder. This is the directory containing the game's .exe plus a game/ subfolder (which holds .rpy, .rpyc, and/or .rpa files).
• A target language — English, Spanish, French, German, Portuguese, Russian, Chinese, Italian, Turkish, Vietnamese, and 20+ more.
• One translation provider. Free Google Translate works out of the box; DeepL has a free tier; OpenAI, Anthropic, a local model (Ollama / LM Studio), and any OpenAI-compatible API are bring-your-own-key. Visual novels are dialogue-heavy and tone-sensitive, so an LLM (OpenAI / Anthropic) or DeepL usually reads best.

Step 1: Open the game folder

Launch RuneTranslate, click New project, and point it at the Ren'Py game directory (the folder with the .exe, or the inner game/folder). Engine detection runs automatically and recognises the project as Ren'Py the moment it sees a game/ tree.

How the text gets read depends on what the developer shipped:

• Source games — loose .rpy scripts under game/. RuneTranslate parses them directly. This is the ideal case.
• Compiled-only games — only .rpyc bytecode. A bundled unrpyc sidecar decompiles them back to readable .rpy first, then parses as normal.
• Archived games — scripts packed into a .rpa archive. RuneTranslate unpacks it with a vendored, patched rpatool into a per-project workspace under %APPDATA%/RuneTranslate/renpy-workspace/<projectId>/, decompiles, then parses. Our rpatool fork auto-detects obfuscated and vendor-custom RPA-x.y archive keys, so it opens many archives upstream tools refuse.

Your original game folder is never modified.

Step 2: How Ren'Py text is extracted

RuneTranslate pulls the say statements (dialogue), menuchoices, and translatable UI text out of the script and lists them in the editor, grouped by file. Ren'Py text markup — {b}, {color=#fff}, {w} waits, {i} italics, and [player_name]style variable interpolations — is masked behind numeric [[R#]]placeholders before anything reaches the provider, then restored on the way out. The machine never sees the tags, so it can't mangle, drop, or translate them.

Step 3: Translate

Pick a provider and run. For a mid-length visual novel (~8,000–15,000 lines) on Supporter tier:

• OpenAI / Anthropic— best for character voice, jokes, and stylized speech; roughly a few dollars in API cost for a full game. The editor shows a token + USD estimate before you commit.
• DeepL— fast and clean for narration; free tier covers 500k characters/month.
• Free Google Translate— $0, fine for menus and short lines, weaker on dialogue.

Glossary your cast and recurring terms up front so every scene 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 (lower concurrency, smaller batches, a short pause between batches) — with identical output quality. Paid tiers run at full speed and add translation memory and provider routing.

Step 4: Review in the editor

Every line lands in the table next to its source — Japanese by default, or whatever language you set the project to (Chinese, Korean, English, and more). Edit anything the machine got wrong inline (auto-saves on blur or Ctrl+Enter), use find & replace for a term you renamed, or run the optional AI refinerfor a context-aware second-pass proofread. Because Ren'Py dialogue is long-form, this is where the polish happens.

Step 5: Export a playable build

Click Export. RuneTranslate doesn't rely on Ren'Py preferring a loose .rpy in tl/ — that only works for text keyed by dialogue ids, which compiled games don't hand out reliably. Instead it drops a few files into game/ and applies the translation at runtime:

• rt_translations.json— a source-text → translation map for every dialogue and menu line.
• zzz_runetranslate_language.rpy— a small runtime hook that installs a config.say_menu_text_filter. It matches each line the game is about to show against the map and swaps in your translation, and it forces the game's active language to the translated one so screen and UI text follows.
• tl/translated/translation.rpy — holds only the _()UI / screen strings (buttons, menus, tooltips), which Ren'Py does resolve reliably by their own mechanism.
• A bundled font plus zzz_runetranslate_font.rpywhen the target language needs one — see the non-Latin note below.

Run the game's .exeand it plays in your target language, with the original scripts and archives untouched. To switch back, remove the files RuneTranslate added — rt_translations.json, zzz_runetranslate_language.rpy, the bundled font and its .rpy, and tl/translated/.

Non-Latin languages

Most Ren'Py games ship a Latin-only font, so Chinese, Korean, Japanese, Thai, or Arabic would otherwise render as blank boxes. When you target one of those, RuneTranslate bundles a suitable font (NanumGothic / Noto Sans) and routes every font the game uses through Ren'Py's config.font_replacement_map, so the translated text shows up correctly without editing the game's own assets.

Known limitations

• Standard RPA-2 / RPA-3 / RPA-3.2 / RPA-4.0 and common vendor-obfuscated archives open automatically; a genuinely non-standard container or an externally-held key may not unpack.
• Text baked into images (title logos, hand-drawn UI, CG captions) is pixel work and isn't translated — outside machine-translation scope.
• Heavily scripted screens that build strings at runtime from variables may need a quick hand-fix pass in the editor.

Why this is easier than the old way

The manual route meant decompiling .rpyc by hand, running rpatool on the archive, then either translating the source in place (and re-breaking it on the next game update) or hand-authoring tl/blocks line by line — and still fighting missing fonts on non-Latin languages. RuneTranslate does the decompile + unpack + extract + runtime-hook chain in a few clicks, while keeping the editor open so you control the wording.

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