Game UI Animation Development: Key Techniques and Performance Tips

Creating UI animations for games is not just decoration, but a functional element that guides the player. We integrate animations into the UI as a signaling system: every transition, confirmation, reward, or warning should be readable by the player without reading text. Proper animation reduces cognitive load and speeds up interaction. Bad animation irritates: too slow delays gameplay, too abrupt goes unnoticed. Our engineers have 10+ years of experience in game development with Unity and Unreal, and we guarantee every animation passes a performance check. Contact us to get an animation prototype in 2 days.

UI Animation Creation: Tool Selection

Animator + Animation Clips – classic under Unity. Works via Animator Controller on a Canvas object. Pros: visibility in the editor, support for Blend Trees, easy control via SetTrigger/SetBool. Cons: difficult to animate to dynamic positions. Suitable for fixed transitions: open/close screen, pulse effect on button.

DOTween – de facto standard for code-driven UI animations. RectTransform.DOAnchorPos(), CanvasGroup.DOFade(), Image.DOColor() via fluent API with sequencing. DOTween.Sequence() with .Append(), .Join(), .InsertCallback() builds complex coordinated animations. Important: when Time.timeScale = 0 animations stop – use SetUpdate(UpdateType.Normal, true) for ignoreTimeScale.

UI Toolkit Transitions – CSS-like transitions: transition-property: translate; transition-duration: 300ms;. The most declarative, but limited to transforms, opacity, and color. Ideal for hover effects and simple states.

Why Easing and Timing Matter

Duration ranges that work:

• Micro-feedback (hover, press): 80–120 ms
• Appearance/disappearance of small element: 150–200 ms
• Screen transition: 250–350 ms
• Rewards and fanfare animations: 600–1200 ms

Anything over 400 ms for utilitarian transitions irritates on repeated openings. Player opens inventory a hundred times per session – 600 ms transition = a minute of wasted waiting.

Easing functions are not symmetric: Ease Out (fast start, slow end) – for appearing elements; Ease In (slow start, fast end) – for disappearing; Ease In/Out – for state transitions. Linear easing is almost never needed – looks mechanical.

Overshoot and spring – when physics is justified. Ease.OutBack (strength 1.5–2.0) works great for pop-up notifications: element "jumps" beyond bounds and returns. Ease.OutElastic – for energetic rewards. But on fullscreen panels overshoot looks unnatural – use only for compact elements.

Case Study from Our Practice: Item Obtained Notification

On a client's project, we needed an animation for an item obtained notification. Implementation via DOTween Sequence:

• Icon flies in from bottom with Ease.OutBack over 200 ms
• Simultaneously (+Join) fade CanvasGroup.alpha from 0 to 1
• After 200 ms, text appears via DOFade over 150 ms (+AppendInterval)
• Hold for 2 s, then disappear: slide right + fade over 200 ms with Ease.InCubic

The entire sequence – 15 lines of code, reused through NotificationController.Show(item). Solved the queue problem: when quickly obtaining multiple items, the new notification displaces the old via DOTween.Kill(targetTransform).

How Animations Affect FPS

Animations in Canvas can cause Canvas Rebuild when changing position, size, or opacity. CanvasGroup.alpha does not trigger Rebuild, but changing RectTransform.position does. Animate via DOAnchorPos (local space) instead of DOMove. For scale animations, use transform.DOScale() – scale does not affect Layout, it's the cheapest type. Split animated elements into separate Canvases: if an icon blinks, its Rebuild should not rebuild the entire HUD.

What to Choose for Complex Sequences

Comparison between DOTween and Animator for multi-step animations: DOTween wins in flexibility – 3 times faster implementation (code-based), but Animator provides better visibility in editor. If sequence is fixed (e.g., shop open animation), Animator is simpler. If dynamic (depends on battle data), DOTween is more efficient.

State Animation for Buttons: Nuances

The standard Button with ColorTween is limited. Use UIAnimation on DOTween or IPointerEnter/Exit/Down handlers. Scale animation on press (scale 0.95 over 80 ms, Ease.OutQuad) – simple and effective tactile feedback for mobile platforms.

How to Implement a Notification Animation Queue Step by Step

1. On receiving a new notification, check if a tween is active. If yes, call DOTween.Kill(targetTransform) on it.
2. Create a new Sequence with desired animations (appear, hold, disappear).
3. Start the sequence via sequence.Play().
4. To prevent accumulation, set a flag that animation is busy, and reset it on completion.

This approach ensures smooth displacement of old notifications and maintains performance even under frequent calls.

What Our Work Includes

• Animation prototype on a separate Canvas
• Integration into existing Unity/Unreal project
• Performance optimization (minimizing Canvas Rebuild)
• Documentation on playback and configuration
• Post-implementation support

Cost is calculated individually after requirements analysis. We will evaluate your project and propose the optimal solution. Order turnkey UI animation development or contact us for a consultation.

More about Canvas Rebuild: Unity Manual - Canvas

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.