RuneTranslate now translates Godot games

RuneTranslate now translates games built on Godot— the free, open-source engine that has quietly become one of the most popular ways to ship an indie or doujin game. Godot has historically been one of the hardest engines to translate from the outside, because a released Godot game is a sealed box: everything lives in a single .pck archive (frequently glued onto the end of the .exe itself), the scripts are compiled to GDScript bytecode, and the scenes are saved as binary. RuneTranslate opens that box, reads the text, and packs your translation back in.

This is a newly added engine, so before anything else: if you point RuneTranslate at a Godot game and it doesn't detect, doesn't open, or the exported copy won't run, please tell us. More on that at the end.

What Godot actually is

Godotis a free, MIT-licensed, open-source game engine (first public release 2014) that exploded in popularity over the last few years — it's now a mainstream choice for 2D and 3D indie games, and a growing slice of Japanese doujin titles ship on it. Games are usually written in GDScript, Godot's own Python-like language, and laid out as scenes— trees of nodes (a label here, a button there, a dialogue box) saved as resources.

When a Godot game is exported for release, all of that — scripts, scenes, images, audio — is bundled into one .pck pack file. The pack sits either next to the executable or, very commonly, appended directly onto the end of the .exe, so the folder looks like nothing but a single game executable. That packaging is exactly what makes Godot games look impenetrable.

Why Godot games have been hard to translate

Unlike a script-driven engine like Ren'Py, a shipped Godot game exposes almost nothing in plain text:

• Everything is inside the .pck.There are no loose script or text files to edit — and when the pack is embedded in the .exe there isn't even a visible .pck to point a tool at.
• The scripts are compiled. GDScript is shipped as compiled bytecode (.gdc) — and in modern Godot 4 that bytecode is additionally compressed — so the dialogue baked into the code isn't something you can grep for or open in a text editor.
• The scenes are binary.The UI labels and menu text live in scene files saved in Godot's binary resource format (.scn), not the human-readable .tscn you see in the editor.
• Most games don't use a translation file. Godot has a first-class localization system (CSV / .po → .translation), but plenty of games — especially smaller doujin titles — never use it and simply hardcode the Japanese into the scripts and scenes. So there's no tidy string table to translate.

What RuneTranslate does now

RuneTranslate treats Godot as a first-class engine and reconstructs the readable project for you. Under the hood it bundles a copy of GDRE Tools (the open-source Godot reverse-engineering toolkit) and uses it to:

• Unpack the .pck — standalone, data.pck, or the pack embedded at the end of the .exe (RuneTranslate detects the embedded-pack signature automatically).
• Decompile the compiled GDScript (.gdc → .gd) so the dialogue and narration in the code become readable again.
• Convert the binary scenes (.scn → .tscn) so the labels and UI text on them can be pulled out.

It then scans the recovered project and lists every translatable string — script dialogue and scene/UI text — grouped by file in the editor, with engine markup masked behind placeholders so the provider never mangles it. On export it splices your translations back into the recovered source and re-packs a runnable copy of the game (more on exactly how below).

What you need

• RuneTranslate for Windows— free, every engine and provider unlocked.
• A Godot game folder — typically just the game's .exe (with the pack embedded), or an .exe plus a .pck / data.pck beside it. Godot 3.x and 4.x are both supported.
• 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. Godot games are usually dialogue-heavy, so an LLM (OpenAI / Anthropic) or DeepL reads best for story text.

Step 1: Open the game folder

Launch RuneTranslate, click New project, and point it at the Godot game directory — the folder with the game's .exe (and a .pck, if it ships separately). Engine detection runs automatically: it recognises the embedded-pack signature at the end of the executable, a loose .pck, or a Godot project. Your original files are never modified.

Step 2: Unpack and recover the project

RuneTranslate runs its bundled GDRE Tools sidecar to unpack the pack, decompile the compiled GDScript, and convert the binary scenes into readable source. It then scans that recovered project and lists every translatable line — dialogue and narration from the scripts, plus labels and UI text from the scenes — grouped by file. Asset paths, node names, and other code identifiers are filtered out so you only translate the strings a player actually sees.

Step 3: Translate

Pick a provider and run. For a story-driven game an LLM (OpenAI / Anthropic) is best for character voice, DeepL is fast and clean for narration, and free Google Translateis fine for short UI strings. Godot games often keep their dialogue as long arrays of lines inside a single script — a "story database" — so the same character or place name appears hundreds of times. Glossary your cast and key terms up front so they render identically everywhere; see Glossary 101. An optional pass with the AI refiner tightens the stiff phrasing machine translation tends to leave behind.

Step 4: Export a translated build

Click Export. Because the original scripts are compiled bytecode, RuneTranslate uses a source-override approach: it writes your translations into the recovered .gd / .tscn source, drops the compiled .gdc / binary .scn from the pack so the engine falls back to the loose translated source, and re-packs a fresh .pck — re-embedding it into a copy of the .exe when the pack was embedded. Your original game stays untouched; you get a separate, runnable, translated copy.

Step 5: Verify the copy runs

The exported build relies on the Godot runtime compiling the loose translated script source at load time, so — as with any new engine — launch the exported game once and confirm the dialogue and menus show your language before you share it. If a script doesn't load, that's exactly the kind of report that helps us harden it (see below).

Known limitations

• Newly added + best-effort. Verify the exported game launches and reads correctly before redistributing.
• Encrypted packs. Some games ship a .pck encrypted with a key baked into the binary; those aren't opened yet.
• C# / .NET (Mono) games.RuneTranslate focuses on GDScript; text compiled into a C# Godot game's logic is out of scope.
• Text painted into images.A title or logo rendered as artwork is pixels, not strings — that's a job for image-text translation, not script extraction.
• Non-Latin target languages depend on the game shipping a font that can actually render them.

It's brand new — tell us what breaks

Godot support is a fresh addition. Godot spans many engine versions and packaging styles, and we haven't seen them all. So if you point RuneTranslate at a Godot game and it doesn't detect, doesn't unpack, or exports something that won't launch, please report it — the game's name, its Godot version, and how it's packaged (embedded pack vs a loose .pck) is exactly what helps us harden it fastest.

Download RuneTranslate, point it at that Godot game you've been meaning to read, and try it. For another modern engine, see the Unity walkthrough next.