GameTranslatorAI V2 – Progress Report #3

Development on GameTranslatorAI V2 is continuing, and this update brings two major improvements: smarter AI cost optimization and support for a completely new game engine.

The main focus has been reducing unnecessary API usage without sacrificing translation quality, while also expanding GameTranslatorAI beyond Ren'Py.

AI Cost Optimization

A new optimization layer has been added to make AI translation more efficient.

Instead of sending the same amount of information with every translation request, GameTranslatorAI can now build prompts dynamically based on what the current text actually needs.

This includes:

• Dynamic prompt generation
• Adaptive context usage
• Character Memory optimization
• Relationship context optimization
• Prompt compression
• Provider-aware prompt optimization
• Translation Memory based request skipping
• Token usage tracking
• Cost estimation and analytics
• API request savings tracking
• Cache-aware cost reporting

For example, narrator text doesn't need the same Character Memory information as character dialogue, and a simple UI string doesn't need the same amount of context as a story-heavy conversation.

The goal is simple:

Use fewer tokens when possible without reducing translation quality.

Translation Optimization Profiles

GameTranslatorAI now also supports different optimization profiles depending on what the user wants to prioritize.

Economy

Focuses on reducing API usage and translation cost.

Balanced

Aims for the best balance between context, quality and cost.

Maximum Quality

Prioritizes translation context and available intelligence systems when quality matters more than API usage.

These profiles work with the existing translation systems instead of replacing them.

Godot Engine Support

One of the biggest changes in this update is the addition of Godot support.

GameTranslatorAI was originally built around Ren'Py projects. The engine architecture has now been expanded and tested with a second game engine.

Godot 3.x and Godot 4.x projects can now be detected and processed through the same translation pipeline used by the rest of GameTranslatorAI.

The implementation supports multiple sources of translatable text, including:

• Godot scene files
• UI text
• GDScript localization calls
• Native localization resources
• Hardcoded player-facing text
• Dialogue systems

Safe Hybrid Text Detection

Godot projects can store text in many different ways, especially when developers don't use the built-in localization system.

Because of this, simply searching every string in the project would be dangerous. File paths, node names, identifiers and other internal values could accidentally be translated and break the game.

GameTranslatorAI now classifies detected text based on confidence.

SAFE

Text that can reliably be identified as player-facing content can enter the translation pipeline normally.

REVIEW REQUIRED

Potential dialogue or UI text that cannot be identified with enough confidence is separated for review instead of being silently ignored or automatically translated.

TECHNICAL

Strings identified as code, paths, identifiers or other technical data are excluded from translation.

This approach is designed to improve text coverage while protecting the structure and logic of the game.

Review Required

Uncertain Godot text can be reviewed before translation.

Instead of forcing the system to guess, users can decide whether detected text should be included or ignored.

Once approved, the text enters the normal GameTranslatorAI translation pipeline and can use the same translation systems as any other supported text.

Dialogue System Support

Support has also been added for common Godot dialogue workflows.

This includes integration work for:

• Dialogic
• Dialogue Manager

Their dialogue formats are handled separately from the core Godot extraction logic so support can be expanded without turning the main engine parser into a collection of plugin-specific rules.

Translation Intelligence Integration

Godot isn't running through a separate simplified translation system.

Extracted Godot text enters the existing GameTranslatorAI pipeline, meaning it can work with systems such as:

• Translation Memory
• Community Translation Memory
• Delta Translation
• Character Memory
• Context Learning
• Translation Intelligence
• Batch and line translation
• Cost optimization
• Existing AI providers

This was an important architectural goal: adding another engine without duplicating the translation system.

Safer Write-Back

Writing translated text back into game files is one of the riskiest parts of engine support.

GameTranslatorAI does not use a global search-and-replace approach.

Translations are written back using the original source location of each extracted text unit.

Before replacing text, the system verifies that the expected original content is still present.

After writing, the file can be scanned again to make sure the expected structure and extracted text remain valid.

If a write operation cannot be performed safely, it is rejected instead of risking damage to the game file.

Round-Trip Testing

Godot support is tested through the complete translation file cycle:

Extract → Translate → Write → Re-scan

The tests verify that:

• translated text is written to the correct location
• technical strings remain untouched
• placeholders and escaping are preserved
• unexpected text units are not created or lost
• modified files remain structurally readable
• existing Ren'Py behavior remains unaffected

Real Godot Validation

Automated parser tests weren't the final check.

The generated test project was also validated using a real Godot installation.

This actually caught an issue in one of the test fixtures that the internal validation couldn't detect. The fixture was corrected and the full validation was run again successfully.

Final test result:

1360 passed · 0 skipped · 0 failed

The real Godot validation also passed successfully.

What's Changed Overall?

GameTranslatorAI V2 can now make smarter decisions about how much AI context it actually needs, reducing unnecessary token usage and API cost while preserving translation quality.

At the same time, the engine architecture has successfully moved beyond its original Ren'Py-only implementation.

Godot is now the second supported game engine, and more engine support is planned as development continues.

There is still more work ahead, including real-world testing with actual games, but this is an important step toward making GameTranslatorAI a more flexible game localization tool.

More updates soon.