RuneTranslate now translates NScripter / ONScripter visual novels

RuneTranslate now speaks one of the oldest dialects in Japanese visual novels: NScripter and its open-source twin ONScripter. If you've ever wanted to translate a classic doujin VN — the kind that ships as a folder of cryptic .datfiles and Shift-JIS scripts — this is the engine family that has historically been the most painful to crack open by hand, and the one machine-translation tools usually skip. RuneTranslate now detects it, reads the script text, and even translates the Japanese painted into the title screen and menu buttons.

This is a newly added engine, so before anything else: if you point RuneTranslate at an NScripter / ONScripter game and it doesn't load or detect, please tell us. More on that at the end.

What NScripter and ONScripter actually are

NScripter is a Windows visual-novel scripting engine written by Naoki Takahashi, developed from roughly 1999 to 2018 (its final point release, 3.10.102, is dated February 2018, though meaningful feature work slowed dramatically after the early 2000s). It was never open source, but its license allowed royalty-free personal andcommercial use, and that — combined with a built-in archive packer and a powerful, famously low-level scripting language — made it one of the most widely used VN engines in Japan during its peak. Commercial studios like Nekonekosoft leaned on it almost exclusively, and the doujin scene adored it.

ONScripteris a separate, independent project: an open-source (GPL) reimplementation of the NScripter runtime, started in 2002 by a programmer known as Ogapee. It's built on SDL and aims to be drop-in compatible with NScripter games, but it runs where NScripter never could — Linux, macOS, *BSD, Android, and more. Because it's open and modifiable, the English-speaking localization community adopted it as the de-facto engine for shippingtranslated NScripter games, and a lineage of forks added Western-language support: Chendo's 2004 1-byte character patch, Haeleth's ONScripter-EN (ONS-EN) and Ponscripterfor proportional Unicode fonts, Uncle Mion's later maintenance, and insani's reactivated branch for modern builds.

So the short version: NScripter is the original closed Windows engine the games were authored on; ONScripter (and ONS-EN / Ponscripter) is the open, cross-platform runtime fan translators actually run their translated builds on. RuneTranslate works from the game's scripts and assets, so it covers titles in either camp.

Why these games have been so hard to translate

Compared to a modern engine like Ren'Py or Kirikiri, NScripter / ONScripter is a minefield of engine-era quirks. Four in particular have made it a wall for both hand-translators and naive machine-translation tools:

• Shift-JIS / CP932 encoding.Legacy scripts and data files are encoded in Shift-JIS (Microsoft's variant, CP932), the old Japanese double-byte encoding. Decode it wrong and you get mojibake; re-encode it carelessly and some older runtimes corrupt memory and crash. A translator has to detect and round-trip CP932 correctly — modern native scripts can be UTF-8, but the back catalogue is CP932.
• The XOR-0x84 obfuscated nscript.dat. The compiled script usually lives in nscript.dat (or pscript.datin Ponscripter), where every byte is XOR'd against the constant byte 0x84. It isn't encryption — the docs are explicit that it provides no security, just a guard against accidental spoilers — but you can't just open it in a text editor either. You have to un-XOR it, edit the Shift-JIS text inside, and re-XOR it on the way back out. (Games may alternatively ship plaintext 0.txt / .u scripts, or scripts inside .nsa / .sar archives.)
• Text baked into image art.Title screens, menus, and buttons are frequently pre-rendered bitmaps — NScripter even requires some art to be BMP — so the Japanese on them is pixels, not strings. A string extractor can't touch them.
• The subtle one: Latin-leading lines get re-parsed as commands. NScripter's parser starts every line in command mode. Historically that was safe because the engine only accepted two-byte Japanese, so any displayed line was unambiguously text. The moment you introduce one-byte English, a line that begins with a Latin letter looks exactly like a script command and the engine tries to executeit — breaking the game. The community fix is a reserved text marker (the backtick ` in legacy ONScripter; Ponscripter later moved to ^) that forces text mode for the rest of the line. A naive find-and-replace of Japanese with English produces lines the engine mis-reads as commands.

That last trap is exactly why early fan projects (Gin'iro, Mizuiro) resorted to two-byte Latin characters — vanilla NScripter wouldn't take one-byte input at all — and why a generic translator that doesn't understand the engine just bricks the script.

What RuneTranslate does now

RuneTranslate treats NScripter / ONScripter as a first-class engine and handles both halves of the problem:

• The script text.It reads the game's script — a loose plaintext file (0.txt and friends) or an nscript.dat obfuscated with XOR 0x84— decodes the Shift-JIS / CP932 dialogue, lists every translatable line in the editor, and on export writes the script back in the form the engine expects, re-applying the XOR 0x84 obfuscation when the original .datused it. It also applies the one-byte text marker automatically so your translated English doesn't get mis-read as a command. (A script that lives only inside an .nsa / .sararchive, with no loose copy at the game root, isn't read yet — see the limitations below.)
• The baked-in image text.The Japanese on title screens, menus, and buttons — pixels, not strings — is handled by RuneTranslate's image-text translation: box the words, recognize them, translate them with your own provider, and re-bake the result so the game loads your translated art instead.

Japanese → English is the sweet spot— it's what this engine's entire fan-translation history has been about, and on legacy Shift-JIS scripts a non-Latin target language is limited by what the engine's fonts can render — but you can target any of 30+ languages.

What you need

• RuneTranslate for Windows— free, every engine and provider unlocked.
• An NScripter or ONScripter game folder. This is the directory containing the game's .exe(or an ONScripter binary) plus its script and assets — typically nscript.dat, a loose 0.txt, and one or more .nsa / .sar archives.
• 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. These games 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 NScripter / ONScripter game directory. Engine detection runs automatically — when it sees an nscript.dat, a loose 0.txt script, or the engine's .nsa archives, it recognises the project as NScripter / ONScripter. Your original game folder is never modified.

Step 2: How the script gets read

RuneTranslate reads the script the game ships loose at its root and decodes it for you:

• Obfuscated nscript.dat— un-XOR'd against 0x84 and read as Shift-JIS, so you never run a separate nsdec step.
• Loose plaintext scripts (0.txtand friends) — read directly.
• Archived images — pulled from the game's .nsa / .sararchives for the image-text step below. (The script itself is read from the loose root files above; a script packed only inside an archive isn't read yet.)

Dialogue and displayed text are listed in the editor, grouped by file. Engine markup and command tokens are masked behind numeric placeholders before anything reaches the provider, then restored on the way out — and the one-byte text marker is applied where it's needed, so the engine doesn't mistake your translated English line for a command.

Step 3: Translate

Pick a provider and run. For a visual novel, an LLM (OpenAI / Anthropic) is best for character voice and tone, DeepL is fast and clean for narration, and free Google Translateis fine for short menu strings. Glossary your cast and recurring terms up front so names render identically across the whole game — see Glossary 101. When you're done, an optional pass with the AI refiner re-reads each line in context and tightens up the stiff, literal phrasing machine translation tends to leave behind.

Step 4: Translate the text in the images

Because so much NScripter UI is pre-rendered art, this step matters more here than on most engines. Open a title or menu image in the project, drag a box around each piece of Japanese, recognize it, translate it with the same provider you use for dialogue, and on export RuneTranslate bakes the translation back into the image and writes it loose into the exported copy, so the engine loads your translated art over the archived original. (Your original game folder stays untouched; SPB-compressed art and a few exotic image variants are still being hardened — report anything that looks off.) Full walkthrough: image-text translation.

Step 5: Export a ready-to-run copy

Click Export. RuneTranslate writes a translated copy of the game — the script re-encoded to Shift-JIS / CP932 and re-obfuscated with XOR 0x84 if the original .dat used it, written as a loose script the engine loads over any archived copy, plus any translated images written loose alongside it. Run the game and it plays in your target language, whether you launch it on the original NScripter runtime or on ONScripter / ONScripter-EN.

Known limitations

• The XOR-0x84 obfuscation is handled, but a game protected with genuine, custom encryption (rather than the standard obfuscation) may not open.
• A script packed only inside an .nsa / .sar archive, with no loose nscript.dat / 0.txtat the game root, isn't extracted yet — most games ship the script loose, but a few don't.
• Image-text translation reaches the Japanese painted into menus, titles, and buttons, but SPB-compressed art and heavily stylised logo art may still want a manual touch-up.
• The exact engine can vary by release — some titles commonly associated with NScripter (for example, parts of the When They Cry lineage) were built on NScripter and are commonly run via ONScripter, but specific Steam / console re-releases were sometimes re-engineered. Always verify on your specific copy.

It's brand new — tell us what breaks

This engine is a fresh addition, not a battle-tested one. NScripter / ONScripter has decades of variants, forks, and per-studio quirks, and we haven't seen them all. So if you point RuneTranslate at an NScripter or ONScripter game and it doesn't detect, doesn't load, or exports something the runtime won't open, please report it — the game's name and how it's packaged (loose 0.txt, nscript.dat, .nsa archives) is exactly what helps us harden it fastest.

Download RuneTranslate, point it at that classic VN you've been meaning to read, and try it. For a look at a more modern VN engine, read the Ren'Py walkthrough next.