How to translate RPG Maker games

RPG Maker is the engine you are most likely to run into when you go looking for Japanese indie games, and it is also the friendliest to translate. The game's text is not compiled into the executable — it sits in ordinary JSON or Ruby-serialised data files that ship next to the game. That is why RPG Maker translation works at all, and why the process below ends with a build you can actually play rather than an overlay that guesses at what is on screen.

This guide covers identifying which RPG Maker you have, the export flow, exactly what gets translated, how control codes survive a machine translator, and what to do when a line comes back wrong. It is written to be useful whether or not you use RuneTranslate to do it.

Which RPG Maker do I have?

Most people asking this question do not know which version they are holding, and the answer changes what is possible. Open the game folder and look for the first thing on this list that matches:

• A `www/` folder containing www/data/*.json — RPG Maker MV. The game is an nw.js app; the executable is usually Game.exe next to www/.
• A bare `data/` folder with .json files and no www/ — RPG Maker MZ. MZ moved everything up one level, which is the fastest way to tell the two apart.
• `Data/` holding .rxdata, .rvdata or .rvdata2 — RPG Maker XP, VX and VX Ace respectively. If Data/ looks empty, check the root for Game.rgssad, Game.rgss2a or Game.rgss3a; that is the same data inside an encrypted archive.
• `RPG_RT.exe` in the root, with .lmt and .lmu files — RPG Maker 2000 or 2003. Different engine generation entirely.
• A .exe that is tens or hundreds of megabytes with no www/ or data/ beside it — likely an Enigma Virtual Box build with the data packed inside the executable. See below.

MV and MZ are close enough that people mix them up constantly, and they differ in ways that matter once you start editing. The MV vs MZ comparison goes through the folder layout, the plugin format and the message box differences.

RPG Maker 2000 and 2003 game text is not supported. RuneTranslate reads their .lsd save files through the save editor and nothing else. If you have an RPG_RT.exe game and you want to translate its script, the right tool is EasyRPG, not this one. Better that you leave this page now than spend an hour finding out the hard way.

The four-step flow

1. Point New Project at the game folder. Pick the folder that contains Game.exe. The engine is detected from what is inside — you do not choose MV or MZ from a dropdown, and if detection disagrees with what you expected, that is worth reading as information.
2. Pick a provider and a target language. Nine providers are available and three of them need no API key or account at all.
3. Translate. The runner batches units, retries failures with backoff, and shows a real progress bar with an ETA. You can edit any line in the table while it runs and after it finishes.
4. Export a playable build to a folder you choose. What lands there is a complete, runnable copy of the game with the translated data files in place.

The original game folder is never modified. Every write goes to the output folder you picked, which means a bad export costs you nothing but disk space — delete it and export again. It also means you can keep the Japanese build installed and playable side by side.

RuneTranslate runs on Windows 10 and 11, and on Linux and the Steam Deck under Wine or Proton. A free Patreon sign-in is required on first launch. The free tier unlocks every engine and every provider — it throttles throughput and holds one project at a time rather than locking features behind a paywall.

What actually gets translated

For MV and MZ, the extractor walks every map file and every event command list, and pulls the commands that produce player-visible text:

• `401` Show Text — the dialogue line. This is the bulk of any RPG Maker game.
• `405` Show Scrolling Text — intros, credits, letters, exposition crawls.
• `102` Show Choices — the choice window entries. The When [choice] branch labels render from this same array, so translating the choice translates both.
• `320` / `324` / `325` — Change Actor Name, Nickname and Profile, which games use for reveals and transformations mid-story.
• The database — Actors.json (name, nickname, profile), Classes.json, Skills.json (name, description, and the message1 / message2 battle lines), Items.json, Weapons.json, Armors.json, Enemies.json, States.json.
• `System.json` — the game title, the currency unit, and the full terms table: every menu label, command name and basic-status string the engine draws.
• `MapInfos.json` map names and CommonEvents.json — common events carry a surprising amount of script in games that route dialogue through a shared handler.
• Plugin parameters in plugins.js, and MZ plugin-command arguments (command code 357). This is where a lot of modern MV/MZ games keep their menu text.

Event comments (108 and their 408 continuation lines) are developer notes the engine does not show to players, so they are excluded by default. They are not deleted — they appear as opt-in rows you can tick, because a handful of balloon and popup message plugins do render them. The same treatment applies to anything the classifier reads as a code identifier or a file path: excluded, visible, reversible.

Control codes, and why they break translations

RPG Maker dialogue is not plain text. It carries inline escape codes the engine expands at draw time:

• \C[1] — switch text colour to palette index 1.
• \N[2] — substitute actor 2's name.
• \V[3] — substitute the value of variable 3.
• \G — the currency unit.
• \I[123] — draw icon 123 inline.
• \. \| \! \{ \} — wait a beat, wait a second, wait for input, grow the font, shrink it.

Hand any of these to a machine translator raw and you will get them back mangled. Google Translate reorders them. Small local models drop a bracket, lowercase the letter, or replace the ASCII brackets with full-width ones. An LLM will occasionally decide \C[1] is a typo and helpfully remove it. The result in game is a text box that prints a literal backslash, loses its colour halfway through, or shows a blank where a character's name should be.

RuneTranslate masks every code as a numbered placeholder — [[T0]], [[T1]] — before the provider ever sees the string, then restores them from the mapping afterwards. The restore is deliberately tolerant: it accepts a placeholder that came back with a bracket missing on one side, extra whitespace inside, a lowercase letter, or full-width brackets, because in practice all four happen. If a code goes missing entirely the unit is flagged rather than silently shipped.

Two less obvious cases are covered by the same mechanism. RPG Maker also uses printf-style substitutions — %1 and %2 in Terms and in skill battle messages, as in %1の攻撃！ where %1 becomes the actor's name — and those are masked too, because a weak provider will invent bracket junk in their place. And many games ship a name-substitution plugin using bare bracketed tokens like [名前] or [呼名] that the engine swaps for the player's name at runtime; those are masked as well, narrowly enough that ordinary bracketed prose is left alone.

Plugin-defined multi-letter codes such as \FFF[20] or \FH[ON] match the same pattern and are protected without any per-plugin configuration.

Word wrap at 46 characters

Japanese fits far more meaning per character than English does. A line that filled the message box comfortably in Japanese will run off the right edge once translated, and RPG Maker does not wrap for you — it just draws past the window and the overflow is invisible. You will not notice until a player tells you half a sentence is missing.

On export, dialogue in 401 and 405 commands is wrapped at 46 characters per line, which is roughly what the default message window holds at the default font size. Breaks are inserted at word boundaries, and newlines already present in the source are preserved, so the author's own page breaks and deliberate line splits survive. Games with a custom message system or a smaller font may want a different number; a game that draws text in a wider window will simply wrap earlier than it needs to, which is cosmetic rather than broken.

Encrypted images and archives

MV and MZ ship an asset encryption option that renames images to .rpgmvp or .png_ and XORs a header over them. RuneTranslate does not assume the standard scheme — it recovers the header length, the XOR run length and the key from the file's own bytes, using the PNG signature as known plaintext and the IHDR CRC32 as the check. That matters because encryption plugins exist that use different parameters (32-byte header, 32-byte run, a mirrored key) and because plenty of games have had the key stripped out of System.json. RPG Maker's own scheme validates on the first iteration, so nothing slows down for the common case, and anything written back is re-encrypted with the same scheme so the game's own decryptor still loads it.

For XP, VX and VX Ace, the .rgssad / .rgss2a / .rgss3a archive is read directly and the Ruby Marshal data inside is parsed in TypeScript — no Ruby install, no external unpacker. Support there is best-effort: XP and VX games store text as Shift-JIS byte strings rather than tagged UTF-8, which makes encoding edge cases more likely than on MZ.

Text that is painted into artwork — a title screen, a menu button, a sign in a CG — is not in any data file and no extractor can reach it. That is what the Image Studio is for: detect the text regions, clean the plate, typeset the replacement, bake it back into the game's own image format, encryption included.

Enigma Virtual Box packed games

A fair number of distributed RPG Maker games have no visible www/ or data/ folder at all, because the whole virtual filesystem was packed into the executable with Enigma Virtual Box. The giveaway is the EVB\0 marker in the exe and a game folder that looks suspiciously empty.

These are detected and handled. The packed filesystem is unpacked into a per-project workspace, the data is extracted and translated normally, and on export the entire virtual filesystem is written out as a runnable folder — the restored inner executable, its DLLs, and www/ — with the translated data patched in. You run the extracted inner executable, which is at that point a plain unpacked game reading loose data files.

It has to work that way. An earlier approach dropped a translated www/ next to the packed executable and it silently did nothing: the running wrapper resolves www/ from its own embedded virtual filesystem and ignores files on disk. If you are doing this by hand with another tool, that is the trap — the translation appears to apply and the game loads the original text anyway.

Which provider to pick

Nine providers are supported, and three of them need no API key and no account anywhere: Google, the free DeepL endpoint, and DeepL with a Classic or Next-gen model choice. You can translate an entire RPG Maker game without paying anyone or signing up for anything. The paid options are the DeepL API, OpenAI, Anthropic Claude, DeepSeek, any OpenAI-compatible endpoint, and a local model through Ollama or LM Studio if you would rather nothing left your machine.

The short version for RPG Maker specifically: the free scrapers are fine for menus, item names and short lines, and they are what most people should start with. They struggle on onomatopoeia — if a provider hands back the source unchanged, the unit is marked failed with a note rather than quietly passing Japanese through to your export. An LLM is noticeably better on long dialogue, on tone, and on anything where the speaker's register matters. The provider comparison has the actual trade-offs, and the AI refiner covers running a second pass over a finished translation to clean it up.

Keeping names consistent

The single most common complaint about a machine-translated RPG Maker game is that the protagonist is called four different things. A glossary fixes it — pin the reading you want for every character, place, item and skill before the run, and every batch uses it. The glossary guide walks through building one. Translation memory helps in the same direction: identical source strings get identical translations across the whole project, which matters in an engine where the same item description appears in a shop, a menu and a chest event.

One RPG Maker-specific trap: some plugins key off the speaker's name string with exact equality — the TRP Skit family for MZ is the well-known one. Translate the name in Actors.json and leave it in the plugin's data and the match fails silently, so the portrait or the skit never fires. RuneTranslate syncs both sides at export. If you are editing by hand, remember that a name in RPG Maker can be both display text and a lookup key at the same time.

When something goes wrong

A line is still in Japanese

Three usual causes. It was never extracted, because it lives somewhere the extractor does not walk — a custom plugin's own data file, or text baked into an image. It was extracted but excluded, because the classifier read it as an identifier; look for it as an opt-in row and tick it. Or the provider returned the source unchanged, which shows as a failed unit you can re-run on a different provider. If you translated the game before updating the app, use Re-scan source from the editor's ⋯ menu — rescanning only adds units, it never deletes your existing translations.

Text overflows the message box

The default wrap targets the default window. A game with a custom message system, a larger font, or a portrait eating half the box will need shorter lines. Edit the offending unit directly and insert your own line breaks — manual breaks are preserved through export. This is also the fix when a translation is simply too verbose: rewrite it shorter rather than fighting the wrap.

The game will not start after export

Almost always a broken data file rather than bad text. Check that you launched the executable in the output folder and not the original. On an EVB build, confirm you are running the extracted inner executable. If a specific event crashes, the suspect is a control code that did not survive — open that unit and compare its codes against the source. Keep the original game folder untouched so you always have a working baseline to compare against.

A plugin string must not be translated

Plugin parameters mix display text with switch names, file paths, keybindings and mode flags in the same block. Anything that reads as a code identifier or a path is excluded automatically, but a plugin using Japanese words as internal keys will slip through. Mark those units as excluded and they stay in the source language on export. Regex filters do this in bulk when a plugin's parameters share a naming pattern.

Honest limits

• RPG Maker 2000 / 2003 game text is out of scope. Save files only, through the save editor. Use EasyRPG for the script.
• XP, VX and VX Ace are best-effort. The archive reader and Ruby Marshal parser are pure TypeScript and work, but the older Shift-JIS string handling is a rougher surface than MV/MZ.
• Text compiled into a custom plugin's JavaScript is reachable only when it looks like data. A plugin that hardcodes strings inside its own logic is a manual edit.
• Natively protected MZ builds — where the data is decrypted below the JavaScript layer — are handled through a runtime capture and overlay path rather than by reversing the encryption. It works; treat it as best-effort and verify the export before committing to a long run.
• Nothing here is a substitute for playing the build. Extraction counts and a green progress bar are not proof. Launch the exported game and read the first ten minutes.

Two adjacent things worth knowing

Cheat Mode reads an RPG Maker game's own switches, variables and items and lets you flip them, which is the fastest way to reach a late-game event you need to check the translation of — and it is how most people verify an export without replaying twenty hours. The save editor opens MV/MZ, XP/VX/VX Ace and 2000/2003 .lsd saves directly, so a stuck playthrough or a missing key item does not end a run.

If you want the broader picture first, the engine list covers all seventeen supported formats, the RPG Maker engine page has the format detail, and the general how-to is the version of this guide that is not engine-specific. When you are ready, the download page has the installer.