Localizing Game Interfaces and Text Blocks

German compound words break out of dialog windows? Arabic text flows left to right, breaking the layout? These are not translation bugs—they are technical localization problems. Localization is systematic work with text, fonts, formatting, inflection rules, and UI sizing for each language. A game that is "translated" but not localized looks like machine translation: text overflows buttons, numbers display without locale awareness, and RTL strings don't mirror.

Our team has over 10 years of experience in game development. We have built pipelines for projects with 15 languages, including Arabic, Hebrew, and Chinese. We use Unity Localization—the standard for Unity projects. It works through StringTable (text strings with keys) and AssetTable (localized assets). Tables are exported to XLIFF or CSV for translators.

The key principle: in code and prefabs—only keys, no hardcoded strings. The LocalizedString component on TextMeshProUGUI is mandatory architecture. Violating this means manually searching all text strings across scenes—hundreds of objects when adding a new language.

How Technical Localization Works

Technical localization starts with auditing: we check code for hardcoded strings and UI for inflexible layouts. Then we configure StringTable/AssetTable and link keys to elements. We export to XLIFF for translators, import back with verification. After that—pseudolocalization and testing. For CJK languages we attach Dynamic Font Asset, for RTL—UI mirroring.

Why Pseudolocalization Is Indispensable

Before receiving real translations, we run pseudolocalization: lengthen all strings by 30–40% and add random characters. This reveals container overflow in 2–3 days instead of discovering it during translation integration. Without pseudolocalization, you risk encountering bugs two weeks before release. Comparison: pseudolocalization is 3 times more effective at detecting overflow issues before strings are sent to translators, whereas real translations only catch them after import.

What Is Dynamic Font Asset and Why Do You Need It?

For Chinese, Japanese, and Korean, static font atlases weigh 15–30 MB. Dynamic Font Asset loads only glyphs encountered in text, reducing memory to a few hundred kilobytes. The downside is micro-stutters (0.5–2 ms) when first rendering a new glyph, but this is acceptable for mobile projects.

For Arabic and Hebrew, RTL support is mandatory. TextMeshPro has a built-in RTL mode (TMP_Text.isRightToLeftText = true), but one flag is not enough. UI elements must also mirror: the "Back" button moves from left to right, lists read from right to left. This requires special logic in Layout Manager or switchable prefabs with mirrored layout for RTL languages.

From our practice: on a project with Russian, English, and German, we encountered that German compound words (e.g., Geschwindigkeitsbegrenzung) do not hyphenate in TextMeshPro by default. Solution—Hyphenation via TMP_Settings + connecting a hyphenation dictionary for German. After configuration, text wraps correctly, the dialog container no longer overflows.

Estimated Timelines

What Our Work Includes

We provide a full localization cycle turnkey:

• Audit of current code and UI for localization readiness.
• Setup of Unity Localization pipeline (or equivalent for Unreal Engine).
• Creation of StringTable/AssetTable, integration with CAT tools.
• Development of Dynamic Font Asset for CJK and RTL languages.
• Pseudolocalization and UI overflow testing.
• Automation of translation import/export.
• Documentation on localization maintenance for the team.

Contact us for an audit of your project—we will find the optimal solution. Get a consultation from a localization engineer to avoid typical mistakes and reduce time to market for new regions.

Prototyping and UX/UI for Games: Architecture, Performance, Localization

You open someone else's Unity project — and see: one Canvas for the whole game, hundreds of nested panels, Layout Groups inside Layout Groups, the profiler showing 4 ms just for UI recalc every frame. This is not uncommon. With over 10 years of experience, we've analyzed hundreds of UI systems — almost all suffered from a lack of architecture from the start. As a result, by mid-development, UI becomes a bottleneck: each new screen introduces bugs, performance drops, and fixes take hours. We design and implement game UI: from wireframes to ready engine components, with a focus on performance and maintainability. Our game interface prototyping approach identifies 80% of UX issues before writing code. Contact us for a consultation — we'll evaluate your project.

Prototyping and Design

Any UI begins with understanding information flows: what the player should see at each moment, what actions are available, how to navigate between screens. Without this, development turns into a series of "made — wrong — redo" iterations. Our prototyping tool is Figma. The choice is not about trends but specific capabilities:

• Component system with variants — test button states (Normal/Hover/Pressed/Disabled)
• Auto Layout — honest simulation of UI behavior under different text sizes (critical for multilingual games)
• Prototypes with transitions — test navigation flow before the first line of code

At the prototype stage, most UX problems are uncovered: non-obvious transitions, overloaded screens, incorrect information hierarchy. Fixing them in Figma takes 15 minutes. Fixing them in a finished project takes half a day. We ensure that each prototype is accompanied by a technical specification for developers — this eliminates ambiguity when transferring to the engine.

uGUI vs UI Toolkit: What to Choose for a New Project

Unity currently has two UI frameworks, and the choice between them is not obvious. uGUI (Canvas-based) is a mature system, present since early versions of Unity. It works with RectTransform and has a rich asset ecosystem. Virtually all existing game UI is built on uGUI.

UI Toolkit is a system based on XML (UXML) and CSS-like styles (USS). Originally created for editor tools, it has been officially supported for runtime UI since Unity 2021. Architecturally, it's closer to web development.

UI Toolkit is suitable for the following scenarios:

• New project, team ready to learn
• Need a complex theme and skin system
• Actively developing custom editor tools

uGUI remains preferable if:

• Supporting an existing project
• Need maximum compatibility with Asset Store assets
• Team already knows uGUI, tight deadlines

How to Achieve Performant UI in Unity?

This is where game UI differs drastically from UI in regular applications. In games, UI updates every frame, and an inefficient implementation can eat 3–5 ms from the frame budget — directly impacting FPS.

How Batching Works in Canvas

Unity combines elements of the same Canvas into a single draw call if they use the same material and texture atlas. Breaking the batch means an additional draw call, which hurts performance.

Batching is broken by:

• Different textures on adjacent elements (solution: sprite atlas via Sprite Atlas)
• Mask component creates a stencil and breaks the batch (alternative: RectMask2D — cheaper)
• Canvases with different Render Modes — batching works only within one Canvas
• Any Graphic Raycaster adds overhead — place it only on interactive Canvases

Splitting Canvas by Content Type

The main recommendation: separate static and dynamic content. When any element in a Canvas changes, Unity rebuilds the geometry of the entire Canvas. If a static HUD frame and an animated health bar live on the same Canvas, the Canvas rebuilds fully every second. This can reduce FPS by 15–20%.

Correct structure:

Canvas (Screen Space - Overlay)
├── Canvas_Static     — backgrounds, frames, icons without animation
├── Canvas_Dynamic    — HP bars, timers, resource counters
└── Canvas_Popup      — modal windows, notifications

Each child Canvas isolates rebuild from the parent. Changes in Canvas_Dynamic do not affect Canvas_Static.

Step-by-step setup for separate Canvases:

1. Create a root Canvas with Render Mode = Screen Space Overlay
2. Inside, create empty GameObjects, each with a Canvas component
3. Name them Static, Dynamic, Popup
4. Move existing UI elements into the appropriate groups
5. Ensure the Canvas Scaler component is set only on the root Canvas (children inherit settings)

Result: up to 60% reduction in UI repaint time in scenes with dynamic HUDs.

TextMeshPro and Text Batching

TextMeshPro is the standard for text in Unity. Unlike the old Text, it uses SDF rendering — text remains crisp at any scale. However, TMP has a nuance: each unique font atlas is a separate material, i.e., a separate draw call. If the game uses three font variants (main, heading, numbers) plus versions for each language, text batching breaks. Solution: TMP Font Asset Creator with glyph merging for needed languages into one atlas. For Cyrillic + Latin + digits, one 2048×2048 atlas usually suffices — reducing text draw calls to 1-2.

How to Adapt UI for Different Screens?

Mobile platforms add a challenge absent on PC: UI must work correctly on 16:9, 18:9, 19.5:9, 4:3, and iPad ratios simultaneously. Adaptation errors are a common cause of rework, consuming up to 30% of the budget.

Tools:

• Canvas Scaler with Scale With Screen Size mode — basic setup. Reference Resolution 1080×1920 for mobile, Match parameter 0.5 (balance between width and height)
• Anchor Presets — each element must be anchored to the correct edge or center
• Safe Area — on devices with notches and rounded corners, buttons must not fall into the inaccessible zone. Solution: Screen.safeArea in code, adjusts the RectTransform of the root element

Testing should be done not only in the Game View — physical testing on devices or using the Device Simulator (built into Unity) is necessary. Order a UI audit — we'll identify bottlenecks in 2-3 days.

UI Localization

This is not a separate task but a requirement from day one. A typical problem: UI designed for Russian text occupying N characters. The German translation is one and a half times longer. Buttons break, text overflows. At the design stage, we perform:

• All text fields with Auto Size in TMP or explicitly set min/max sizes
• Buttons with Horizontal Layout Group + Content Size Fitter instead of fixed width
• Icons and decorative elements are not concatenated into text strings

For implementation, we use the Unity Localization Package (official) or I2 Localization (asset, more flexible for complex cases). Time savings on rework with this approach — up to 40%.

What's Included

• Navigation structure and screen flow design
• Game interface prototyping in Figma with handoff to development
• Implementation of UI components in Unity (uGUI or UI Toolkit)
• Performance audit of existing UI: draw calls, Canvas rebatch, excess Raycasters
• Localization system setup and testing with long translations
• Adaptation for mobile aspect ratios and Safe Area

Timeline: from 5 working days for an audit to 4 weeks for a full cycle. Pricing is calculated individually — contact us for a commercial proposal. Over 10 years in game development, more than 200 projects delivered guarantee results.