[UE5] Localization Basics: Showing the Same Menu in Japanese and English

You want "ゲームをはじめる" to read "Start Game". One button is easy to rewrite, but once dialogue and item descriptions pile up, rebuilding screens per language is a lot of work.

In UE5 you can prepare translations per language for the same Text and display the language you chose . The Localization Dashboard is the tool that prepares that. Leave gathering the strings to UE and enter translations in a separate list.

What You'll Learn

• Preparing displayed text as the Text type for translation
• Gathering Japanese source text and making the English readable by the game
• Switching language from a picker and keeping the setting for the next launch
• Checking for missing glyphs and untranslated text through to a packaged build

Our subject is a small menu with a start button and a language picker, using basic Blueprint and UMG. Localization is adapting a game's display to a language or region. Here we handle Japanese and English text as the entry point.

Text versus String: separate what carries translations

When handling text in Blueprint, choosing between Text and String matters.

Type	How we use it here
Text (FText in C++)	Display that changes by language, such as "ゲームをはじめる"
String (FString in C++)	Text passed to logic, such as the language codes en and ja

Text can carry information tying it to which source text a translation belongs to . Entering the source in a UMG Text Block and gathering that Text as a translation target is how we build it.

Making something Text does not produce an English translation. We later gather the source and enter "Start Game" for "ゲームをはじめる". Text also has a setting for not translating it, so holding it as Text and having a translation prepared are different things .

Meanwhile, joining "Gold: " and a number as Strings at runtime and converting to Text at the end does not automatically create a translation mapping. Sentences containing numbers are assembled with Format Text later. For text you want shown as-is without translation, such as player names, conversion from String works.

Preparation: build the menu to translate

Use a Third Person Blueprint project. Create a UI folder directly under Content and, inside it, create WBP_LanguageMenu from "User Interface → Widget Blueprint" with User Widget as its parent.

In the Designer, place a Canvas Panel at the root with a Vertical Box as its child. Aim for the Vertical Box's Canvas slot at a center anchor, Alignment (0.5, 0.5), Position (0, 0), and Size (480, 260).

Inside the Vertical Box, stack these three from the top. Padding of about 8 on each slot creates spacing between lines.

Element	Name	Settings
Text Block	Text_MenuTitle	Text "メニュー", Font Size 32
Button with a Text Block child	Button_Start, Text_Start	Text "ゲームをはじめる", Font Size 28
Combo Box (String)	Combo_Language	Is Variable on. Default Options "日本語" and "English". Font Size 24

Enter the text directly into the Text Blocks' Text fields and, where the Text details can be expanded, enable "Localizable". We do not create a Text Binding. Leave Combo_Language's Selected Option empty; we set it from the current language later.

Only the language picker is String so that "日本語" and "English" display as written in any language . Even on an English screen, you can return from a language name you can read. We translate the start button's text but not those two entries.

Enable Is Focusable in the Widget's Class Defaults. That lets us designate this Widget as the input target later. Compile, save, and save the current level as L_LanguageTest . Build the following in the Level Blueprint.

1. Wire Event BeginPlay to Create Widget (Class = WBP_LanguageMenu). Pass Get Player Controller (Player Index = 0) to Owning Player.
2. Pass Create Widget's Return Value to Add to Viewport's Target and wire white exec too.
3. Continue to Set Input Mode UI Only. Player Controller is the same Get Player Controller and In Widget to Focus is Create Widget's Return Value.
4. With the same Player Controller as Target, set Set Show Mouse Cursor to true.

After displaying it, switch the input destination too.

The A in the diagram marks the white wire continuing from the previous diagram. You do not create it as a node. When placing several Get Player Controllers, use Player Index 0 for the same player.

Now the menu is clickable. Logic starting the game from the start button is not added in this hands-on. To review displaying screens in detail, see the UMG article.

Dashboard: gather, translate, and make it usable

Open "Tools → Localization Dashboard". Translations are prepared in three stages.

Operation	What it does
Gather	Collects the source text to translate from specified assets
Translate	Enters the translation matching each source
Compile	Turns entered translations into .locres files the game loads

1. Configure the Game target and languages

Select the Game target on the left. If there is none, add a Game Target and name it Game . A target is a group of text gathered and translated together. We collect the menu's text into this one.

Entry	Setting here
Loading Policy	Game
Cultures	Add Japanese (ja) and English (en)
Native Culture	Choose Japanese (ja)

A Culture represents a language or region. Here ja is Japanese and en is English. Native Culture is "the language the source is written in", so for this Japanese-authored menu it is ja. Loading Policy's Game specifies loading this translation when the game runs.

2. Decide where to gather from

Enable "Gather from Packages" in Gather Text's settings. Packages here means asset files such as Widgets. It is not a setting for finding a shipped exe.

• Add Content/UI/* to Include Path Wildcards.
• Confirm Widget .uasset files are covered by File Extensions. Keeping the default .umap is fine.
• Confirm Exclude Path Wildcards does not exclude Content/UI.

Content/UI/* searches under the project's Content/UI. The trailing * marks file names and such at that location as covered. If your Widget lives elsewhere, include that too. When expanding to conversation Data Tables, add wherever the source text lives.

3. Gather two sources and enter the English

Save All the Widget and level, then run "Gather Text" and confirm it succeeded. Open "Edit Translations", such as the pencil icon on the English row.

Find the sources in the translation editor's Untranslated list and enter these translations, then save.

Japanese source	English translation
メニュー	Menu
ゲームをはじめる	Start Game

Confirm those two lines appear in the list here. If they do not, before translating, review where the Widget was saved, the gather scope, and whether the Text is Localizable. Total word counts vary by project, so verify by the actual sources rather than a count.

Return to the Dashboard and run "Compile Text". With that done, the English the game uses is prepared. When you add new text, repeat save → Gather → enter translations → Compile. Fixing only a translation also needs a Compile after saving.

Hands-On: switch to the chosen language

Choosing English changes the same menu's "ゲームをはじめる" to "Start Game". You do not need a separate English Widget.

The node that changes language

We use Set Current Culture , passing the String en or ja to Culture. It also changes number and date formatting, but in this menu we use it for switching between Japanese and English.

Setting Save to Config true saves the choice to user settings. It reads back at launch, so we do not create a language-specific Save Game.

The Boolean Return Value indicates whether the setting was applied. Even true does not create missing English translations. Whether translations appear on screen is verified separately.

Wire the selection event

Create a Boolean bSyncingSelection on WBP_LanguageMenu with default false. It marks the period where we auto-match the picker, preventing the change event from continuing into a language switch.

Select Combo_Language in the Designer and add On Selection Changed from Details' Events. Wire the white output to a Branch with bSyncingSelection into Condition. True ends without doing anything. From False, continue to Switch on String.

Pass the event's Selected Item to the Switch's Selection. Add "日本語" and "English" to Pin Names in the selected Switch's Details to get white outputs with those names. Default can stay unconnected.

Wire the 日本語 output to Set Current Culture (Culture = ja) and English to another Set Current Culture (Culture = en). Both use Save to Config = true. Do not add quotation marks in the field; just enter ja or en.

From each white output, continue to a Branch with that node's Return Value into Condition. True ends. On False, Print String "Check the language settings". Restoring the picker on failure uses the sync function next.

Match the picker to the current language after a relaunch

Having English saved while the picker still reads "日本語" is confusing. When the menu opens, read the current language and match the picker .

Create a function SyncLanguageSelection on WBP_LanguageMenu with no inputs or outputs and Pure disabled.

1. Wire the entry to Set bSyncingSelection = true.
2. Pass Get Current Language's String output to Starts With's Source String with In Prefix en.
3. Pass that Boolean to Select String's Pick A, with A = English and B = 日本語.
4. Continue white exec to Set Selected Option (Target = Combo_Language), passing Select String's output to Option.
5. Finish with Set bSyncingSelection = false.

Get Current Language, Starts With, and Select String return values and take no white wires. Starts With checks "does it begin with that text". Regional English such as en-US also matches English, and anything else matches Japanese, our source language. That mapping is for this exercise, which prepares only ja and en.

Call SyncLanguageSelection (Target = Self) from the Widget's Event Construct. Self is the Widget running this logic. Also call it after the Print String on the branch where Set Current Culture failed.

Even when Set Selected Option raises a selection-change event, the first Branch stops it while syncing. That is the mechanism preventing the picker-matching logic from overwriting the saved language .

Check fonts and how text fits

"Start Game" reads fine while Japanese shows as □ . That is a different problem from a missing translation; it happens when the font in use lacks the needed glyphs , the character shapes.

UE also has a mechanism using a different font per character. Do not assume the name Roboto means Japanese never appears; check the Font actually used and its fallback settings. For shipped UI, explicitly using a Font containing Japanese makes verification easier.

Prepare a TTF or OTF font containing Japanese glyphs that you may use in a game. Import it into the Content Browser and, when asked whether to create a Font Face and a Font, choose to create them.

A Font Face holds glyph data and a Font is the asset you assign in UI . Choose your created Font under "Appearance → Font" on Text_MenuTitle and Text_Start and specify the typeface such as Regular. Set the same Font on Combo_Language so "日本語" is readable. If you only created a Font Face, create a "User Interface → Font" and assign the Font Face to its Default Font Family.

If English overflows the button, review width and Padding before shrinking the text. For descriptions, fixing a width and using Auto Wrap Text wraps it. Do not assume "English is always longer"; check both languages' actual text for clipping and line breaks .

Confirm: from Standalone to a packaged build

Compile and save all assets and run the Dashboard's Compile Text. Choose Standalone Game from the Play menu and open the menu in a separate window.

PIE inside the editor has a translation preview that is not identical to runtime language settings. Use Standalone to verify switching and saving here, and test a shipped package at the end.

Action	Expected result
Choose 日本語	メニュー / ゲームをはじめる
Choose English	Menu / Start Game
Switch back to 日本語	The original Japanese reads correctly with no boxes or clipping
Choose English, quit, and relaunch	It opens in English with the picker on English

If the editor's Preview Game Language or launch arguments specify a language, it affects the relaunch result. When verifying saving, launch with any test language override removed.

Include translations and language data in the build

Check the following under "Project Settings → Packaging". The search box or expanding advanced entries helps find them.

Entry	Setting here and its role
Localizations to Package	ja and en. Chooses which translations to include
Internationalization Support	EFIGSCJK. Includes language-processing data covering Japanese and English
Build Configuration	Development. A build for verification

Translated text and the data for handling languages are different , so include both. Set L_LanguageTest as the Game Default Map and, if needed, add it to the packaged maps list.

Build for Windows following the packaging article and launch the resulting exe. Confirm the four items above again. After fixing a translation, run Compile Text and rebuild the package.

To specify only the launch language, add a space and -culture=en after the quoted exe path in a shortcut's target. For Japanese use -culture=ja . That is for inspecting the launch display; remove it when verifying saving.

Investigate what does not change, in order

Symptom	Where to check
The source is not in the translation list	Save All, the Content/UI gather setting, exclusions, Localizable
Only some parts stay Japanese	That source's English, a Compile after changes, whether it was built from a String
Everything stays Japanese	The selection event, Culture en, Loading Policy = Game, Compile
Set Current Culture returns false	Typos in the code, the package's Internationalization Support
Japanese shows as boxes	Text Block and Combo Box Fonts, the needed glyphs, inclusion in the package
It reverts after a relaunch	Save to Config, a launch language override, overwriting by other initialization
Only the exe lacks translations	Localizations to Package, compiling translations, repackaging

Bonus: translating sentences with numbers in them

For displays like "所持金：100", combine text and a number with Format Text . Leaving a marker such as {Gold} reserves the place for a value. That marker is called a placeholder.

Source Format	English Format
所持金：{Gold}	Gold: {Gold}

Add a Text Block to WBP_LanguageMenu's Vertical Box named Text_Gold with Is Variable on. Assign the Japanese-capable Font here too and widen the Vertical Box if it does not fit. After calling SyncLanguageSelection in Construct, wire to SetText (Target = Text_Gold), passing Format Text's output to In Text.

Typing 所持金：{Gold} directly into the Format field creates a Gold pin. Set a Make Literal Int's Value to 100 and pass its output to Gold. Save, Gather to collect this source, enter the English Gold: {Gold} , and Compile. Do not translate {Gold} ; keep the same name.

Switching in Standalone shows 所持金：100 and Gold: 100. Pass Format Text's result to SetText as Text without converting to String along the way. When the number changes during play, rebuild Format Text with the new value and SetText again.

This form also handles translations where the number sits in a different place. UE handles language rules such as plurals too, but switching this one sentence first builds the sense of separating text from values.

To hand translations to a person, the Dashboard exports PO files. PO is the format for exchanging sources and translations. When translations come back, import them, review the contents, and Compile. If you edited a source afterwards, also check that the translation is not stale.

Once you have a full round trip on the menu, expand to dialogue and item descriptions. The steps of "prepare the displayed text", "give it translations", and "verify in game" are the same.

Summary

• Use Text for strings that carry translations and String for internal strings
• The Dashboard is three stages: gather, translate, make usable
• Save the chosen language and match it on the next launch
• Verify glyphs and fitting through to a packaged build

The question when writing is "does this text appear on screen?" If it does, make it Text.

Sentences mixing numbers are covered in this article's bonus, and the mechanism for persisting settings in the settings menu.

Reference: Localization Tools, Text Localization, Culture and previewing, Creating fonts.