Image-text translation: translate the words baked into menus, titles, and buttons

Some of a game's text isn't text at all — it's painted into the artwork. The title screen, the “New Game / Continue / Options” buttons, a HUD label, a stamp on a CG. A normal translation pass never touches those, because there's no string to extract: the words are pixels. So you finish a translation and the game still greets you in Japanese on the very first screen.

Image-text translationcloses that gap. You point at the words inside an image, RuneTranslate reads them, you translate them like any other line, and on export it bakes your translation back into the picture — under the original filename, so the game loads it with no extra steps. New in 0.24.2, it also cleans the text away properly: instead of stamping a colored rectangle over the art, it removes just the original lettering and rebuilds the artwork behind it.

How it works at a glance

It's a new Images tab in the project editor, right next to your normal text lines. The flow is deliberately hands-on, so you stay in control of exactly what gets translated:

• Pick an image.RuneTranslate surfaces likely candidates (menu / title / button art from the engine's UI folders), or you add any image yourself.
• Draw a boxaround a piece of text on the image — as many boxes as you need, one per word or phrase.
• Recognizeturns each box into editable text in the game's own language — fix any OCR slip right there.
• Translate it with the same engine you use everywhere else, then tweak the result.
• Export re-bakes the translated text into the image and keeps the original safe as bk_<name>.

Finding the images worth translating

You don't scroll a thousand sprites looking for words. The Images tab shows a candidate gallery— a quick local pass that surfaces the images most likely to be menu / title / button art (by where they live in the game and their size), and skips tiny icons and giant backgrounds. Nothing is uploaded to build that list; it's just reading your own files. If something isn't in the gallery, you can add any imageby hand. You eyeball which ones actually have text and open them — CG and personal art are never touched unless you choose to open them.

Draw a box, get the text

Click a candidate and it opens large on a canvas. Drag a box around a piece of text — the same marquee select used elsewhere in the app — and it becomes a numbered region with its own row beside the image. Most images have several text spots (New Game, Continue, Options, Load…), so you just draw a box for each and they stack up as a little list. Boxes are nudge-, resize-, and delete-able.

Hit Recognizeon a region and the crop is read back as editable text. It's recognized in the project's source language— not hard-coded to Japanese. If your project is Chinese, Korean, English, Russian, Arabic, or a European language, recognition uses the matching model automatically. If a box catches a border or sits between glyphs and comes back empty, you'll get a “no text detected — resize the box” nudge rather than silence. And the source field is always editable, so you can correct or just type the text yourself.

Translate it like any other line

Each region has a Translatebutton (and a per-image “translate all”), and it runs through the same translation you use for dialogue — your chosen provider and model, from DeepL and Google to OpenAI or Claude. The translated text lands in an editable field, so you can shorten it to fit a button or fix tone before it ever touches the image. It reads as one cohesive workflow next to your normal lines, not a bolt-on.

Clean backgrounds, not patches (the 0.24.2 upgrade)

This is the part that makes baked-in text actually look translated. The naive way to replace image text is to paint a filled rectangle over the old words and write the new ones on top. That looks fine on a flat button — and terrible on a title screen, where the text sits over a detailed illustration and the patch is an obvious block of the wrong color.

Instead, RuneTranslate does text-stroke inpainting: it detects the actual letter strokes, removes onlythose pixels, and reconstructs the artwork that was behind them — the night sky, the character, the gradient — before drawing your translation on top with a clean outline. On a flat button you get a seamless swap; on a busy title CG you get the lettering gone and the art rebuilt, which is as close to “it was never in Japanese” as a re-bake gets. (Heavily textured photographic backgrounds are the hard case and can leave faint traces; flat and gently-shaded art come out cleanest.)

Where it runs — and what stays private

Recognition and background cleanup run on RuneTranslate's own server— a self-hosted recognizer, no third-party OCR cloud. Your app only ever sends the small crop you boxed (plus a little margin for the cleanup to rebuild from), never your whole game. Those crop bytes are read in memory and discarded immediately— nothing is stored, and the request is tagged by engine only, never by game or project name. The actual translation still goes through whatever provider you chose, exactly as it does for dialogue.

Free vs Supporter

The server-side recognition and the clean inpaint are a Supporterfeature ($3/mo) — that's the part that uses our hardware, the same paid-to-host model as collaborative projects and cloud translation memory.

Free users still get a real workflow, fully on their own machine: draw boxes, type the source text yourself, translate it with your own provider, and export — the re-bake just uses a simple flat-fill erase instead of the server inpaint. So the auto-recognition and the clean reconstructed backgrounds are the Supporter upgrade; everything else works for everyone, and a free export never touches our server.

How the re-bake and backup work

Re-baking happens at export, into the exported copy of the game — never your original files. For each image with a translated region, RuneTranslate writes the new image over the original filename (so the engine loads it with zero config) and copies the untouched original next to it as bk_<name>. The backup is written once, so re-exporting never clobbers the true original — you can always revert by deleting the baked file and dropping the bk_ copy back. PNGs stay lossless; JPEGs are re-encoded at high quality and keep their format.

Scope & limits

• Loose-image engines first.It targets games whose images are loose files — RPG Maker MV / MZ to start (the img/folders), with more engines following. Images sealed inside archives (some Kirikiri / Unity / Wolf packs) aren't reached yet.
• Flat and illustrated UI shine; dense photos are the hard case. Buttons, titles, and stylized logos clean up beautifully; text sitting on a busy photographic texture can leave faint traces.
• You're always in the loop.Recognition and translation are both editable, and nothing is auto-applied to an image until you export — so a wrong read or an awkward phrasing never ships by surprise.

Do it in six steps

1. Open your project and switch to the Images tab.
2. Pick a title / menu image from the gallery (or add your own).
3. Draw a box around each piece of text on it.
4. Recognize each box, then fix any OCR slip in the source field.
5. Translate with your provider and tidy the result.
6. Export. Your translated images land under the original names (with bk_ backups) and the game loads them as-is.

Wrapping up

A translation that stops at the dialogue still feels half-done the moment the title screen loads in Japanese. Image-text translation finishes the job — the menus, the buttons, the title art — and the new inpaint makes them look like they were drawn that way, not patched over.

Download RuneTranslate, open the Images tab, and translate the words your extractor could never reach.