Backbone Localization

Introduction

When we develop a game, we often focus on graphics, mechanics, or sound. But if we want people from different countries to play it, we need something more: they need to understand it.

Localization means adapting your game to different languages — from UI text to menus, images, audio, or even materials. It's not just about translation — it’s about giving each player a native experience, no matter what language they speak.

A game without localization has an invisible wall: it might be great, but many players will never get to enjoy it.

Welcome to the Backbone Localization Manual. This guide will walk you through all features, workflows, and best practices for localizing your Unity project using Backbone.

What is Backbone Localization

Backbone Localization is a modular system designed to make localizing your game in Unity easy, fast, and scalable. It supports localized strings, sprites, textures, audio clips, and even materials — all fully editable directly from the Unity Inspector.

It allows you to assign values per language using components attached to GameObjects, or manage content centrally using localization keys. You can also import and export data using CSV files, making it ideal for both designers and developers.

The system supports three main workflows:

You can also combine these workflows freely, adapting the system to your specific needs. Whether you're building a small indie title or a large commercial project, Backbone adapts to your workflow, helping you deliver a native experience to every player.

Key Benefits

Backbone Localization is more than just a localization tool — it’s a flexible, production-ready solution designed to make your workflow smoother, your content more accessible, and your team more efficient. Whether you're working solo or coordinating a large team, this system gives you everything you need to localize your game with confidence and control.

Here’s why developers love it:

Unity Version Compatibility

Compatible with Unity 2020.3 LTS and newer. Supports Built-in, URP, and HDRP pipelines.

Installation & Initial Setup

To install Backbone – Localization from the Asset Store:

Intro image
  1. Open your Unity project.
  2. Go to the Asset Store tab or open Unity Asset Store in your browser.
  3. Search for “Backbone – Localization” and click Download (if you’ve already purchased it) or Buy.
  4. Once downloaded, click Import in Unity. Unity will display a list of files included in the package.
  5. Confirm by clicking Import again to bring all necessary assets, scripts, and editor tools into your project.
Intro image

Once imported, you’ll find the system under a folder named Assets/Backbone/Localization. All scripts, resources, and editor tools are organized for easy access.

Defining Available Languages

When you install the asset, a default configuration file is automatically created at Assets/Backbone/Localization/Resources/LocalizationConfig.asset

This file contains the list of languages available in your project and serves as the central configuration point for the entire localization system.

What if I delete it?

If the LocalizationConfig.asset file is accidentally deleted, you can easily create a new one. Simply right-click on the Resources folder and select Create → Localization → LocalizationConfig.

Intro image

This will regenerate the configuration file so you can continue working without issues.

How to define the languages

To define the languages you want to support:

  1. Select the LocalizationConfig.asset file in the Project window.
  2. In the Inspector, you’ll see a list of languages.
  3. Use the [+] button to Add Language.
  4. Use the [-] button to Remove existing one.
Intro image

You can add as many languages as you need. Each one is represented by a string, which can be a code (e.g., en, es, fr-FR) or a name (e.g., English, Spanish, French). Keep in mind that this string will be used later to select the language in scripts or settings, so choose names that are clear and representative.

The first language in the list will be treated as the default language. This means:

You can reorder the list to change which language is used as default. Simply drag the language entry, move it to the desired position, and drop it — the first language in the list will be treated as the default for the system.

And that’s it — no more setup needed. You’re now ready to start localizing your game.

Add a LocalizationManager to Each Scene

To ensure the localization system works properly at runtime, you must add a LocalizationManager to every scene that uses localized content.

How to do it:

  1. In the Hierarchy, right-click and select Create Empty.
  2. Rename the GameObject to something like LocalizationManager.
  3. Click Add Component and select LocalizationManager.

This component is responsible for:

Left panel Right panel

You only need one LocalizationManager per scene. If it's missing, localized content may not update correctly at runtime.

Real-Time Language Switching

Backbone – Localization allows you to switch languages at runtime easily. You can trigger the change either via code (for full control) or directly from the Unity Editor using a UI Button’s OnClick() action — no extra scripts required.

When the language changes, the system automatically:

Option 1: Call from Code

Use this if you want to change the language from a script, based on custom logic or events, for example:

Intro image 
LocalizationManager.Instance.SetLanguage("es");

The string must match the identifier defined in your LocalizationConfig (e.g., "en", "es", "fr-FR", "English", "Spanish").

Option 2: Use Unity’s OnClick() in the Editor

You can also trigger a language change from a UI Button without writing any code.

Steps:

  1. Select the button in the Hierarchy.
  2. In the OnClick() section, click the “+” button.
  3. Drag the GameObject with the LocalizationManager into the object field.
  4. From the dropdown, select:
    LocalizationManager → SetLanguage(string)
  5. Enter the language string in the text field (e.g., es, en, ja).
Intro image

Whether you choose the script-based approach or the visual one, Backbone makes language switching instant, clean, and fully automatic.

Mode 1: Quick Setup with Components

This is the fastest and most visual way to localize your content — no coding, no manual lists, just drag, drop, and assign directly in the Unity Inspector.

Ideal for:

How It Works

You simply add a localization component to any GameObject that contains localizable content. Then, in the Inspector, assign the values for each language directly.

The number of languages shown in the component depends on your LocalizationConfig. You can add or remove languages at any time, and all components will automatically update to reflect the current list.

The system will:

Intro image

This makes it easy to work visually: what you see in the Inspector always matches the languages you’ve defined — no extra steps needed.

NOTE: Text component fully supports Unicode characters, meaning you can safely use foreign scripts like Japanese, Russian, Chinese, Arabic, or any other — the values will display correctly both in the Editor and in-game.

Available Components

These components are ready to use and can be added directly from the Add Component menu in the Unity Editor:

Intro image

Each component will automatically show the list of languages you've defined, with an input field for each one. Simply assign the value you want for each language, and the system will handle the rest.

How to Add and Configure

How to Add and Configure a Component: Step-by-step guide

In this section, we’ll walk through a step-by-step guide to localize a UI Text element, using the LocalizedText component as an example.

Adding localized content to your GameObjects is quick and intuitive. Here’s how you can do it entirely from the Unity Editor — no coding required.

Left panel Right panel
  1. Select the GameObject that contains the content you want to localize (in this case a UI Text component).
  2. In the Inspector, click Add Component, and search for and select the appropriate localization component — in this case, LocalizedText.
  3. Once added, the component will automatically display one field for each language defined in your LocalizationConfig.
  4. Enter the localized values directly in the Inspector.

Mode 2: Key-Based Lists

This workflow is ideal for teams, scalable pipelines, or projects where localization is handled externally (e.g., by translators or localization managers).

Instead of assigning localized values directly in each GameObject, you define a set of localization keys in central lists. These keys are then referenced by components or scripts throughout your project.

This method improves consistency, reuse, and collaboration — especially in large games with a lot of content.

Introduction to Key-Based Localization

A localization key is a unique identifier (usually a short string like main_menu.play or dialog.intro_01) that represents a specific piece of content. Instead of writing the actual text or selecting the image/audio in every place it’s used, you just reference the key.

Each key maps to a set of values — one per language.

Advantages of This Approach

List Editor

Backbone – Localization provides a set of specialized editors to manage your localized content in centralized, structured lists. Each list type is tailored to a specific kind of data and is fully compatible with CSV import/export.

You can find four main types of data lists:

Each of these lists can be created via:
Right-click in the Project → Create → Localization → [List Type]

All list editors share the same features:

  1. Search bar to filter entries by key
  2. Expand/Collapse All to navigate large datasets
  3. Multiline field support (for text content)
  4. Import/Export to CSV for batch work
  5. One field per language, based on your LocalizationConfig

As you add entries, the editor automatically groups them by prefix. For example, keys like Menu.Start, Menu.Options, and Menu.Quit will be grouped under "Menu", improving readability and organization.

Grouping is purely visual and doesn’t affect the keys at runtime.

These tools are designed to scale. Whether you’re managing a few UI labels or hundreds of dialogue lines, the experience remains smooth and organized.

LocalizedStringsData

Use this list to manage localized text strings.

Intro image

Each entry consists of:

You can enable multiline editing for your entries using the checkbox labeled “Multiline fields” at the top of the editor. This is especially useful for:

LocalizedAudioClipsData

Use this list to localize AudioClip references. Each entry allows you to assign a different clip per language.

Intro image

Example use cases:

Each field accepts any AudioClip in your project.

LocalizedSpritesData

Use this list to localize 2D sprites, such as:

Intro image

Just enter a key and assign one Sprite per language. These will be loaded and applied automatically at runtime.

LocalizedTexturesData

Use this list for 3D textures, especially in:

Intro image

Each field allows assigning a different Texture per language, enabling visual localization at the material level.

Using Keys with Localization Components

When working with key-based lists, the automatic localization components (LocalizedText, LocalizedTMP_Text, LocalizedAudio, LocalizedImage, etc.) continue to work exactly as before — the only difference is that you now provide a key instead of entering the localized value directly.

This makes switching from direct values to key-based localization effortless — just assign the key and you’re done.

Special case: LocalizedText and LocalizedTMP_Text

These two components don’t have a dedicated Key field. Instead, you enter the key name in the first language field (usually under "English").

The system will detect that you’re using keys instead of direct values, and resolve the localized content from the list accordingly.

This hybrid approach gives you flexibility: use direct values for small elements, or keys for shared or dynamic content — even mix both within the same project.

Organize Your Lists However You Like

You’re free to create as many lists of each type as you need. For example, you might have:

In each scene, you assign the relevant lists directly in the LocalizationManager component. Just drag and drop the list assets into the appropriate fields:

Intro image

This gives you full control over what content is loaded in each scene, allowing for better memory usage and clean project structure. Whether your project is small or massive, this flexible system adapts to your needs.

This highly flexible setup adapts to any kind of project — from small mobile games to large-scale multi-scene productions.

Importing & Exporting CSV Files

One of the most powerful features of Backbone Localization is the ability to export and import all localization lists via CSV. This is ideal for collaborating with translators, content teams, or managing large-scale projects.

Exporting a CSV

All list types can be exported:

To export:

  1. Select the list asset (e.g., UIText.asset).
  2. Click Export to CSV in the Inspector.
  3. Choose the location and filename.

The resulting file will contain:

This allows teams to work on translations or file assignments in parallel, using familiar spreadsheet tools like Excel or Google Sheets.

Importing from CSV

To import:

  1. Select the target list asset.
  2. Click Import from CSV.
  3. Select the file containing the updates.

The system will:

For asset-based lists: ensure that the file paths specified in the CSV match actual asset locations in your project. The system will try to resolve them automatically on import.

Why This Matters

You have full control: structure your data how you want, name assets consistently, and maintain a clean workflow across large teams or multilingual projects.

Mode 3: Full API Control via Code

For developers who need precise and dynamic control over localization, Backbone – Localization provides a clean and extensible API that allows you to access localized content directly from code.

This mode is ideal for:

The central entry point is the LocalizationManager class, which acts as a singleton and provides access to all localized data based on keys.

Accessing Localized Strings

To retrieve a string by key:

string value = LocalizationManager.Instance.GetLocalizedString("Menu.Start");

Or, to do it safely:

if (LocalizationManager.Instance.TryGetLocalizedString("Menu.Start", out string value)) {
		// use value
	}

Accessing Localized Sprites

To retrieve a sprite by key:

Sprite icon = LocalizationManager.Instance.GetLocalizedSprite("Icons.Play");

With a safety check:

if (LocalizationManager.Instance.TryGetLocalizedSprite("Icons.Play", out Sprite icon)) {
		// use icon
	}

Accessing Localized Textures

To retrieve a texture by key:

Texture tex = LocalizationManager.Instance.GetLocalizedTexture("UI.Background");

Or safely:

if (LocalizationManager.Instance.TryGetLocalizedTexture("UI.Background", out Texture tex)) {
		// use tex
	}

Accessing Localized AudioClips

To retrieve an audio clip by key:

AudioClip clip = LocalizationManager.Instance.GetLocalizedAudioClip("VO.Intro");

Or safely:

if (LocalizationManager.Instance.TryGetLocalizedAudioClip("VO.Intro", out AudioClip clip)) {
		// use clip
	}

Summary of Available API Methods

This API gives you full control over how, when, and where you load and apply localized content. It's perfect for advanced runtime behaviors and logic-driven UI.

Full API Documentation

Everything you need to use the API is already explained here. The full technical reference is only for advanced users who want to deeply customize the asset's behavior.

→ View full API documentation (advanced use only)

Conclusion & Support

Backbone – Localization was built with one clear goal: make localization in Unity effortless, scalable, and powerful — without forcing you into a rigid workflow.

Whether you're a solo developer working directly in the Inspector, or part of a larger team managing multilingual assets and translations via CSV, Backbone adapts to your needs.

From UI text to images, audio clips and even materials — all in one consistent, flexible system.

A localized game is a game without borders. With Backbone, that boundary disappears.

For help or questions, please contact at:

Zoomed image