How to translate Artemis-engine visual novels to English

To translate Artemis Engine games, RuneTranslate reads a framework that has long been almost untouchable for fan translators: the Artemis Engine, the Lua-based visual-novel framework behind hundreds of Japanese releases. Open an Artemis game folder and you'll find a pile of .pfs archives and nothing readable. RuneTranslate detects the engine, 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.

Artemis has years of per-studio variation, so if you point RuneTranslate at an Artemis game and it doesn't detect, doesn't open, or exports something the game won't load, 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 the readable .ast(Lua-table) scenario scripts — both the older v1 and newer v2 layouts — the .txt (line-oriented) scripts, AND the compiled binary ASB scenarios that many games actually ship (detected by signature, even when renamed to a custom extension like .iet), 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 an override patch. Artemis reads its scripts from the mounted .pfs archives, so on export RuneTranslate writes a translated override-patch archive — a root.pfs.NNN file, one per source .pfs— into a copy of the game. Artemis mounts the highest-numbered archive last and reads from it, so the patch shadows the packed originals without rebuilding the game's own archives. (The translated scripts are also written loose as a harmless extra.) It's the same override-patch idea 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 a root.pfs.NNNoverride-patch archive — one per source .pfs— that Artemis mounts last and reads in preference to the packed originals. (The translated scripts are also dropped loose as a harmless extra.) Run it, and the game plays in your target language.

Known limitations

• Compiled .asb scenarios are read— many Artemis games ship the scenario as compiled binary AST (the form that begins with the ASB marker) instead of the readable .ast / .txt, and several rename the extension (one game we tested uses .iet). RuneTranslate detects that by signature, not extension, and translates it in place. Where a game stores speaker namesin graphics or as command names rather than as in-script text, those names come from the image-text flow, not the script — if a name stays Japanese, that is usually why.
• The override patch is the load path. The translated root.pfs.NNNarchive is what the game actually reads. On the rare title that mounts archives differently, the export may need adjusting — exactly the kind of real-game behaviour we harden as reports come in.
• 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.

Hit a snag? Tell us

The .pfs reader, the encryption, and the .ast / .txt / .asbparsers are built and unit-tested, but Artemis has years of per-studio variation. If a game doesn't detect, doesn't open the archives, extracts nothing, or exports something it won't load, 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.