Frequently asked questions

RuneTranslate is a Windows desktop app that translates Japanese games into your language by reading the game's own data files. It detects the engine, extracts every line of dialogue, menu text, item name and choice into an editable project, translates them through the provider you choose, and then exports a playable build you keep — not an overlay that has to run alongside the game. Sixteen engines are supported, plus the gettext .po and .mo catalog format, and 35 target languages.

Translating a game with RuneTranslate takes four steps. Point New Project at the game folder and let it detect the engine and count the text. Pick a translation provider and press Translate — you watch the progress bar and a live ETA. Read through the editor and fix anything that reads wrong, using find and replace, regex filters or the AI refiner. Then press Export and choose an output folder: RuneTranslate writes a translated, playable build there and never touches the original game.

RuneTranslate does require an account: the app signs you in with Patreon on first launch and there is no signed-out or anonymous mode. Signing in is free and takes one click — you do not need to pledge anything. The free tier simply means you are signed in with no active pledge, and it unlocks every engine, every provider and the whole editor. After that first sign-in the app verifies your token on your own machine, so you can keep working without a connection.

A whole game usually finishes in one sitting with RuneTranslate. A short visual novel of a few thousand lines takes minutes on the free Google or DeepL routes. A dense RPG of 30,000 to 100,000 lines takes anywhere from twenty minutes to a few hours depending on the provider you chose, how many requests it will accept in parallel, and whether you are on the free throttle or a paid plan. Runs resume where they stopped, translation memory skips lines you have already translated once, and the Supporter overnight batch queue can chain several projects while you sleep.

What RuneTranslate produces depends on what the engine can load, and it always writes to an output folder you choose rather than over your game. Most engines get a full translated copy of the game folder that you run directly. Some get a small override instead, because that is what the engine reads first: Kirikiri gets loose files plus a patch archive, Unreal gets a small override pak you drop into Content/Paks so a 60 GB game is not duplicated, and Ren'Py gets translation files written into the game folder copy. Either way the result is a standalone translated build you can keep and play offline.

Going back is always possible with RuneTranslate, because the original game is never modified. Export writes to a separate output folder you pick, so undoing an export is a matter of deleting that folder — your installed game is untouched. Inside a project you can also reset any line back to the Japanese it was extracted from, which is stored in the project file at creation time, so a Reset followed by an Export gives you the original text back even if the folder you exported to earlier was overwritten.

RuneTranslate is free to use once you sign in with Patreon. Every engine, every translation provider, the whole editor, the save editor, the core of Cheat Mode and the AI refiner are unlocked with no pledge. Free is a throughput throttle rather than a feature paywall: translation runs roughly twice as slow on AI providers and a little slower on the free scrapers, you can keep one project at a time, and the Image Studio opens read-only. What paid adds on top is listed in the next answer — full speed, translation memory, the glossary, provider routing, collaborative hosting, the batch queue and more project slots — but no engine, provider or editor feature is ever locked away from free.

Supporter is 3 dollars a month on Patreon and removes the speed throttle, adds cloud translation memory, the glossary, provider routing, collaborative project hosting, the overnight batch queue, the Image Studio editor, beta channel builds and 10 concurrent projects. Pro is 5 dollars a month and includes everything in Supporter plus animated scene themes, 30 concurrent projects, a bring-your-own translation proxy pool for the free scraper routes, and a larger daily Image Studio quota. Nothing in either tier locks an engine or a provider away from free users.

Developer is RuneTranslate's top tier and a superset of Pro. It adds the Developer interchange tab for bulk localization work — importing and exporting CSV, JSON, PO and XLIFF in one pass, so a project can move in and out of an existing translation pipeline — along with the highest project limit of 100. It is aimed at studios and localization teams rather than individual players, and it is quoted rather than listed: contact us through the site and we will price it for your case.

The number of RuneTranslate projects you can keep at once depends on your tier: 1 on free, 10 on Supporter, 30 on Pro and 100 on Developer. It counts the projects sitting in your library, not how many games you may ever translate — finish a game, export it, delete the project and the slot is free again. Collaborative projects you host or join do not count against it. Exported builds and the translations you have already made are yours permanently and are not affected by the limit.

Speed is the main thing the free tier throttles. It sends fewer requests in parallel, halves the batch size and adds a short pause between batches, which works out at roughly twice the wall-clock time on AI and LLM providers and a smaller gap on the free scrapers, since those are limited by the endpoint rather than by us. Quality is identical — the same provider, the same prompt, the same result. A banner above the progress bar explains the slowdown while a run is going. Free also keeps one project at a time, opens the Image Studio read-only, and allows one patch export and one import every three days; the Supporter extras — translation memory, the glossary, provider routing, collaborative hosting and the batch queue — are listed above.

Translations you have already made with RuneTranslate stay yours. Project files live on your own disk, exported builds are standalone folders you can play with the app closed, and nothing expires or phones home to keep a finished translation working. If a subscription lapses you drop back to the free tier, which still gives you every engine, every provider and the full editor at the throttled speed; the paid extras such as cloud translation memory and the extra project slots pause until you resubscribe.

RuneTranslate is a text-editing tool for games you already own, and it is built to stay on that side of the line. It reads a game's documented data formats, extracts the text, and writes a translated build for your own use — it does not remove copy protection, does not distribute game content, and never uploads a game anywhere. Personal translation of a game you bought is broadly accepted practice, but copyright law varies by country and by the game's own licence, so check your jurisdiction and do not redistribute a translated build without the rights holder's permission. Share the .rtpatch file instead: it carries your translations and the source lines they attach to, and no game files, artwork or executables.

RuneTranslate never sends your game's text to our servers unless you switch on a feature that needs it. Extraction, the editor, project storage and export run entirely on your machine, and translation requests go straight from your PC to the provider you chose — we never proxy them. What the app does talk to us about is your account: it refreshes your sign-in token, asks for your speed allowance when a run starts, and checks for updates. Anonymous usage statistics — engine, provider and language labels, plus a line count — are also sent after a run unless you switch them off in Settings. Four optional features carry real content, and it is worth knowing which: cloud translation memory stores your source and translated pairs privately under your account, collaborative projects keep that project's text on the server so the other people can see it, the Image Studio sends the image crop you are reading or repairing to our hosted recognizer, and a support ticket carries whatever text and files you attach until the ticket expires. With those four switched off, no game text and no translations leave your machine.

Your API keys never leave your machine in RuneTranslate. They are encrypted at rest with Windows DPAPI — the same mechanism Chrome uses for saved passwords — and stored in the app's own user data folder. Translation requests are made directly from your PC to the provider's API using that key, so it is only ever seen by the provider you are paying. Our servers never receive a key, and there is no code path that would send one.

RuneTranslate is a normal Windows installer that puts an Electron desktop app in your user profile — no admin rights, and you can choose another folder during setup — with no bundled toolbars, no advertising, no telemetry you cannot switch off, and no background service left running when you close it. It does bundle several open-source helper tools that read game formats, all shipped under their own licences. The build is unsigned, so Windows SmartScreen may show a warning on first run — you can compare the installer against the checksum published with each release on runetranslate.com. Anonymous usage statistics are optional and can be turned off in Settings.

Translating a game never writes to your game folder. Extraction opens the game read-only, any unpacking happens in a per-project workspace inside the app's own data folder, and Export writes a fresh translated copy or a small override file into an output folder you select. That is deliberate, so a failed export or a bad translation can never cost you the installed game. The one feature that does modify a game in place is Cheat Mode, which you point at a folder on purpose and which has a one-click Remove. Back your game up anyway if it is irreplaceable, and note that some engines produce a full game copy, so make sure the output drive has room.

Everything RuneTranslate stores about you is small and removable. Projects and settings live in the app's own folder on your PC and go away when you uninstall. On the server side, an account holds your Patreon identity, your tier, your device list, and — only if you used those features — your cloud translation memory entries, any collaborative project you host, and any open support ticket. Translation memory is managed and can be cleared at runetranslate.com/account/translation-memory, support tickets are deleted automatically once they go idle, and you can ask us to delete the account itself by email.

RuneTranslate ships 35 target languages, covering English, Spanish, French, German, Portuguese, Italian, Russian, Chinese (simplified and traditional), Korean, Japanese, Polish, Turkish, Vietnamese, Thai, Indonesian, Arabic and many more. Which of them read well depends partly on the game: an engine that stores text in Shift-JIS, such as RPG Maker XP and VX or older visual novel engines, is happiest with Latin-script targets, and some engines need a font bundled with the export for Cyrillic, Greek or CJK output — RuneTranslate does that automatically for Ren'Py. The app's own interface is available in 18 languages.

Japanese is RuneTranslate's default source language but not its only one. You set the source per project, so a Chinese, Korean, English or European-language game extracts and translates the same way — the engine adapters key on the game's file formats, not on the script the text is written in. Chinese-to-English and English-to-anything are common uses. The one thing worth checking is that the source language you pick matches what the game actually contains, since some engines use it to decide which strings are text and which are engine wiring.

RuneTranslate is a Windows application, built and tested for Windows 10 and Windows 11 on x64. There is no macOS build and no native Linux build, and none is currently planned — the games it translates are overwhelmingly Windows games, and several of the bundled format tools are Windows binaries. On Windows you need nothing installed beforehand — the installer brings every format tool the engines use, and the few .NET helper tools rely on the .NET Framework that Windows 10 and 11 already include.

RuneTranslate runs well on Linux and the Steam Deck through Wine or Proton, even though there is no native build. Install the ordinary Windows version into a prefix and it behaves the same as on Windows, with the same engines, providers, editor and export. That is a natural fit, because the Japanese games it translates are Windows games that you are already running through the same compatibility layer. Most engines need nothing extra; RPG Developer Bakin additionally wants the .NET Framework in the prefix, which winetricks can install.

RuneTranslate ships nine translation providers and you can switch between them at any time. Four use your own API key: DeepL, OpenAI, Anthropic Claude and DeepSeek. A fifth, the OpenAI-compatible provider, takes any key and base URL, so OpenRouter, NanoGPT and self-hosted endpoints work. Three need no key and no account at all — Google Translate, DeepL through its free anonymous route, and a second free DeepL route that lets you choose between its classic and next-generation models. The ninth is Local Model, which talks to Ollama or LM Studio on your own hardware.

An API key is optional in RuneTranslate. Three of the nine providers are free and need no key or account: Google Translate, and two free routes to DeepL, one of which lets you pick its next-generation model. A local model through Ollama or LM Studio also needs no key and costs nothing per line. Keys only come into it if you want the official DeepL API, OpenAI, Anthropic Claude, DeepSeek or another OpenAI-compatible endpoint, and even then the key stays encrypted on your own machine.

The cheapest way to translate a game in RuneTranslate costs nothing: Google Translate and the two free DeepL routes need no key and no account. They are unofficial endpoints, so they are rate-limited and can change without warning — the free DeepL route is deliberately paced at about one request a second with a circuit breaker so it does not get you blocked — which makes them best for short strings and small to medium games. Among paid options, DeepSeek and the small Claude and GPT models are the cheapest per million characters. Provider routing on Supporter and above cuts cost further by sending short menu strings to a free provider and keeping dialogue on your paid one.

Quality in RuneTranslate depends on the game rather than on one universal winner. DeepL is the strongest plain machine translation for straightforward narrative and is fast. The large LLMs — GPT, Claude and DeepSeek — read context across a batch and handle slang, register and character voice much better, which matters most in visual novels. RuneTranslate's own prompt tells every LLM provider to romanize Japanese onomatopoeia rather than echo it, so んん comes back as “Mm…” whichever of them you pick. The practical approach is to run a few hundred lines on two providers, read them side by side in the editor, and pick before committing to the whole game.

RuneTranslate can translate entirely on your own hardware through its Local Model provider, which talks to any OpenAI-compatible local server such as Ollama, LM Studio or llama.cpp. Point it at your server URL, choose an installed model, and translation runs with no API key, no per-token cost and no text leaving your PC. It is slower than a hosted API because it sends small batches one at a time, and quality tracks the model you run — a good local model handles menus and short dialogue well, while the large hosted models still lead on nuanced long-form prose.

The AI refiner is RuneTranslate's optional second pass over a finished translation. It sends lines back to an LLM with the original Japanese alongside the current translation and asks for a corrected version, which catches stiff machine phrasing, wrong pronouns, lost politeness levels and lines that came back unchanged. You can run it over a whole project or over a selection, and the editor keeps the first-pass translation beside the refined one, so you can see exactly what it changed and edit or roll back any line rather than taking it on trust. It is available on every tier, free included.

Provider routing is a RuneTranslate feature, available from Supporter upward, that splits one run into two lanes by string length. Short strings — item names, Yes and No, menu labels — go to a cheap or free provider, while anything longer than your chosen threshold stays on your premium provider where the context actually matters. The two lanes run in parallel, so the run is no slower, and on a large RPG where most units are short labels it typically cuts the LLM bill by a factor of two to three.

Editing by hand is the point of RuneTranslate's editor rather than an afterthought. Every extracted line is a row you can rewrite, with the Japanese source beside it, grouped by map, scene or file so you can read a conversation in order. There is find and replace across the whole project with regex support, bulk operations on a filtered selection, and filters for lines that are pending, failed or already edited. Edits save on blur or Ctrl+Enter, and Escape cancels. Re-running the translator preserves lines you edited and only retranslates pending or failed ones unless you explicitly ask for a full retranslation.

Translation memory is RuneTranslate's cache of every Japanese line you have already translated and what it became. When the same line appears again — later in the same game, or in a completely different one — it is filled in instantly with no provider call, which saves money on LLM runs and makes your hand-fixed wording propagate forward. Since version 0.18.0 it is stored privately per user on our servers rather than in a local file, so it follows you between PCs, and you can browse or clear it at runetranslate.com/account/translation-memory. It is available on Supporter, Pro and Developer. Results from the free unofficial scraper routes are not written into it by default, so a rough machine pass does not poison the cache, and you can opt any provider in or out.

A glossary in RuneTranslate forces specific terms to come out the same way every time, regardless of provider or model mood. Add a pair such as 勇者 to Hero, or アリス to Alice, and every occurrence in the game renders exactly that way — which is what keeps character names, place names, signature attacks and item terminology consistent across a 40-hour RPG translated in dozens of batches. The substitution is applied through opaque placeholders before the text is sent, so plain machine-translation providers respect it as well as LLMs do. The glossary is available from Supporter upward.

Glossaries in RuneTranslate import and export as CSV from Settings, with columns for the source term, the target term and the target language. Import offers Merge, which adds the rows on top of what you have and de-duplicates, or Replace, which wipes the existing list. CSVs written by Excel work as-is. It is the practical way to share a glossary with a collaborator, reuse one across a series of games by the same circle, or back up a large term list before a big edit.

RuneTranslate supports collaborative projects, where one person hosts a project and invites others to work on it live. Everyone sees each other's edits as they land, with presence indicators showing who is on which section, and later edits win where two people touch the same line. Hosting a collaborative project needs Supporter or above, but joining one is free — so a paying host can bring in as many free helpers as they like. That project's text lives on our server for as long as the session exists, and an idle collaborative project expires after 15 days.

RuneTranslate exports your work as an .rtpatch file — the unit ids, the source lines it matches on and your translations, and no game files or assets at all. Your friend opens their own copy of the game as a project, imports the patch, and exports a translated build for themselves — which is both the polite way to share and the safe one, since no game binaries or artwork change hands. It is also how you move your own work between PCs, hand a project to a proofreader, or update a translation after the game gets patched. On the free tier you can export one patch and import one every three days; paid tiers are unmetered.

When a game you have translated gets an update, you do not start over in RuneTranslate. Re-scan the source in the existing project and the extractor adds the lines that are new while keeping the ones you already translated matched to their identifiers; translation memory fills in anything the developer merely moved or repeated. You then translate the remaining handful and export again. The caveat is that a few engines address text by position rather than by a stable key, so a large structural change to the game can shift identifiers — re-scan only ever adds newly-detected lines, so if a rebuilt game comes back with far more new rows than you expected, creating a fresh project (and letting translation memory refill it) is the cleaner route.

The batch queue is RuneTranslate's way of translating several projects unattended. Queue up to ten projects on Supporter (thirty on Pro), start it before bed, and each one runs to completion and hands off to the next, with the results waiting in the editor in the morning. It is a Supporter and above feature, it uses each project's own provider and language settings, and it is the natural companion to a paid tier where a full-speed run on a large RPG is measured in hours rather than minutes.

RuneTranslate includes a local MCP server, so an assistant such as Claude Desktop can talk to it directly — listing your projects, reading extraction reports, inspecting units and, on a paid tier, driving translation and export. It is off by default and, when enabled, listens only on loopback behind a token, so nothing outside your machine can reach it. Diagnosing a broken exported build through it is free on every plan.

RPG Maker is fully supported in RuneTranslate across five versions. MV and MZ are read from their JSON data files — dialogue, choices, scrolling text, items, skills, terms and plugin parameter strings — with in-game word wrap applied on export, and games whose data is packed inside the executable with Enigma Virtual Box are unpacked into a full runnable translated copy. The older Ruby-based XP, VX and VX Ace are read through an in-house Ruby Marshal implementation covering events, the database and system terms, including encrypted RGSSAD archives. XP and VX store text in Shift-JIS, so they suit Latin-script targets best; VX Ace is UTF-8 and takes anything.

Ren'Py is one of RuneTranslate's most complete engines, covering source games with loose .rpy files, compiled-only games with just .rpyc, and archived games shipped in .rpa — the last two are decompiled and unpacked with bundled tools before parsing. Beyond ordinary dialogue and menus it reaches screen buttons, text passed as arguments to helper labels such as phone and SMS systems, prose assigned to variables, and data tables for galleries and quest logs. The exported build carries a runtime hook that forces the game's language, and a font is bundled automatically when your target language needs glyphs the game does not have.

Kirikiri and KAG visual novels are fully supported in RuneTranslate, including encrypted XP3 archives: around 26 documented encryption schemes are implemented, plus a solver that recovers simple single-byte keys automatically, and archives appended inside the game executable are located the same way the engine itself does. It reads .ks scenarios with their ruby, name and button tags, and compiled PSB scenario files as used by KirikiriZ. Export ships both loose files with an AfterInit2 hook and a patch archive, because different games load overrides differently. Encrypted or MDF-compressed PSB scenarios remain out of scope.

Wolf RPG, known in Japanese as ウディタ, is supported in RuneTranslate through a bundled open-source sidecar that handles .wolf archive decryption and repacking, with the string data read out of the .dat and .mps files. Version 2.x is the proven path and has been confirmed playable on real games. Version 3.x, which stores compressed UTF-8 data in a different layout, has its own clean-room parser that round-trips byte-identically and lifted one real game from 7 extracted lines to 1,856 — and an exported 3.x build has been confirmed launching and showing its translations. Write-back is deliberately conservative: a line whose control codes would be disturbed is reverted to Japanese rather than risking a crash.

TyranoBuilder and TyranoScript visual novels are fully supported in RuneTranslate, in both their Electron-wrapped and HTML5 standalone forms. It translates every scenario file, the interface language file, the config, and character display names, which are injected as proper character definitions so the game's own name lookup keeps working. Inline KAG tags, including Japanese-named ones, are masked before translation and restored afterwards, and binary or encrypted scenario files are detected and left alone rather than corrupted.

RuneTranslate has a catch-all Electron adapter for visual novels built as custom Electron shells rather than on a named engine. It reads and rewrites the game's app.asar, scanning the JavaScript, HTML, JSON and scenario files inside it with a real lexer, which matters on modern React or Vite bundles where a naive scanner finds almost nothing. Cocos Creator games wrapped in Electron are covered too, with the engine's own asset manifest used to tell display text apart from resource identifiers so a translation cannot break asset loading. The rewrite is streaming, so a single button can be replaced inside a multi-gigabyte archive in seconds.

Unity games are supported in RuneTranslate on a best-effort basis, covering the text Unity keeps outside compiled code: TextAssets and MonoBehaviour string fields inside the asset files, level files and AssetBundles, loose StreamingAssets scripts, localization tables, multi-language CSVs and XUnity.AutoTranslator dictionaries. MonoBehaviour fields are read on both Mono and IL2CPP builds, encrypted Addressable bundles are decrypted and rewritten, and on Mono builds text compiled into Assembly-CSharp.dll is reached as well. Extensive guards mark identifiers, scene names and flow operands as opt-in rather than translating them, since translating one of those is what silently breaks a Unity game. Text compiled into an IL2CPP binary stays out of scope.

RPG Developer Bakin is supported in RuneTranslate through a bundled sidecar that drives the game's own data layer. It reads the database — item, skill, character, class and condition names and descriptions — plus event and scenario text out of the game's data pack, then applies your translation through Bakin's own built-in localization system as the game's default language, so the exported build opens already translated with no per-string binary patching. 3D models, textures, audio and any text compiled into a game's C# scripts are out of scope.

Gettext catalogs are supported in RuneTranslate as a format rather than an engine, which covers games localized with Poedit or Weblate and anything built on Python, pygame, SDL or Solarus. It reads both the editable .po source and the compiled .mo that the game actually loads, extracts every message with its plural forms and context, and on export compiles a fresh .mo beside each catalog so the game picks the translation up without any other change. If a game ships only .po sources, the export compiles the .mo it is missing.

Unreal Engine 4 and 5 games are supported in RuneTranslate for their externalized .locres text — user interface, menus, system messages and subtitles, which is most of what a player reads. It reads .pak archives in pure TypeScript without loading the whole file into memory, recovers the AES key from the shipping executable automatically for encrypted games, and unpacks UE5 IoStore containers through a bundled open-source tool with a filter that pulls only the localization files, so a 100 GB title takes seconds instead of a full rebuild. Export is a small override pak you drop into Content/Paks, not a copy of the game. Strings compiled into DataTables or cooked assets are out of scope, and a game with no .locres at all is reported honestly rather than failing silently.

LiveMaker, also sold as LiveNovel, is supported in RuneTranslate on a best-effort basis. A LiveMaker game is an executable with an archive appended to it, or a separate data file, holding compiled .lsb scenarios; a bundled sidecar reads each scenario in memory and pulls out dialogue, menu choices and interface captions, then repacks the archive into a full runnable translated copy. Split archives and the separate-index form are both handled, and the rebuild is re-opened and verified before anything is replaced. Extraction and repacking are confirmed on real games — one 411 MB title yielded 7,715 lines and repacked in five seconds — but launching an exported build has not yet been confirmed in-game.

Godot 3.x and 4.x games are supported in RuneTranslate and confirmed playable on real titles. It unpacks the .pck, including packs embedded in the executable and encrypted ones whose key it recovers from the binary, decompiles GDScript and converts binary scenes, and reads text from four different places a Godot game may keep it: script and scene literals, compiled translation resources patched in place by value, Dialogic timeline files, and — for C# games — a game's own string table when it ships a loader that can read a replacement file. Engine wiring such as node paths and resource identifiers is filtered out so a translation cannot break scene lookups.

YU-RIS, the raiL-soft engine, is supported in RuneTranslate with no sidecar at all — everything is pure TypeScript. It reads the .ypf package, parses the compiled YSTB scripts inside it, recovers each script's XOR key automatically, and pulls out the raw Shift-JIS dialogue along with quoted interface strings. Write-back relocates every value and patches its descriptor, so a translation that changes length still produces a valid script, and an unchanged script comes out byte-identical. Structural gates keep bytecode and jump targets out of the editor, which on one real game removed 78 percent of the rows without losing a single real line. Extraction is verified on real games; launching an exported build has not yet been confirmed in-game.

AliceSoft's System engine — the Rance series and the wider System 3.x / System 4 catalog — is supported in RuneTranslate across both System 3.x and System 4, implemented entirely in TypeScript. It reads the .ald and .afa archives, pulls message text out of the shared System39 symbol table on 3.x or the per-game .ain bytecode on System 4, including the compressed and encrypted container variants, and exports by loose-file override so the original archives are untouched. Three real games round-trip byte-identically, which proves extraction and write-back; launching an exported translated build has not yet been confirmed in-game, so verify on your title before a long run.

The Artemis engine, from iMel and also known as Mikage, is supported in RuneTranslate and confirmed rendering in-game. It reads PF8, PF6 and PF2 .pfs archives in pure TypeScript, including PF8's SHA-1 based encryption, and extracts dialogue, speaker names and choices from both the Lua .ast scripts — including the multilingual form where each block carries a branch per language — and the KAG-style .iet scenarios. Export ships a numbered override archive that the engine mounts after the base one, which is the same update mechanism the developers use, rather than loose files the engine would ignore.

NScripter and its open-source successor ONScripter are supported in RuneTranslate in pure TypeScript with no sidecar. It decodes the obfuscated nscript.dat, the Ponscripter variant and the plain-text script forms, handles Shift-JIS, and translates line by line while leaving every other byte identical. One rule matters more than the rest and is handled automatically: the engine decides what a line is from its first character, so an English line that used to be Japanese would be read as a command — RuneTranslate prefixes it to force single-byte text mode. Image text inside the .nsa and .sar archives can be read too, and overrides ship as loose files, which this engine prefers. Real-game in-game confirmation is still outstanding.

SRPG Studio, the SapphireSoft tactical-RPG maker common on DLsite, is supported in RuneTranslate through a bundled open-source C++ sidecar. It unpacks the encrypted data.dts, extracts every in-game text field, applies your translation and repacks the archive into a full translated copy of the game, since this engine has no loose-file override. The bundled tool covers SRPG Studio up to version 1.322; a game built on something newer may not unpack. A full unpack, edit, repack and re-read round-trip is proven on a recent real game.

If RuneTranslate does not detect your game, there are three things worth trying before giving up. Many games that look like an unknown engine are actually a supported one in disguise — a custom Electron shell, a Cocos Creator build, a Unity game with an unusual folder name — so open New Project and let detection look at the folder before assuming. If the game ships gettext .po or .mo catalogs, or a Unity-style localization table, those are read as formats regardless of the engine around them. And if it genuinely is not supported, email us at [email protected] with the game and a folder listing: most of the sixteen engines currently supported were added because someone sent in a game that would not open.

The Image Studio is RuneTranslate's editor for Japanese that is painted into a game's artwork — title screens, menu buttons, a stamp on a CG — which no text extractor can reach because it is pixels, not strings. It works in four correctable steps: detect the text regions, clean them off the artwork, typeset your translation with real control over font, size and position, and bake the result back into the game in its original format, including encrypted RPG Maker images and Kirikiri TLG. You can also export a page as a PNG, edit it in an external image editor and import it back. It works on RPG Maker, Kirikiri, NScripter, Ren'Py, Electron games and any engine keeping images in ordinary folders. Free accounts can open and read the Image Studio but not change anything; editing needs Supporter, and Pro raises the daily quota.

RuneTranslate has a built-in save editor on its own tab, and it is free on every tier. Drag a save file in and edit it directly — no project, no translation, no replaying an hour to fix a flag you missed or to top up gold. Edits save straight to the file, the first change copies the original to a backup beside it, and one click reverts. It is a separate tool from translation and works on games you have not translated at all.

RuneTranslate's save editor opens eight formats. RPG Maker MV (.rpgsave) and MZ (.rmmzsave) get the full structured editor: gold, each party member's level, HP, MP and EXP, variables, switches and inventory, with variable and switch names read out of the game's own System.json so you can tell what each one does. RPG Maker XP (.rxdata), VX (.rvdata), VX Ace (.rvdata2), RPG Maker 2000 and 2003 (.lsd), Ren'Py (.save) and TyranoBuilder (.sav) open in a variable editor that surfaces their stored values. On MV and MZ you can also have those variable and switch names shown in your language, which is a display mapping in the app only and is never written into the save.

The save editor in RuneTranslate changes only the fields you touch and re-serializes everything else exactly as it found it, writing through a temporary file so a crash cannot leave half a save behind. The first edit copies the original to a backup file next to it, and a Revert button puts that back in one click. That said, save formats are game-specific and a game can always reject a value it considers impossible, so keep your own copy of a save you care about before experimenting.

Cheat Mode is a separate tab in RuneTranslate that injects a live in-game cheat menu into an RPG Maker MV or MZ game, or enables the developer tools in a Ren'Py game. You point it at a game folder — no translation project needed — and it adds the menu in place, with a one-click Remove that cleanly undoes it. It is meant for offline single-player use on your own copy, and it never touches your translation projects or your original archives.

Cheat Mode in RuneTranslate gives RPG Maker games a hotkey overlay, F10 by default, with add 1000 gold, godmode, full heal, one-hit kill, no random encounters and walk through walls, plus give all items, max stats and level, and instant win battle. Variables and Switches tabs list every game variable and switch so you can search by name or id and set or toggle any of them live. For Ren'Py it enables the built-in developer console on Shift+O along with the developer menu, plus a panel that lists and edits the game's store variables while it runs. The same overlay works on both MV and MZ.

Cheat Mode in RuneTranslate is partly free. Seven cheats cost nothing: on RPG Maker, add 1000 gold, godmode, full heal, one-hit kill, no random encounters and walk through walls, and on Ren'Py, the developer console. Six more need Supporter or above — give all items, max stats and level, instant win battle, the RPG Maker Variables and Switches tabs, and the Ren'Py live variable editor. Free or paid, cheats affect only the copy of the game you inject them into.

A line left in Japanese after a RuneTranslate run almost always has one of four causes. It may never have been extracted, because it lives somewhere the adapter does not reach — text compiled into code, or baked into an image, which is what the Image Studio is for. It may be marked as excluded, shown as an opt-in row in red, because it looks like an identifier the game compares against rather than displays; tick it to translate anyway if you are sure. It may have failed, if the provider returned the source unchanged or dropped a control code, in which case the original is kept deliberately rather than shipping broken text. Or the engine may have reverted it on write-back to avoid a crash, which Wolf RPG does on lines with fragile control structures. The editor's filters show which of the four applies.

RuneTranslate is engine-aware, not content-aware, so a doujin or adult game translates exactly like any other title on the same engine. If it is built on RPG Maker, Ren'Py, Kirikiri, Wolf RPG, TyranoBuilder, Unity, Godot, NScripter, Artemis, YU-RIS, AliceSoft, LiveMaker, SRPG Studio, RPG Developer Bakin, Unreal, or a custom Electron shell, it is supported regardless of theme. That covers most of what is sold on DLsite, DMM and Itch. Choose your provider with that in mind: some hosted LLMs refuse or soften explicit lines, while the free machine-translation routes never refuse (they simply handle explicit slang and onomatopoeia poorly) and a local model through Ollama or LM Studio has no filter at all.

RuneTranslate is not limited to Japanese sources — you set the source language per project, so an English game can be translated into Spanish or a Chinese game into English using the same engines and the same editor. The adapters key on file formats, not on script. Two practical notes: a Latin-script source gives the extractor less to go on when telling display text apart from engine identifiers, so expect more opt-in rows to review, and a game already shipping official translations will have those left untouched rather than overwritten.

Boxes or blanks in a game translated with RuneTranslate mean the game's font has no glyph for your target language's characters, which is common with Cyrillic, Greek, Polish, Turkish, Vietnamese and CJK in a Japanese game. Some engines are handled automatically — Ren'Py exports bundle a suitable font and remap the game's fonts to it. Where they are not, replacing the font file in the exported build usually fixes it. Literal question marks are a different problem: that is an encoding limit in the engine's own string format, not a missing font, and it is worth reporting so we can look at the specific engine.

There are three broad approaches to getting Japanese out of a game, and RuneTranslate takes only one of them: it parses the game's own data files and produces a finished translated build you keep and can play any time with nothing else running. The alternatives hook the running game or read the screen, which translates live but saves nothing and needs a second program open every session. Which is better depends on your engine and your patience, and neither is universally right. There are detailed side-by-side pages for the main tools — Sugoi Toolkit, Translator++, mtool, Textractor, Translumo and XUnity.AutoTranslator — at runetranslate.com/compare.

RuneTranslate works offline in every part except the two that inherently need a network. Engine detection, extraction, the editor, the save editor, Cheat Mode, project storage and export all run locally. Translation needs a connection because the provider is a remote service — unless you use a local model through Ollama or LM Studio, in which case even that runs on your own hardware. The other exception is the first sign-in: a fresh install has to reach Patreon once. After that your signed token is verified on your own machine, so you can keep working with no connection at all while it is valid.