RuneTranslate now translates Artemis-engine visual novels

RuneTranslate now reads an engine that has, until now, been almost untouchable for fan translators: the Artemis Engine, the Lua-based visual-novel framework behind hundreds of Japanese releases. If you've ever opened an Artemis game folder, found a pile of .pfsarchives and nothing readable, and given up — that's the engine. RuneTranslate now detects it, opens those archives in pure TypeScript (encryption and all), reads the dialogue, character names, and choices out of its scripts, and exports a translated copy the game loads on its own. It's the latest engine RuneTranslate supports.

This is a brand-new engine and the honest part comes first: Artemis support is freshly built and has notyet been verified across many real games. So before anything else — if you point RuneTranslate at an Artemis game and it doesn't detect, doesn't open, or exports something the game won't load, please tell us. More on how, at the end.

What the Artemis Engine actually is

Artemis is a commercial Japanese visual-novel engine developed by iMel Inc. (the studio also known for Mikage). Where older engines like Kirikiri or NScripter expose a bespoke domain-specific scripting language, Artemis is built around Lua— its scenario scripts are essentially Lua data tables — which makes it flexible for developers but, in practice, a wall for anyone trying to translate a finished game from the outside. Around 730 releases on VNDB are built on it, so it is far from a niche curiosity; it is a whole back catalogue that machine-translation tools have historically skipped.

On disk, an Artemis game is a Windows .exe plus one or more .pfs resource archives that hold the scripts, art, and audio. The scripts inside are mostly .ast files (Lua-table scenario scripts) and .txt files (a simpler line-oriented format). RuneTranslate works directly from those archives and scripts, so it covers the game whether the studio shipped scenarios as .ast or .txt.

Why Artemis games have been so hard to translate

Compared to a source-driven engine like Ren'Py, Artemis hides its text behind several layers. A few specific ones have kept it out of reach for both hand-translators and naive tools:

• Everything lives inside .pfs archives.The scripts aren't loose on disk — they're packed into Artemis's own .pfs container format (you'll see PF8, PF6, and the legacy PF2 variants). Without a reader for that format, there is nothing to edit in the first place.
• The newest archives are encrypted. The current PF8 format doesn't just pack the files, it encryptstheir contents: each entry is XOR'd against a key derived from a SHA-1hash of the archive's own index. You can't simply carve the bytes out — you have to reproduce the engine's key derivation to get readable script back.
• The scripts are Lua data, not plain text. An .astscenario is a Lua table — dialogue, speaker names, and choices are nested fields inside structured tables, mixed with engine commands. There are two table layouts in the wild (an older v1 and a newer v2), and a translator has to understand both to pull the actual spoken lines out without mangling the structure around them.
• Inline engine commands are woven through the dialogue. Ruby/furigana annotations, name-plates, colour changes, and click-waits are written inline with the text. A find-and-replace that doesn't recognise them will translate the command tokens too, and the game breaks.

The net effect: even a translator who can read Japanese fluently first has to unpack a proprietary encrypted container, then hand-parse Lua tables, then carefully step around inline markup — before a single line gets translated. That's the work RuneTranslate now does for you.

What RuneTranslate does now

RuneTranslate treats Artemis as a first-class engine and handles the whole pipeline in pure TypeScript — no external tools, no Python sidecar, nothing to install:

• Reads .pfs archives directly. It opens the PF8, PF6, and legacy PF2 archive formats in-house, including PF8's SHA-1-keyed XOR encryption— reproducing the engine's key derivation so the script content comes out readable.
• Extracts dialogue, names, and choices. It parses both .ast(Lua-table) scenario scripts — the older v1 and newer v2 layouts — and .txt (line-oriented) scripts, and lists every translatable line in the editor: the spoken dialogue, the character names on the name-plates, and the branching choices.
• Preserves the engine commands.Inline markup — ruby/furigana, name-plates, colour, click-waits — and line breaks are masked behind numeric placeholders before anything reaches the translation provider, then restored exactly on the way out. The text gets translated; the engine instructions don't.
• Exports without repacking. Artemis prefers a loose script on disk over the same file packed inside a .pfs, so on export RuneTranslate writes the translated .ast / .txt scripts loose, at their original archive paths, next to the game. There is no repack— the game simply reads your translations instead of the packed originals. (It's the same loose-file override approach as our Kirikiri patch flow.)

Japanese → English is the sweet spot, but you can target any of 30+ languages— Spanish, French, German, Portuguese, Russian, Chinese, Italian, Turkish, Vietnamese, and more.

What you need

• RuneTranslate for Windows— free; every engine and provider is unlocked (the free tier is throttled on speed, not features).
• An Artemis game folder. This is the directory containing the game's .exe and its .pfs archives (the scripts and assets are packed inside those).
• 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. Artemis 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 Artemis game directory. Engine detection runs automatically — when it sees the engine's .pfs archives, it recognises the project as Artemis. Your original game folder is never modified.

Step 2: How the scripts get read

RuneTranslate opens the .pfs archives and pulls the scripts out for you, decrypting and parsing as it goes:

• Encrypted PF8 archives— decrypted in-house using the SHA-1-keyed XOR scheme, so you never run a separate unpacker.
• Unencrypted PF6 / legacy PF2 archives — read directly.
• .ast and .txt scripts— parsed for dialogue, names, and choices and listed in the editor, grouped by file.

Inline engine commands and line breaks are masked behind numeric placeholders before anything reaches the provider, then restored on the way out — so the ruby annotations, name-plates, and colour tags survive the round trip untouched.

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 and choices. 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: Export a ready-to-run copy

Click Export. RuneTranslate writes a translated copy of the game with the translated .ast / .txt scripts placed loose at their original paths, alongside the untouched .pfs archives. There's no repack— Artemis loads the loose scripts in preference to the packed originals, so the game just reads your translations. Run it, and it plays in your target language.

Known limitations

• Compiled .asb scripts aren't supported yet. Some Artemis games ship their scenarios as compiled binary AST (.asb) rather than the readable .ast / .txt form. Those aren't read yet — if a game is .asb-only, let us know and tell us the title.
• The loose-file override is the expected load path, and on most Artemis games it works because the engine prefers a loose script over the packed copy. On the rare title that doesn't honour that, the export may need adjusting — this is exactly the kind of real-game behaviour we're still confirming.
• Text baked into image art— a title screen or menu button drawn as a bitmap — is pixels, not script text, so the script extractor can't reach it. For that, see image-text translation.
• The exact archive and script variant can differ between releases. Always verify on your specific copy.

It's brand new — tell us what breaks

Worth repeating plainly: Artemis support is a fresh addition and has not yet been tested across many real games. The .pfs reader, the encryption, and the .ast / .txtparsers are built and unit-tested, but the engine has years of per-studio variation we haven't all seen. So if you point RuneTranslate at an Artemis game and it doesn't detect, doesn't open the archives, extracts nothing, or exports something the game won't load, please report it on our Discord — the game's name and how it's packaged (which .pfs variant, .ast vs .txt vs .asb) is exactly what helps us harden it fastest.

Download RuneTranslate, point it at that Artemis VN you've been wanting to read, and try it. For a look at how we handle another archive-based VN engine, read the Kirikiri walkthrough next.