2D UI Graphics for Games: Icons, Buttons, HUD, and Atlases

Our video game development company runs independent projects, jointly creates games with the client and provides additional operational services. Expertise of our team allows us to cover all gaming platforms and develop an amazing product that matches the customer’s vision and players preferences.

From immersive apps to game worlds and 3D scenes

Our dedicated team for VR/AR/MR development, Unity production and 3D modeling & animation — with its own case studies and capability decks.

Visit the dedicated studio
Showing 1 of 1All 242 services
2D UI Graphics for Games: Icons, Buttons, HUD, and Atlases
Medium
from 2 days to 2 weeks
Frequently Asked Questions

Our competencies

What are the stages of Game Development?

Latest works

  • image_games_mortal_motors_495_0.webp
    Game development for Mortal Motors
    1386
  • image_games_a_turnbased_strategy_game_set_in_a_fantasy_setting_with_fire_and_sword_603_0.webp
    A turn-based strategy game set in a fantasy setting, With Fire and Sword
    926
  • image_games_second_team_604_0.webp
    Game development for the company Second term
    544
  • image_games_phoenix_ii_606_0.webp
    3D animation - teaser for the game Phoenix 2.
    591

In an RPG, a poorly drawn sword icon breaks immersion — the player sees it hundreds of times per session. Low-quality UI kills immersion. Hence, rendering 2D elements for games is an engineering task: fit within the engine's technical constraints, formats, resolutions, and maintain readability on any screen.

Our team has 8+ years of experience in game UI graphics and has completed over 50 projects for mobile, PC, and consoles. Atlas packing reduces draw calls by 10x compared to individual textures — each atlas equals one batch.

Why plan atlases before rendering?

A sprite atlas is the basic tool for packing UI graphics in Unity. All icons and interface elements are packed into one or several atlases to minimize draw calls when rendering the Canvas. One atlas = one batch. If icons are scattered across individual textures, each icon on screen becomes a separate draw call.

This imposes limits on atlas size and quantity: typically 2048×2048 pixels maximum for mobile, 4096×4096 for PC. All UI of one screen goes into one atlas. That means the designer must know in advance: do all inventory icons fit into 2048×2048? At 64×64 pixels per icon — 1024 icons. At 128×128 — 256. Atlas planning starts at the technical specification stage, not after final rendering.

Export formats: PNG without compression for sources; inside Unity, textures are converted depending on the platform. According to Unity documentation, we use ETC2 for Android, ASTC for iOS, and DXT5 for PC. Alpha channel — separate PNG or through RGBA in one file, depending on project settings. Transparency through a separate mask channel sometimes gives better quality under compression.

Format Platform Comment
ETC2 Android Suitable for most devices
ASTC iOS Best quality under compression
DXT5 PC Supports alpha channel

Layers and overrides in Figma are the standard for UI graphics preparation. Each element is a separate component with state variants (normal, hover, pressed, disabled). During final export, all variants are sliced automatically via Figma plugins like Spriter Pro or manually through Assets → Export.

How to ensure icon readability on any background?

An icon must be tested not only on a neutral gray background in Figma. In-game, it appears on an inventory panel background, on a dynamic scene through a semi-transparent HUD, on dark and light theme variants if the game supports multiple color schemes. An icon that reads perfectly on a dark background can get completely lost on a light one.

A standard technique is an outline with a contrasting color. For dark icons — a light outline of 1–2 pixels. For light icons — a dark outline. However, using the standard Outline component in uGUI generates additional mesh copies and works poorly with TextMeshPro. For icons, it's better to bake the outline directly into the texture or use an SDF approach via ShaderGraph: the icon is rendered as an SDF texture, and the outline is added through a shader parameter without modifying the mesh.

Another technique is a drop shadow under the icon. A soft shadow with a 4–6 pixel diameter separates the icon from any background. This is one of the most reliable methods for UI with a dynamic background (when HUD icons are overlaid on the game environment).

Rendering in Figma vs. in-game screen — the difference can be up to 30% contrast loss due to engine post-effects. Our experience shows the best way is to test on the target platform with real camera settings.

What does rendering UI elements include?

Icons — the most labor-intensive type. RPGs often have 200–500+ item icons. Standard pipeline: style guide with 10–20 reference icons → approval → batch rendering following a template. Each batch icon takes 30–60 minutes, a unique "showcase" icon takes 2–4 hours.

Frames and panels — decorative borders for windows, dialogs, inventory. Critical: support for 9-slice (NineSlicedSprite in Unity): the frame must scale correctly without stretching corner decorative elements. When rendering, corners and edges must occupy exactly the pixel count required for the 9-slice rule — this is documented in the delivery materials.

HUD elements — health bar, mana bar, timers, markers. Readability during animation is crucial: a filling health bar must be visible even during fast motion. We test on the actual resolution of the target platform, not on Figma preview.

Buttons and navigation elements — all states (normal/hover/pressed/disabled/focused for gamepad). The focused state is often forgotten when rendering for mobile and remembered only when porting to console.

Case: inventory redesign with 300 icons

From our practice: on one project, we redesigned the item system for an action-RPG — changing the visual style from realistic to stylized. 312 icons, deadline 6 weeks. Solution through templating: developed 8 basic silhouette shapes (sword, shield, bow, potion, armor, accessory, resource, quest item) and a style guide with rules for color application, highlights, and shadows. Each icon was built on a base silhouette with variations in details. This reduced the average rendering time from 45 to 25 minutes while maintaining stylistic unity.

Interaction with programmers and artists

UI graphics are always done in close contact with the programmer who implements the interface. Before starting, we agree on: atlas sizes, file naming conventions (for automatic Sprite Atlas packing), whether multi-resolution support is needed (x1/x2/x3), and the source delivery format.

Changes to element sizes or shapes after implementation has started are costly to fix. Therefore, the final specification document (pixel dimensions, 9-slice rules, color codes) is approved before export, not after.

Work stages for UI graphics

  1. Requirements analysis — determine platforms, style, number of elements.
  2. Style guide creation — 10–20 reference icons.
  3. Element rendering according to the approved pipeline.
  4. In-engine verification — readability test, 9-slice, animations.
  5. Packing into atlases and delivery to the programmer.
Scope Timeline
20–50 icons (batch rendering per style) 1–2 weeks
Full UI kit: buttons, frames, icons (up to 100 elements) 3–5 weeks
200–400 item icons 6–12 weeks
Redesign of existing UI with new style 4–8 weeks

Cost is calculated individually based on the number of elements, uniqueness of each, and quality requirements. We guarantee stylistic unity and readability on any screen. Contact us for a project assessment — we'll find the optimal pipeline for your budget and timeline. Get a consultation on your UI right now.