How to translate NScripter / ONScripter visual novels

RuneTranslate reads one of the oldest engine families in Japanese visual novels: NScripter and its open-source twin ONScripter. These classic doujin VNs — the ones that ship as a folder of cryptic .datfiles and Shift-JIS scripts — have historically been the most painful to crack open by hand, and the ones machine-translation tools usually skip. RuneTranslate detects the engine, reads the script text, and can even translate the Japanese painted into the title screen and menu buttons.

This engine support is newly added and not yet real-game-verified, so if you point RuneTranslate at an NScripter / ONScripter game and it doesn't detect or load, please tell us — more on that at the end.

What NScripter and ONScripter actually are

NScripter is a closed-source Windows VN scripting engine by Naoki Takahashi, widely used in Japan from the early 2000s on. Its royalty-free license for personal and commercial use, built-in archive packer, and famously low-level scripting language made it a doujin-scene staple; studios like Nekonekosoft leaned on it almost exclusively.

ONScripteris a separate, open-source (GPL) reimplementation of the NScripter runtime by a programmer known as Ogapee. Built on SDL and drop-in compatible, it runs where NScripter can't — Linux, macOS, Android, and more — so the localization community adopted it (and forks like ONScripter-EN and Ponscripter for proportional Unicode fonts) as the de-facto runtime for shipping translated builds.

Short version: NScripter is the original closed Windows engine the games were authored on; ONScripter is the open, cross-platform runtime fan translators run their 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 with 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 hand-translators and naive MT tools alike:

• Shift-JIS / CP932 encoding. Legacy scripts are Shift-JIS (CP932). Decode it wrong and you get mojibake; re-encode it carelessly and some older runtimes corrupt memory and crash. 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), every byte XOR'd against the constant 0x84. It isn't encryption — just a guard against accidental spoilers — but you still can't open it in a text editor. Plaintext games ship the script as 0.utf / 0.utf.txt (UTF-8) or 0.txt / 00.txt (Shift-JIS) instead.
• Text baked into image art.Title screens, menus, and buttons are frequently pre-rendered bitmaps, 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. That was safe when the engine only accepted two-byte Japanese, but a line beginning with a one-byte Latin letter looks exactly like a command and the engine tries to execute it. The community fix is a reserved text marker (the backtick ` in legacy ONScripter; ^in Ponscripter) that forces text mode — which a naive find-and-replace won't add.

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 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 when the original used it. It also inserts the one-byte text marker automatically so translated English isn't mis-read as a command. (A script that lives only inside an .nsa / .sararchive, with no loose copy, isn't read yet — see limitations.)
• The baked-in image text. The Japanese on title screens and menus is handled by image-text translation: box the words, recognize them, translate with your own provider, and re-bake the result so the game loads your translated art.

Japanese → English is the sweet spot— it's what this engine's fan-translation history is about — but you can target 30+ languages. On legacy Shift-JIS scripts a non-Latin target is limited by the fonts the engine can render.

What you need

• RuneTranslate for Windows— free, every engine and provider unlocked.
• An NScripter or ONScripter game folder — the directory with the game's .exe (or an ONScripter binary), its script (nscript.dat, or a loose 0.txt / 0.utf), and any .nsa / .sar archives.
• A target language — English, Spanish, French, German, Chinese, and 30+ more.
• One provider. Free Google Translate works out of the box; DeepL has a free tier; OpenAI, Anthropic, a local model, and any OpenAI-compatible API are bring-your-own-key. These games are dialogue-heavy, so an LLM or DeepL reads best.

Step 1: Open the game folder

Launch RuneTranslate, click New project, and point it at the game directory. Detection runs automatically: an nscript.dat / pscript.dat, or a plaintext 0.utf / 0.utf.txt, is enough on its own. A bare Shift-JIS 0.txt or a lone .nsaarchive is only recognised alongside a corroborating signal — an ONScripter binary, a game font, or an accompanying archive — to avoid false matches. 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 skip a separate nsdec step.
• Plaintext scripts — 0.utf / 0.utf.txt (UTF-8) or 0.txt / 00.txt (Shift-JIS), read directly.
• Archived images — pulled from the game's .nsa / .sararchives for the image-text step. (The script itself is read from the loose root files; 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 reaching the provider, then restored on the way out — and the one-byte text marker is applied where needed, so the engine won't mistake a translated line for a command.

Step 3: Translate

Pick a provider and run. An LLM (OpenAI / Anthropic) is best for character voice, DeepL is fast and clean for narration, and free Google Translateis fine for short menu strings. Glossary your cast up front so names render identically — see Glossary 101. When you're done, an optional pass with the AI refiner re-reads each line in context and tightens the stiff, literal phrasing MT 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, box each piece of Japanese, recognize it, translate it with the same provider, and on export RuneTranslate bakes the translation back in and writes it loose into the exported copy, so the engine loads your translated art over the archived original. (Your original folder stays untouched; SPB-compressed art and a few exotic image variants are still being hardened.) 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 used it, written as a loose script the engine loads over any archived copy, plus any translated images beside it. Run it and it plays in your target language, whether on the original NScripter runtime or on ONScripter / ONScripter-EN.

Known limitations

• The XOR-0x84 obfuscation is handled, but a game with genuine custom encryption may not open.
• A script packed only inside an .nsa / .sar archive, with no loose nscript.dat / 0.txtat the root, isn't extracted yet — most games ship it loose, but a few don't.
• Image-text translation reaches painted menus, titles, and buttons, but SPB-compressed art and heavily stylised logos may want a manual touch-up.
• The exact engine can vary by release — some titles associated with NScripter were re-engineered for specific Steam / console re-releases. Verify on your copy.

It's brand new — tell us what breaks

This engine is a fresh addition, not yet battle-tested. NScripter / ONScripter has decades of variants, forks, and per-studio quirks we haven't all seen. So if you point RuneTranslate at one 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) helps us harden it fastest.

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