When we started working on our first game in Unreal Engine, localization wasn't exactly at the top of our priority list.
There were plenty of other things to figure out, and choosing the game's language seemed like an easy decision. English would be enough. At least, that was the original plan.
By the time we'd made some progress on the game, a question came up during one of our conversations that we hadn't really thought much about before.
"What about people who don't speak English? How are they supposed to enjoy the game if they can't understand it?"
And honestly, that was a good question. :)
So we started looking into how localization works in Unreal Engine and what options were available.
There were already several tools and approaches out there, but we had something a little different in mind.
We wanted to manage translations online.
Open a web interface, fix a translation, add another language, and let the game pick up those changes without having to release a new build every single time.
At that point, we weren't trying to build some big localization platform. We just wanted to make localization easier to manage in our own game.
One Solved Problem Led to Another Question
The first idea was simple: store the translations in a database and let the game fetch them directly.
But then came the security question.
How do you safely handle database credentials in a game that anyone can download?
That's why we moved to a read-only API. The game could fetch translations, but it couldn't modify them. The database stayed separate from the game itself.
That solved one problem, but it wasn't long before another one appeared.
What if 100,000 people downloaded the game?
Having thousands of clients repeatedly request translations from our main server didn't sound like the best approach.
So we started looking at Cloudflare CDN and caching.
Initially, we considered caching translations for 5 to 15 minutes, or maybe even an hour. At one point, we even thought about different cache durations depending on the subscription plan.
But why should a developer have to wait for the cache to expire every time they fix a single string?
In the end, we went with long-lived caching, combined with CDN synchronization and the ability to purge the relevant cache when translations change.
A developer can update a string, trigger synchronization, and subsequent requests can receive the updated version without constantly putting load on the main server.
Later, we also added a separate fallback server outside the CDN. It keeps its own slightly delayed copy of the translations, giving clients an alternative source if the CDN becomes unavailable.
And to think that all of this started because we wanted to add a few more languages to a game.
What If the Player Is Offline?
Another important question was how localization should work without an internet connection.
Our Unreal Engine plugin can store downloaded translations locally. Once the game has successfully fetched them, it can continue using them without an internet connection.
We also recommend that developers bundle their language JSON files directly into the game build through the plugin. It's optional, but it means translations are available from the very first launch, even when the player is offline.
If the files aren't included in the build, the plugin can download them on the first successful online launch and save them for future use.
For integrations using the Runtime API, developers can implement local storage and offline behavior in whatever way works best for their projects.
The basic idea is simple: the internet should mainly be used to update translations, not be a requirement just to display text in a game.
How VeluTranslate Came to Be
Over time, we added project management, synchronization tools, more integration options, and eventually context-aware AI translation.
One of the more interesting features is the ability to automatically prepare a missing language.
If a player uses a language that isn't available yet, VeluTranslate can prepare it in the background, provided the developer has enabled automatic AI translation and has enough credits.
Meanwhile, the player can continue using an available language. The plugin checks the CDN for the requested language, and once it's ready, the game can offer the player the option to switch without requiring a new game update.
And if multiple players request the same language, the system creates just one translation job.
Eventually, it became clear that we were no longer building a localization plugin for a single game.
What started as a small solution had grown into VeluTranslate.
One thing worth mentioning, though, is that AI is completely optional.
Developers can use their own translations, work with professional translators, or manage everything manually.
The main purpose of the platform is to manage, update, and distribute localization. AI is simply an optional part of that workflow.
Today, we're continuing to develop VeluTranslate for both games and applications, with an Unreal Engine plugin and a Runtime API for other engines and custom projects.
We're Looking for Developers to Try It in Real Projects
We've recently opened the VeluTranslate Pilot Program.
We're looking for indie developers, small studios, and teams working on games or applications who would like to try the platform in a real project.
Selected projects will receive 60 days of free access to the platform. AI credits aren't included in the free period and are billed separately if you choose to use them.
VeluTranslate is still under active development, and we'd like to find out how well it works outside our own projects.
What works well for other developers? What's confusing or unnecessarily complicated? What's missing?
We're not looking for people to tell us everything is perfect. Specific, constructive criticism is exactly what can help us improve the system.
If you'd like to learn more about joining the program:
👉 VeluTranslate – Pilot Program
How Do You Handle Localization?
Do you use the localization tools built into your engine, external services, or something you've built yourself?
What causes the most trouble in your localization workflow? Adding languages, updating translations, managing files, or something else entirely?
Feel free to mention specific tools or approaches that have worked well for you.
It would be interesting to hear how other developers deal with these challenges. Maybe we can learn a thing or two from each other.
Top comments (0)