Skip to main content

Den komplette guiden til lokalisering i Unreal Engine

Fra FText-makroer til reservekjeder for språkinnstillinger: lokaliser UE5-spillet ditt med Localization Dashboard, String Tables, C++, Blueprints og automatisert oversettelse.

1

FText og lokaliseringspipelinen

FText er Unreal Engines lokaliseringsklare strengtype. Hver brukervendt streng i spillet ditt — etiketter i brukergrensesnittet, dialog, verktøytips og varsler — må bruke FText for å inngå i lokaliseringsprosessen. FString skal bare brukes til intern logikk.

LOCTEXT krever to argumenter: en nøkkel og en kildestreng. Nøkkelen må være unik innenfor sitt navnerom. UEs tekstinnsamler bruker disse nøklene til å spore oversettelser på tvers av kulturer. NSLOCTEXT lar deg angi navnerommet eksplisitt; LOCTEXT bruker navnerommet definert av den omsluttende LOCTEXT_NAMESPACE-makroen.
FText Basics
// FText is UE's localization-aware string type.
// ALWAYS use FText for user-facing text, never FString.

// LOCTEXT: localize a literal string (most common)
FText Title = LOCTEXT("MainMenuTitle", "Start Game");

// NSLOCTEXT: specify namespace explicitly
FText Msg = NSLOCTEXT("UI", "WelcomeMessage", "Welcome, adventurer!");

// INVTEXT: invariant text (never translated — debug/logging only)
FText Debug = INVTEXT("Debug overlay active");

// FText::Format: safe variable interpolation
FText Greeting = FText::Format(
    LOCTEXT("PlayerGreeting", "Hello, {PlayerName}!"),
    FText::FromString(PlayerName)
);
MainMenuWidget.cpp
// In a UMG Widget (C++)
void UMainMenuWidget::NativeConstruct()
{
    Super::NativeConstruct();

    // Bind localized text to UI elements
    if (TitleLabel)
    {
        TitleLabel->SetText(LOCTEXT("GameTitle", "My Epic Game"));
    }

    if (PlayButton)
    {
        PlayButton->SetText(LOCTEXT("PlayButtonLabel", "Play Now"));
    }
}

// IMPORTANT: Always use LOCTEXT for UMG widget text.
// Setting text via FString bypasses the localization pipeline.
Bygg aldri brukervendt tekst med FString::Printf eller strengsammenslåing. Dette omgår hele lokaliseringspipelinen — den resulterende teksten kan ikke samles inn, oversettes eller vises korrekt i RTL-språk. Bruk alltid FText::Format med LOCTEXT-mønstre i stedet.
2

Sett opp Localization Dashboard

Localization Dashboard er UEs innebygde verktøy for å administrere oversettelser. Det samler inn alle LOCTEXT- og NSLOCTEXT-strenger fra kildekoden din, eksporterer dem som .po-filer for oversettelse, og kompilerer resultatene til binære .locres-filer som UE laster inn ved kjøretid.

Localization Dashboard Workflow
# 1. Open the Localization Dashboard:
#    Window > Localization Dashboard

# 2. Add a localization target (e.g., "Game")

# 3. Add cultures:
#    Click "Add New Culture" > select languages (de, ja, fr, es, ko, zh-Hans...)

# 4. Gather text:
#    Click "Gather Text" — UE scans all LOCTEXT/NSLOCTEXT macros

# 5. Export translations:
#    Click "Export" to generate .po files for each culture

# 6. Import translations:
#    After translating .po files, click "Import"

# 7. Compile translations:
#    Click "Compile" to generate .locres binary files

# 8. Preview:
#    Editor Preferences > Region & Language > Preview Game Language
Kjør «Gather Text» etter hver kodeendring som legger til eller endrer LOCTEXT-makroer. Hopper du over dette steget, vises ikke nye strenger i .po-filene dine, og oversetterne ser dem ikke. Legg til et innsamlingssteg i byggautomatiseringen din for å fange dette automatisk.
3

Bruk String Tables for datadrevet tekst

String Tables lar deg definere lokaliserte strenger i en sentralisert ressurs i stedet for å spre LOCTEXT-makroer utover kildefiler. De er ideelle for UI-tekst, dialog og alle strenger som designere eller forfattere trenger å redigere uten å røre koden. String Tables kan defineres som UE-ressurser eller importeres fra CSV.

StringTableUsage.cpp
// StringTables provide a data-driven approach to localization.
// Define strings in a CSV asset instead of scattering LOCTEXT across code.

// 1. Create a String Table asset:
//    Content Browser > Right-click > Miscellaneous > String Table

// 2. Or define via CSV (importable into UE):
// Key,SourceString
// MainMenu_Title,Start Game
// MainMenu_Continue,Continue
// MainMenu_Settings,Settings
// MainMenu_Quit,Quit to Desktop
// HUD_Health,Health
// HUD_Ammo,Ammo: {0}
// Dialog_Merchant_Greeting,Welcome to my shop!

// 3. Reference in C++:
FText Title = FText::FromStringTable(
    FName(TEXT("/Game/Localization/ST_MainMenu")),
    TEXT("MainMenu_Title")
);

// 4. Reference in Blueprints:
//    Use the "Make Text from String Table" node
//    Set Table ID and Key
String Tables samles inn automatisk av Localization Dashboard. Du trenger ikke LOCTEXT-makroer for strenger definert i en String Table — bare referer til dem med tabell-ID og nøkkel i C++ eller Blueprints.
4

C++-lokaliseringsmønstre

I C++ definerer du en LOCTEXT_NAMESPACE øverst i hver .cpp-fil og bruker LOCTEXT for alle brukervendte strenger. Bruk FText::Format for dynamisk innhold med variabler. Opphev alltid navnerommet på slutten av filen for å unngå lekkasjer.

MainMenuWidget.cpp
// Define a namespace at the top of each .cpp file
// All LOCTEXT calls in this file use this namespace
#define LOCTEXT_NAMESPACE "MyGame.MainMenu"

#include "MainMenuWidget.h"

void UMainMenuWidget::NativeConstruct()
{
    Super::NativeConstruct();

    // These use the "MyGame.MainMenu" namespace automatically
    TitleText->SetText(LOCTEXT("Title", "Main Menu"));
    PlayText->SetText(LOCTEXT("PlayButton", "Play"));
    SettingsText->SetText(LOCTEXT("SettingsButton", "Settings"));
    QuitText->SetText(LOCTEXT("QuitButton", "Quit"));
}

// CRITICAL: Always undefine at the end of the file
#undef LOCTEXT_NAMESPACE
FText::Format Examples
// FText::Format — the safe way to build localized strings
// NEVER use FString::Printf or string concatenation for user-facing text.

// Named arguments (recommended)
FText ItemPickup = FText::Format(
    LOCTEXT("ItemPickup", "You picked up {ItemName} x{Count}"),
    FText::FromString(ItemName),
    FText::AsNumber(Count)
);

// FText::AsNumber respects locale formatting:
//   English: 1,234,567
//   German:  1.234.567
//   French:  1 234 567

// FText::AsCurrency for prices:
FText Price = FText::AsCurrency(
    9.99,
    TEXT("USD"),
    &FInternationalization::Get().GetCurrentCulture().Get()
);

// FText::AsDate and FText::AsTime for dates:
FText DateStr = FText::AsDate(FDateTime::Now());
Argumenter til FText::Format må også være FText, ikke rå FString. Bruk FText::FromString() for å konvertere FString-verdier, FText::AsNumber() for tallformatering tilpasset språkinnstillingen og FText::AsCurrency() for priser. Rå FString-sammenslåing gir tekst som ikke følger formateringsreglene for språkinnstillingen.
5

Blueprint-lokalisering

Alle Text-egenskaper i Blueprints er FText som standard, så de er allerede klare for lokalisering. Angi Key og Namespace i egenskapsdetaljpanelet for å gjøre strengene innsamlingsbare. Bruk Format Text-noden for dynamisk innhold med variabler.

Blueprint Localization Patterns
// Blueprint Localization Basics:
//
// 1. All Text properties in Blueprints are FText by default
//    (already localization-ready)
//
// 2. Set the Text property in the Details panel
//    Expand the dropdown to set:
//    - Key: unique identifier for translation
//    - Namespace: grouping for organization
//    - Source String: the text to display/translate
//
// 3. For dynamic text, use the "Format Text" node:
//    Format: "Hello, {PlayerName}!"
//    Connect a "Find" pin named "PlayerName" to your variable
//
// 4. For plurals, use "Text Format with Arguments":
//    Pattern: "{Count}|plural(one=item,other=items)"
//
// 5. Culture switching at runtime:
//    Use "Set Current Culture" node
//    Input: culture code string (e.g., "de", "ja", "fr")
Utvid nedtrekksmenyen for tekstegenskapen i Blueprint Details-panelet for å se feltene Key, Namespace og Source String. Å angi en meningsfull Key gjør det mye lettere for oversettere å identifisere strenger i .po-filen.
6

Håndter flertallsformer og kjønn

Unreal Engine støtter ICU-meldingsformat for flertallsformer og kjønnsavhengig tekst. Definer flertallsregler i kildestrengene dine, og UE velger automatisk riktig form basert på den aktive kulturens CLDR-regler.

ICU Plural & Gender Rules
// UE uses ICU message format for plurals.
// Define plural rules in your .po or String Table:

// English source:
// "{Count}|plural(one=You have # item,other=You have # items)"

// German translation:
// "{Count}|plural(one=Du hast # Gegenstand,other=Du hast # Gegenstaende)"

// Arabic translation (6 forms):
// "{Count}|plural(zero=لا عناصر,one=عنصر واحد,two=عنصران,few=# عناصر,many=# عنصرًا,other=# عنصر)"

// Japanese (1 form):
// "{Count}|plural(other=アイテム#個)"

// In C++:
FText ItemCount = FText::Format(
    LOCTEXT("ItemCount",
        "{Count}|plural(one=You have {Count} item,other=You have {Count} items)"),
    ItemCount
);

// Gender-dependent text:
// "{Gender}|gender(masculine=Il est,feminine=Elle est) prêt{Gender}|gender(masculine=,feminine=e)"
Hardkod aldri count == 1 for entallsgjenkjenning. Fransk behandler 0 som entall. Russisk har egne former for «få» og «mange». Arabisk har 6 flertallsformer. La ICU-flertallsreglene håndtere logikken — definer alle nødvendige former, så velger UE riktig form per kultur.
7

Pakk og test lokaliseringen

Før lansering må du bekrefte at alle målkulturer har kompilerte .locres-filer, og at teksten vises korrekt ved kjøretid. Bruk redigeringsverktøyets kulturforhåndsvisning, overstyring av kultur fra kommandolinjen og automatiserte kontroller for å fange opp manglende eller ødelagte oversettelser.

Packaging & Testing Workflow
# Compile and test localization before packaging:

# 1. Editor Preferences > Region & Language > Preview Game Language
#    Set to each target language and verify all text renders correctly.

# 2. Command-line culture override for testing:
MyGame.exe -culture=ja

# 3. Packaging settings:
#    Project Settings > Packaging > Localizations to Package
#    Select all cultures you want to include in the build.

# 4. Verify .locres files exist after packaging:
MyGame/Content/Localization/Game/
├── en/
│   └── Game.locres
├── de/
│   └── Game.locres
├── ja/
│   └── Game.locres
├── fr/
│   └── Game.locres
└── ko/
    └── Game.locres

# 5. Runtime culture switching:
#    FInternationalization::Get().SetCurrentCulture(TEXT("ja"));
#    This reloads all FText strings from the new culture's .locres files.
Hvis en kultur ikke er oppført under Project Settings > Packaging > Localizations to Package, ekskluderes .locres-filene fra bygget. Spillere som velger dette språket ved kjøretid, vil se fallback-tekst eller tomme strenger. Bekreft alltid at pakkeinnstillingene dine samsvarer med kulturene du støtter.
8

Legg til reservekjeder for språkvarianter

Standardlokaliseringen i Unreal Engine følger bare IETF-hierarkiet for undertagger ved reserveoppslag. En pt-BR-bruker som mangler en oversettelse, får engelsk i stedet for en fullgod pt-PT-oversettelse. locale-chain-ue legger til konfigurerbare, sidestilte reservekjeder gjennom FTextLocalizationManager, slik at regionale brukere alltid ser den nærmeste tilgjengelige oversettelsen.

locale-chain-ue (C++)
// locale-chain-ue: Smart fallback chains for UE5
// Problem: UE falls back to default when a locale is missing.
// pt-BR user gets English instead of pt-PT translations.

// Solution: One function call at startup.
#include "LocaleChain.h"

void UMyGameInstance::Init()
{
    Super::Init();
    ULocaleChain::Configure();  // Load 75 built-in fallback chains
}

// Now resolve strings with per-key fallback:
FString Greeting = ULocaleChain::Resolve(
    TEXT("greeting"), TEXT("MyNamespace")
);
// pt-BR user: tries pt-BR -> pt-PT -> pt -> default

// Custom overrides:
TMap<FString, FString> Overrides;
Overrides.Add(TEXT("pt-BR"), TEXT("pt"));       // Simplify chain
Overrides.Add(TEXT("sv-FI"), TEXT("sv"));        // Add new chain
ULocaleChain::ConfigureWithOverrides(Overrides);

// Full control (C++ only):
TMap<FString, TArray<FString>> Custom;
Custom.Add(TEXT("pt-BR"), {TEXT("pt-PT"), TEXT("pt")});
Custom.Add(TEXT("es-MX"), {TEXT("es-419"), TEXT("es")});
ULocaleChain::ConfigureCustom(Custom, false);
Kall ULocaleChain::Configure() én gang ved oppstart for å laste inn 75 innebygde fallback-kjeder som dekker 11 språkfamilier. Bruk ConfigureWithOverrides for Blueprint-vennlig tilpasning, eller ConfigureCustom i C++ for full kontroll over fallback-oppførselen.

Automatiser oversettelseskvalitet

Fang opp manglende nøkler og ødelagte plassholdere før de lanseres, med i18n-validate. Test brukergrensesnittet ditt med pseudooversettelser ved hjelp av i18n-pseudo før de virkelige oversettelsene er klare.

Vanlige fallgruver

Bruk av FString for brukervendt tekst

FString omgår hele lokaliseringspipelinen. Tekst bygget med FString::Printf eller strengsammenslåing kan ikke samles inn, oversettes eller vises korrekt i RTL-språk. Bruk alltid FText med LOCTEXT-makroer og FText::Format for strenger som vises til brukeren.

Manglende #undef LOCTEXT_NAMESPACE

Å glemme #undef LOCTEXT_NAMESPACE på slutten av en .cpp-fil fører til at navnerommet lekker inn i påfølgende oversettelsesenheter. Dette fører i det skjulte til at strenger i andre filer får feil navnerom, slik at oversettelser dukker opp i feil kontekst.

Hardkodet flertallslogikk

Å skrive «count == 1 ? entall : flertall» ignorerer CLDR-reglene. Fransk behandler 0 som entall, russisk har 4 flertallsformer, arabisk har 6. Bruk ICU-syntaks for flertallsformer i FText-mønstrene dine, og la UE håndtere reglene per kultur.

Glemte å kompilere etter import

Import av .po-filer oppdaterer tekstdataene, men genererer ikke .locres-binærfiler. Spillet laster fortsatt inn de gamle kompilerte oversettelsene ved kjøretid. Kjør alltid «Compile» i Localization Dashboard etter import, eller legg det til i byggautomatiseringen din.

Anbefalt prosjektstruktur

Project Structure
MyUnrealProject/
├── Config/
│   └── Localization/
│       └── Game.ini                  # Localization target config
├── Content/
│   └── Localization/
│       ├── Game/
│       │   ├── Game.manifest         # Gather manifest
│       │   ├── en/
│       │   │   ├── Game.po           # Source strings (.po)
│       │   │   └── Game.locres       # Compiled binary
│       │   ├── de/
│       │   │   ├── Game.po
│       │   │   └── Game.locres
│       │   ├── ja/
│       │   │   ├── Game.po
│       │   │   └── Game.locres
│       │   └── fr/
│       │       ├── Game.po
│       │       └── Game.locres
│       └── StringTables/
│           ├── ST_MainMenu.uasset    # String Table asset
│           └── ST_HUD.uasset
├── Plugins/
│   └── LocaleChain/                  # locale-chain-ue plugin
│       ├── LocaleChain.uplugin
│       └── Source/
│           └── LocaleChain/
├── Source/
│   └── MyGame/
│       ├── UI/
│       │   ├── MainMenuWidget.h
│       │   └── MainMenuWidget.cpp    # LOCTEXT macros here
│       └── MyGameInstance.cpp        # ULocaleChain::Configure()
└── MyUnrealProject.uproject

Prøv i18n Agent nå

Slipp oversettelsesfilen din her

JSON, YAML, PO, XML, CSV, Markdown, Properties

eller klikk for å bla gjennom

Målspråk

Ingen registrering krevesUmiddelbart estimat

Ofte stilte spørsmål