VeluTranslate – runtime localization plugin for Unreal (new player languages without rebuilds)

Community Showcase
,
1

I’ve been building a live localization plugin for Unreal called VeluTranslate and the core idea is very simple:

  • If a player starts the game in a language you don’t support yet, they see:
    “Your language is being prepared. It will be ready in a few minutes.”

  • When the backend finishes AI translation and deploys it, the game shows:
    “Your language is ready. Click here to switch.”

  • No new build, no patch, no store review.

:movie_camera: Short demo video

Unreal plugin + web dashboard + auto language expansion:

:backhand_index_pointing_right: YouTube demo: https://youtu.be/qfmlA6fmypA

Who I am

I’m Lukáš from Slovakia, working on VeluTranslate together with Veronika.
We originally built this for our own projects because we were tired of:

  • shipping new builds just to fix text,

  • re-baking localization every time we added a language,

  • keeping Unreal + other ports in sync.

Now we’re turning it into a product and looking for feedback from other Unreal devs.

TL;DR

Let your game teach itself new languages.
Runtime localization plugin for Unreal – change text and add languages in minutes, without rebuilds or store review.

  • Unreal: main, production-ready target.

  • Unity: public beta using the same backend.

The problem it tries to solve

If any of this sounds familiar:

  • you ship a new build or patch just to update text (UI, tutorial, shop, events),

  • you plan to add more languages or new markets later,

  • you run live ops (seasonal events, offers, notifications),

  • QA is slowed down because all text is baked into the build,

…then you know how annoying text-related builds can be.

We wanted text to behave like runtime data, not a reason for another build.

What VeluTranslate does (Unreal-first)

VeluTranslate sits between your game and the final text.

In game code / Blueprints you use keys, e.g.:

  • menu.play

  • shop.offer_title

  • tutorial.step_1

The plugin then loads the actual strings from a cloud JSON layer (via CDN) or from a cached JSON file.

You control everything from a web dashboard:

  • edit text,

  • add or remove languages,

  • run AI translations,

  • review and approve before going live.

:backhand_index_pointing_right: Changing a string or adding a language does not require a new build.

Auto-expanding languages at runtime

When a player appears with a new language (e.g. Brazilian Portuguese, Turkish):

  1. The plugin detects the player’s language at runtime.

  2. If that language doesn’t exist in the project yet, VeluTranslate can:

    • create a new language entry,

    • prefill it with AI translations,

    • mark it for manual review if you want.

  3. In game, that first player sees:

    • “Your language is being worked on…”

    • “Your language is ready. Click here to switch.”

From that point on, all future players with the same language get a fully localized experience – still without shipping a new build.

Auto-translation can be completely disabled or limited from the web panel if a studio prefers manual-only control.

Short overview of the Unreal integration

1. Install & pair

  • Install the VeluTranslate plugin into your Unreal project.

  • Pair the editor with your Velu project (EditKey → device token).

  • Configure the subsystem (project ID, default language, etc.).

2. Use keys instead of hardcoded text

  • Use keys (or bridge an existing system like String Tables).

  • There is also a String Table bridge, so you can keep your existing tables and let VeluTranslate manage their content.

3. Fetch text at runtime

On BeginPlay (or earlier), the plugin fetches text from either:

  • Online mode:
    CDN-hosted JSON with caching.

  • Offline JSON mode:
    A JSON file that ships with the build, but its content is managed from the cloud and can be updated out-of-band.

4. Change text on the web, see it in game

  • Open the web dashboard, change any text or add a language.

  • The next time the game refreshes data, it picks up the new content – no rebuild.

Current status

  • Unreal plugin:
    Production-ready, used in our own projects.
    Currently downloadable directly from our website (Fab / Marketplace review is next).

  • Unity integration:
    Public beta using the same backend (workflow/packaging still being tuned).

Right now we’re focusing on:

  • polishing the Unreal dev experience,

  • adding more examples (menu, shop, events),

  • getting feedback from real Unreal teams (indies and small studios).

Early access, demo & trial

If you’re curious or want to poke holes in it:

We’d rather work closely with a smaller number of teams, fix real-world issues, and then call it “1.0”.

What kind of feedback we’re looking for

I’d really appreciate hearing:

  • how you currently handle localization in Unreal
    (String Tables, Data Tables, custom systems, external tools),

  • what would be a dealbreaker for a runtime localization plugin,

  • which features would be missing to make this usable in your pipeline.

If you’re interested, I can also:

  • share a minimal example project, or

  • record a short Unreal-only walkthrough focused on your type of game (menu-heavy, narrative, live ops, etc.).

Happy to answer any questions or dive into technical details (Subsystem, caching, CDN, fonts, analytics, etc.).