dreamsavior.net

What is Translator++?

Translator++ is a computer-aided translation (CAT) tool aimed specifically at game localization. Rather than translating for you, it gives a human translator a GUI workspace for extracting, editing, and re-injecting text from game files — the page calls it a CAHT (computer-aided human translation) program and lists support for engines including RPG Maker, Wolf RPG Editor, Ren'Py, KiriKiri, Unity, and Unreal.

What it actually does

• Handles engine-specific file formats. Game text usually lives in proprietary scripts, archives, or asset bundles. Translator++ parses those formats so you can work on the strings as text, then write them back into the game.
• Provides a translation workspace. The GUI and supporting tools are meant to speed up repetitive work: browsing extracted lines, reusing translations, and managing large string sets.
• Serves both professionals and hobbyists. The page explicitly frames it as useful whether you translate full-time or as a hobby — which matches the reality that fan translation and small commercial localization use many of the same engines.
• Extends beyond dialogue. A recent post describes an Image Translator for words baked into game art, such as title screens, menu buttons, HUD elements, and illustrated signs — text that never appears in a script file.
• Pairs with a separate server project. Dreamsavior also develops YOJET (Your Own Japanese-English Translator), which lets you run a machine-translation service or API offline on your own machine or local intranet instead of relying on a hosted service.

Who it suits, and the trade-off

If you are localizing a Japanese-origin RPG Maker, Wolf RPG, or visual-novel-engine game and want to keep control over the final wording, this is the kind of tool that replaces manual hex-editing and spreadsheet juggling. The trade-off is that it is an aid, not automation: quality still depends on the translator, and engine support varies, so a parser for one engine may be more mature than another. Check that your specific engine and game version are covered before committing to a workflow.

Practical next step

Identify your game's engine first, then look for the matching parser or workflow notes on the site — for example, the Unity Parser and UnrealParser posts describe engine detection and injection. If you want machine translation as a first pass, evaluate YOJET separately from Translator++, since they solve different halves of the problem. See Dreamsavior for the current project list and version changelogs.

How do I choose between Translator++ and YOJET for my game translation needs?

Translator++ and YOJET are two different halves of the same workflow, not direct competitors. Translator++ is the editing environment where you extract, translate and reinsert game text; YOJET is a local translation server that supplies machine-translation output. Most people who do serious game localization end up wanting both, but you only need to start with one.

What each one actually does

Translator++ — a CAT (computer-aided translation) tool aimed at game engines. Based on the site's own description, it handles RPG Maker, Wolf RPG Editor, RenPy, KiriKiri "and many more," works through a GUI, and is positioned for both full-time professionals and hobbyists. The project updates frequently, with changelogs covering engine parsers (Unity, Unreal), autosave, and an image translator for text baked into art such as title screens, menus and HUD elements.

YOJET (Your Own Japanese-English Translator) — a server you run yourself, so that a Google-Translate-style or DeepL-style service works offline on your own machine or across your local intranet.

Choosing by situation

The practical trade-off: Translator++ gives you control over structure and context — speaker, scene, UI element — which is exactly what machine output tends to lose. YOJET gives you volume and independence from paid cloud APIs, but raw machine output still needs a human pass for tone, honorifics and terminology consistency.

A concrete path

If you are localizing a RenPy or RPG Maker game and have never done it before, install Translator++ first: extract the script, translate in its grid, and reinsert. Add YOJET later, once you feel the bottleneck is typing rather than judgment. In Translator++ you can pre-fill lines with machine output and then edit them, which is the standard hybrid approach.

For engine-specific guidance and file-format quirks, community documentation is often more current than any single tool's own pages — see ScummVM for adventure-game extraction context, or engine communities such as RPG Maker Web for RPG Maker project structures.

Can I use Translator++ for Unity games?

Yes. Translator++ lists Unity among the game engines it supports, and the site's own update notes describe Unity-related work: a UnityTrans component (noted as updated to ver. 0.14 in the 8.9.30 changelog) and a post titled "Proper localization of Unity Games with the Unity Parser" that refers to "burning in" translations for Unity games. Those are the developer's own observations about their tool, not independent testing.

What that means in practice

Translator++ is described as CAT/CAHT software for games — a GUI environment where you extract text, translate it, and reinject it — rather than a service that translates Unity projects automatically. The Unity Parser is the part that handles engine-specific extraction and injection, so a Unity workflow depends on it recognizing your project's text storage.

Practical implications for a Unity project:

• Text stored in standard Unity assets (dialogue, UI labels, item descriptions) is the typical target for a parser-based workflow.
• Text baked into images — title screens, menu buttons, HUD elements, illustrated signs — is a separate problem. The site's Image Translator post treats these as their own task, so plan for them separately rather than assuming one pass covers everything.
• Text generated at runtime or pulled from a server may fall outside what any parser can extract cleanly, since there's no asset to rewrite.

A sensible first step

Test on a small slice before committing: pick one scene or one UI screen, run the Unity Parser extraction, and check whether the strings you expect appear in the translation grid. If key text is missing, the issue is extraction coverage, not translation quality — and that's worth discovering before you build a full glossary and workflow around it.

For context on how this compares with other tools in the same space, Dreamsavior is the developer's own site, while general-purpose CAT tools such as OmegaT are aimed at document formats rather than game engines, and GitHub hosts community extractors for individual Unity titles. Which one fits depends on whether your bottleneck is engine-level extraction or the translation editing itself.

How do I install and set up the YOJET offline translation server?

The YOJET offline translation server is a separate project from the main Translator++ tool: its stated purpose is to let you run a Japanese–English translation service on your own machine or local intranet, in the style of Google Translate or a DeepL-style API, without sending text to a third party. Installation and setup instructions are not published on the Dreamsavior home page, so the reliable path is to go to the YOJET project page itself and follow the official documentation there rather than improvising from the homepage summary.

What to figure out before you start

Decide which of two deployment shapes you actually need, because they lead to different setup work:

A sensible order of operations

1. Read the YOJET page at Dreamsavior for the current install method, supported platforms and any model files you must download separately.
2. Check the hardware requirements against your machine before downloading anything large; offline translation models are the bulky part, not the server code.
3. Install, start the server, and confirm it responds locally before exposing it to anything else.
4. Only then point Translator++ (or another client) at the local address, and test with a short Japanese string whose translation you can judge yourself.

Where YOJET fits in a real workflow

A freelance translator working on a Japanese RPG Maker or Ren'Py title might use Translator++ as the editing environment and YOJET as the engine behind it, so that draft translations are produced locally and then revised by hand in the CAT interface. The trade-off is straightforward: you gain privacy, offline operation and no per-character API costs, but you take on installation, model storage and the responsibility for keeping the server running. If your priority is maximum translation quality on a small volume of text, a hosted service may still be the better fit; YOJET's case is volume, confidentiality and independence from an internet connection.

Next step: open the YOJET section linked from the site's Current Projects area and follow its own setup notes, since version-specific steps change more often than the homepage text does.

Does Translator++ support translating text embedded in game images?

Yes. Translator++ includes an Image Translator feature for text that appears inside game art rather than in dialogue or script files, and Dreamsavior describes it as covering elements such as title screens, menu buttons, HUD elements and illustrated signs.

What that means in practice

A typical game localizer working on, say, a Ren'Py or RPG Maker title will extract dialogue strings into Translator++ and translate them there. But a menu button that reads "Start" or a signpost painted into a background image is not a string — it is pixels. Text embedded in art normally has to be edited in an image editor, then re-imported. The Image Translator is aimed at that second category, so you are not switching between two unrelated workflows for the same game.

Where it fits and where it does not

• Good fit: short, high-visibility text — buttons, HUD labels, logos, signage, title art.
• Weaker fit: long paragraphs baked into images, or stylized lettering where the replacement font has to match the original closely. Those still tend to need manual retouching.
• Not the same thing as machine translation: the page frames Translator++ as a CAT/CAHT tool, meaning it assists a human translator rather than replacing one. Quality still depends on the person doing the work.

A sensible next step

Before committing to a workflow, take one representative image from your project — ideally a menu screen with several labels — and test how cleanly the text can be replaced and repositioned. If the result holds up, the same approach will usually scale to the rest of the UI art. For background reading on the tool's wider engine support, the project's own site is Dreamsavior, and general game-localization practice is covered at IGDA and Localization Industry Standards Association.

How do I update Translator++ and what changes in the latest version?

Updating Translator++ is handled through the application itself rather than a manual download-and-replace routine. The site's own update posts show the pattern: a new build number appears with a short changelog listing fixes and features, and the release notes for Ver. 8.9.30 include an "Autosave update," a UnityTrans version bump, and faster material copying during the injection process. Earlier entries in the same series cover a grid toolbar overflow fix (Ver. 8.9.23) and an UnrealParser update that recognizes the Unreal engine (Ver. 8.9.16). So the practical expectation is that each update is incremental: a handful of parser improvements, UI fixes, and workflow speed-ups rather than a redesigned program.

For the actual mechanics, use the update path built into the tool rather than hunting for a separate installer. Check the version number in the about screen or title bar, compare it against the newest changelog post on Dreamsavior, and let the app's own updater fetch the build. If you are on a version several releases behind, updating straight to the newest one is normally fine because the changelogs describe cumulative fixes, not breaking migrations.

A concrete scenario: you are mid-project on a RenPy or RPG Maker game, Ver. 8.9.16 is installed, and you keep hitting a toolbar glitch. Updating to 8.9.30 gets you the overflow-menu fix plus the autosave change. Before updating, duplicate your project folder and export or note your translation memory, since autosave behaviour changing is exactly the kind of thing you want a backup for. After updating, reopen the project and run one injection pass on a small test file to confirm the faster material copy behaves as expected on your engine.

Decision criterion for timing: update immediately if the changelog names your engine or the bug you are hitting; otherwise finish your current pass and update between projects, because parser changes can alter how strings are extracted and re-injected.