The AI translation refiner — a second-pass proofread in context

Machine translation commits to the first plausible reading of every line. On an easy line that's fine. On a hard one — a dropped subject, an idiom, a pun, a line whose meaning hangs on the one before it — that first guess comes out stiff, literal, or just wrong, and you usually don't notice until you're reading it in-game hours later.

The AI translation refiner is a second pass that catches those. After your translation run finishes, an LLM re-reads each translated line next to the original Japanese and the surrounding lines, then rewrites it — fixing mistranslations, smoothing literal phrasing, matching tone, keeping terminology consistent within a scene. It is a separate, optional pass, not part of the translation run, and it's free on every tier.

What the AI translation refiner does

It is not a re-translation from scratch. For each line, the refiner is handed three things:

• The source— the original Japanese, as the reference for what the line is supposed to mean.
• The current translation— the first pass's output, which is what the refiner improves.
• The surrounding lines— the rest of the batch. Because lines are processed in extraction order, a batch is a contiguous run of text (usually one scene or file), so the model gets a couple dozen neighbouring lines of context for free.

That context is the whole point. With it, the refiner resolves things a line-at-a-time provider can't: dropped subjects (Japanese omits who's acting; the neighbours often reveal it), ambiguous references (what それ points at, question vs. exclamation), tone and register (a casual line rendered as stiff formal English), literal idioms and onomatopoeia, and terminology drift within a scene.

It's a separate pass — you trigger it

The refiner does not run during translation, and there is no prompt when a run starts. Translation runs alone and fast, so you can export and start playing right away; refining happens afterward, on demand. First turn the feature on in Settings → Translation(it's off by default). Then there are two ways to run it:

• The Refine button.A toolbar button in the editor. Click it, a small chooser opens — pick any configured LLM provider and type the model — and it refines every translated-but-unrefined line in the project.
• Always refine.Tick "Always refine with this model" in that chooser and the refine pass starts silently after each translate run, using your remembered model, no dialog. Turn it off any time in Settings.

It's best-effort. The line was already translated before the refiner touched it, so if a refine call fails or you cancel, the first-pass translation is simply kept — a line is never lost to a refine hiccup. A dedicated refiner progress bar and a "Refined Translation" column track what changed, and the run summary reports how many lines improved. (Re-translating a refined line discards its refinement, so RuneTranslate asks before pulling refined lines into a new translate run.)

Pick any LLM, type the model

Refining needs an instructablemodel, so it runs on an LLM provider: OpenAI, Anthropic, DeepSeek, an OpenAI-compatible endpoint (OpenRouter, NanoGPT, and friends), or a local model via Ollama / LM Studio. You pick the provider and type the exact model name — gpt-4o, a claude-model, a local model id, whatever you've got a key for. The fast statistical providers (Google, DeepL) are great for the firstpass but can't refine — they don't take instructions.

The cost-smart combo: cheap first pass, smart refine

The refiner is at its best as the second half of a two-provider strategy. Run the first pass on free Google or DeepL, then refine with Claude, GPT-4o, or DeepSeek. You end up with LLM-quality output but pay for only one LLM pass — the free pass did the bulk lifting and the LLM just proofreads on top. Refining with the sameLLM you translated with helps too (the refine pass has full-batch context and an explicit "improve this" instruction the first pass lacked), but it roughly doubles your token spend, so save that for projects where every line matters. Either way, a glossary keeps names consistent across both passes.

It's free for everyone

Translation memory, provider routing, and the glossary are Supporter features. The refiner is not. It runs entirely on your own API key — or your own local model — so it costs us nothing to offer, and every tier gets it, free included. The only thing you pay is your provider's tokens.

Customize the refiner prompt

The refiner has its own prompt, separate from the translation prompt, in Settings → Translation. The default already tells the model to improve naturalness and accuracy, preserve every placeholder and tag, keep established terminology, and never output Japanese. Override it to enforce house style — a register, how to handle honorifics, a content rating, a target audience.

Only the current translation is masked and restored, so your engine tags (RPG Maker control codes, KAG tags, Ren’Py interpolations) and any locked glossary terms survive the refine round-trip untouched. The model just sees the same opaque [[T0]]-style placeholders the first pass did.

What it won't touch

• Lines you hand-edited.Once you edit a translation yourself, it's your wording — the refiner leaves it alone and only reworks freshly machine-translated lines (including ones served from your translation memory).
• Placeholders and engine tags.They're masked through the refine pass exactly as in normal translation, so control codes, ruby text, and interpolations come back intact.
• Failed lines.The refiner improves an existing translation; it isn't a standalone translator. A line that failed the first pass (e.g. a provider that returned the Japanese unchanged) isn't magically fixed — switch provider and re-run those.

How to use it

1. Translate as usual and pick your first-pass provider (free Google / DeepL is a great choice here).
2. Turn the refiner on in Settings → Translation (once), then click Refine in the editor, pick an LLM provider, and type the model. Tick always refine to auto-run it after every translate run.
3. Watch the refiner progress bar and the "Refined Translation" column; the run summary shows how many lines the refiner improved.
4. Want a specific style? Edit the refiner prompt in Settings → Translation and run Refine again.

Wrapping up

A first-pass machine translation gets you to "readable." The AI translation refiner is the cheapest way past it — a second model, reading every line in context against the original, fixing the things a myopic first pass gets wrong. Pair it with a cheap first-pass provider and a strong refine model and a glossary for names, and your output lands squarely in "ship as a fan translation with light hand-editing" territory.

Download RuneTranslateand try the refiner on a real project — it's free on every tier, on your own API key or local model.