How to Generate PO Files for Game Localization in Unreal Engine

A Guide to Getting Your Game Ready for the World

This guide will walk through scanning your game for text and generating PO files to use for text translation.

First Things First: What Is a PO File?

A Portable Object file (PO) is a text file that holds translations between two languages. It is a standardized format that contains entries for each line of text to be translated. At a minimum each entry will contain a msgid and a msgstr. Translators work directly with these files, filling in the msgstr with the translated version of msgid .

#: MainMenu.uasset
msgid "Start Game"
msgstr "Démarrer le jeu"

Unreal Engine has strong built-in support for localization. It can collect all the text in your game, export it to PO files, and then import translations back in — all without you having to manually hunt down every string.

The Big Picture: How It All Works

Here’s the workflow at a glance:

1. Gather Text ( Unreal scans your assets)
2. Export to PO Files
3. Send to Translator
4. Translator fills in translations
5. Import PO Files back into UE
6. Localized Game 🎉

Now let’s walk through each step.

Step 1: Mark Your Text for Translation

Before Unreal can export anything, it needs to know which text should be translated. Unreal calls this “localizable text”.

In Blueprints

If you’re using Blueprints (Unreal’s visual scripting system), any text you display — in a UI widget, a dialogue box, a button label — should use the Text type, not the String type.

Why? Because Unreal only localizes the FText type. FString is just a raw string — Unreal won't touch it for localization.

When you create a Text variable or literal in Blueprints, you’ll notice a small icon (it looks like a tag or label). Make sure the text is not marked as “Culture Invariant” — that flag tells Unreal to skip it during localization.

In C++

If you write C++ code, wrap your strings in the NSLOCTEXT or LOCTEXT macros:

// LOCTEXT takes a namespace and key
FText MyLabel = LOCTEXT("MainMenu_StartButton", "Start Game");

// NSLOCTEXT is the same but you specify the namespace inline
FText MyLabel = NSLOCTEXT("MainMenu", "StartButton", "Start Game");

Any string not wrapped in these macros won’t appear in your PO files. This is the most common reason for missing translations.

In Data Tables

If you store dialogue, item descriptions, or UI labels in Data Tables, make sure those columns use the Text type, not String or Name.

Step 2: Open the Localization Dashboard

Once your text is properly marked, you’re ready to start the export process.

In Unreal Engine 5 (and late UE4), go to:

Tools → Localization Dashboard

(In older versions of UE4 it may be under Window → Localization Dashboard.)

This opens Unreal’s dedicated localization interface.

Step 3: Create a Localization Target

A Localization Target is basically a named container for your project’s translations. You’ll usually just have one — called something like “Game”.

1. Click Add New Target (or you may already have a “Game” target created automatically).
2. Give it a name (stick with “Game” unless you have a specific reason not to).
3. Under Cultures, add the languages you want to support. For example: en (English), fr (French), ja (Japanese).

The source culture is your original language — usually English (en). The other cultures are your translation targets.

Step 4: Configure What to Gather

Now you tell Unreal where to look for text to translate.

Inside your Localization Target, find the Gather Text section. You’ll see options for gathering from:

• Packages (your .uasset files — levels, blueprints, widgets, etc.)
• Metadata (asset names and descriptions)
• Source Code (your C++ files, for those LOCTEXT macros)
• INI Files (configuration files)

For most games, you’ll want Packages and Source Code enabled. Make sure the paths point to your project’s content and source directories.

Click Gather Text when you’re ready. Unreal will scan everything and build a list of all the localizable strings it finds.

Step 5: Export to PO Files

After gathering, you’ll see a count of how many strings were found. Click Export to PO (or simply Export, depending on your UE version).

Unreal will generate one PO file per language, saved to your project’s localization folder:

YourProject/
  Content/
    Localization/
      Game/
        en/
          Game.po       ← source strings
        fr/
          Game.po       ← empty (waiting for translations)
        ja/
          Game.po       ← empty (waiting for translations)

The en/Game.po file contains all your source strings. The other folders contain PO files with the msgid fields filled in but empty msgstr fields — those are the blanks your translator will fill in.

Step 6.a: Send to Your Translator

Hand the PO files for each target language to your translator (or translation service). They can open PO files in free tools like POEdit — a simple, purpose-built editor that makes translation easy even for non-technical people.

Your translator sees a clean list of source strings and fills in the translations one by one. When they’re done, they save the file and send it back to you.

Step 6.b: Use an Unreal Compatible Localization Provider Plugin

Unreal provides an option to directly use a localization provider plugin to automatically generate localized text using an external automation service.

The Syntactic Text Localization Unreal Plugin can automatically translate 32 different languages.

Once you have downloaded the plugin and enabled it , you can select it from the Localization Provider dropdown and use it to Auto-generate the translations. An example video translating English to Spanish can be found here.

As your game grows, so does your text. A Localization Provider keeps your translation data in sync with that growth, letting you spot and fix layout or formatting problems without burning a translator’s time ( and budget ) on a build that isn’t ready.

Step 7: Import the Translations Back

Once you have your translated PO files back, drop them into the correct folders (replacing the empty ones), then go back to the Localization Dashboard and click Import from PO.

Unreal reads the files and compiles everything into its own internal binary format (.locres files). These are what the engine actually uses at runtime — the PO files are just the human-readable exchange format.

Click Compile if Unreal doesn’t do it automatically.

Step 8: Test Your Localization

To test a specific language in the editor:

Go to Edit → Editor Preferences → Region & Language and change the Preview Game Language to your target language. Then hit Play.

Alternatively, you can launch your game with a command-line argument:

YourGame.exe -culture=fr

This forces the game to start in French (or whatever culture code you pass in).

Common Gotchas (And How to Avoid Them)

“Some of my strings aren’t showing up in the PO file.” Double-check that you used FText and not FString. Also verify your gather paths include all your content directories.

“The translation isn’t showing up in-game even after importing.” Make sure you clicked Compile after importing. The engine uses compiled .locres files, not the raw PO files.

“My UI still shows English.” Confirm the widget text is using a Text variable, not a hardcoded String. Also check that the text node isn't set to "Culture Invariant."

“The translator says the context doesn’t make sense.” PO files include metadata about where each string came from (the asset name and key). If your keys are auto-generated gibberish, add a proper Text Key comment in your Blueprint or a meaningful namespace in your C++ macros. This helps translators understand the context of each line.

A Note on Text Keys and Namespaces

Every localizable string in Unreal has three parts:

• Namespace — a broad category (e.g., MainMenu, InventoryScreen)
• Key — a unique identifier within that namespace (e.g., StartButton, ItemDescription)
• Source String — the actual text (e.g., “Start Game”)

Good namespaces and keys make translator’s lives much easier, especially for large games with thousands of lines. Take a few minutes to set these up thoughtfully — you’ll thank yourself later.

Wrapping Up

Generating PO files for Unreal Engine localization is less scary than it sounds once you understand the pieces:

1. Mark your text as localizable (FText, proper widget types)
2. Open the Localization Dashboard and create a target
3. Configure your gather sources
4. Gather text, then export to PO
5. Send to translator, get back translated PO files
6. Import and compile
7. Test in-editor or via command line

The PO file format is a battle-tested, widely understood standard that keeps developers and translators working in their own comfort zones. Unreal’s tooling around it is solid — once you’ve run through it once, it becomes a routine part of your release pipeline.

Now go make your game speak every language it deserves to.

Have questions or ran into a specific issue? Drop a comment below — happy to help.