SkillAgentSearch skills...

game-ui-ux

Engine-neutral design rules for game HUDs and menus: anchors and containers, scaling, safe areas, gamepad focus, HUDs driven by events instead of polling, and accessibility minimums. Use for menus, health bars or inventory screens that break on ultrawide or phones.

Install / Use

npx skills add gamedev-skills/awesome-gamedev-agent-skills --skill game-ui-ux

Installs into whichever agent you are using.

About this skill
πŸ“„

SKILL.md

Installable skill definition

Quality Score

95/100

Category

Operations

Supported Platforms

Universal

Our assessment of game-ui-ux

game-ui-ux scores 95/100 on our quality scale, 71st of 746 Operations skills we index (top 10%).

Its SKILL.md is 8.2 KB long, well organised into 31 sections with 5 code examples: a thorough specification that gives an agent plenty to work with.

With 8,904 GitHub stars, it is one of the more widely adopted skills in the catalogue.

Substance
29/30
Structure
20/20
Description
15/15
Adoption
17/20
Freshness
15/15

Maintenance, license and trust

  • The repository was last updated 4 days ago, so game-ui-ux is actively maintained.
  • Our last check on 2026-11-15 found the source still online.
  • It is released under the Apache-2.0 license, a permissive license that allows use, modification and commercial use with attribution.
  • Its trust signals score 100/100, with no cautions. These come from repository metadata, not a code audit β€” read the skill file before letting an agent act on it.

Safety scan

No issues found

Our scan of the whole file found no instruction hijacking, hidden characters, credential access, data exfiltration or destructive commands. An AI review of the same text found nothing harmful.

AI review by kimi-k2.7-code on 2026-10-04. Automated pattern scan on 2026-10-04. It catches known dangerous patterns, not every risk β€” read a skill before letting an agent act on it.

game-ui-ux compared with similar skills

All 4 of these similar skills score higher than game-ui-ux; compare them before choosing.

SkillScoreStarsUpdatedFormat
game-ui-ux (this skill)by gamedev-skills958.9k4d agoSKILL.md
taste-skillby Leonxlnx100116.8k8d agoCLAUDE.md
Claude-Code-Game-Studiosby Donchitos10039.7k7d agoCLAUDE.md
x402by browser-use100121.0k3d agoSKILL.md
algorithmic-artby anthropics100177.9k55d agoSKILL.md

Frequently asked questions

How do I install game-ui-ux?
Run npx skills add gamedev-skills/awesome-gamedev-agent-skills --skill game-ui-ux. The install tabs above show the steps for each supported agent.
Which AI agents does game-ui-ux work with?
It is written for Universal, as a SKILL.md file. Other agents that read the same format can often use it too.
Is game-ui-ux safe to use?
Our scan of the whole file found no instruction hijacking, hidden characters, credential access, data exfiltration or destructive commands. An AI review of the same text found nothing harmful. It is Apache-2.0-licensed and scores 100/100 on trust signals. Skills are instructions an agent will follow, so read the file before installing it and do not approve commands you do not understand.
Is game-ui-ux still maintained?
The repository was last updated 4 days ago, so game-ui-ux is actively maintained.

name: game-ui-ux description: > Design and build game UI/UX β€” HUDs, menus, and overlays β€” that survive every screen: anchor- based responsive layout, resolution/aspect scaling and safe areas, keyboard/gamepad focus navigation, a screen/menu state stack, and event-driven (not polled) HUD updates. Engine- neutral patterns that pair with the detected engine's UI skill. Use when the user mentions HUD, health bar, main menu, pause menu, settings screen, UI layout, anchors, UI scaling, aspect ratio, safe area, controller/keyboard menu navigation, or wiring UI to game state.

Game UI/UX

Build HUDs and menus that stay correct on a phone, an ultrawide monitor, and a TV across a gamepad and a mouse. This skill owns the engine-neutral UI architecture β€” responsive layout, scaling, focus navigation, screen flow, and how UI talks to game state β€” and defers the concrete widget API to the engine UI skill.

When to use

  • Use when building a HUD (health/ammo/score), a menu (main/pause/settings), an inventory or shop screen, or any overlay, and you want it to scale and navigate correctly.
  • Use to fix UI that breaks at other resolutions/aspect ratios, ignores notches/safe areas, can't be used with a controller, or is wired to game state by per-frame polling.
  • Use to structure screen flow (title β†’ game β†’ pause β†’ settings) as a stack, not flag soup.

When not to use: for the engine's concrete UI nodes/components and styling, use godot-ui-control or Unity UI (UGUI/UI Toolkit). For visual punch (button pop, damage numbers, shake) use game-feel. For branching conversation UI use dialogue-systems. For translating UI strings, that is localization (see references/ and input-systems for rebinding screens). For card/board layout specifics, the card-game genre composes this skill.

Core workflow

  1. Pick a layout model: anchors + containers, never absolute pixels. Anchor elements to edges/corners/center and let containers (rows, columns, grids) flow children. Absolute (x, y) positions break at the first new resolution.
  2. Choose a scaling strategy for the whole UI: a reference resolution that scales to fit (most games), plus a policy for extra width/height on other aspect ratios (letterbox, expand, or anchor HUD corners outward).
  3. Respect the safe area. Inset critical UI from screen edges so notches, rounded corners, and TV overscan don't clip it.
  4. Make every screen keyboard/gamepad navigable. Set an initial focused control per screen, define focus order/neighbors, and show a clear focus highlight. Mouse and focus must coexist.
  5. Model screens as a stack. Push (pause over game), pop (resume), with input + visibility handed to the top screen. This makes overlays and "back" trivial.
  6. Drive the HUD from events, not polling. The HUD subscribes to health_changed, score_changed, etc. and updates only when they fire β€” it does not read game state every frame.
  7. Verify across screens and devices. Resize the window, switch aspect ratios, unplug the mouse and navigate by gamepad only, and confirm focus, scaling, and safe-area insets. Report what you actually observed at which resolutions.

Patterns

1. Anchors + containers, not absolute coordinates

# Godot 4.7. Anchor a HUD label to the TOP-LEFT; let a container flow a row of hearts.
func _ready() -> void:
    $Score.set_anchors_preset(Control.PRESET_TOP_LEFT)   # sticks to the corner at any size
    # An HBoxContainer auto-lays-out children left-to-right; never position hearts by hand.
    for i in lives:
        $Hearts.add_child(make_heart())                   # HBoxContainer spaces them for you
# Unity 6.3 LTS uGUI: set RectTransform anchors to the corner; use a HorizontalLayoutGroup.
# RIGHT: anchors + layout groups. WRONG: rect.anchoredPosition = new Vector2(640, 360) (1080p-only).

2. Scale to a reference resolution (one UI, many screens)

# Godot 4.7 β€” Project Settings > Display > Window > Stretch:
#   Mode = "canvas_items", Aspect = "expand", reference size e.g. 1920x1080.
#   UI scales to the window; "expand" reveals extra space you anchor HUD corners into.
# Unity 6.3 LTS β€” Canvas > CanvasScaler:
#   UI Scale Mode = "Scale With Screen Size", Reference Resolution = 1920x1080,
#   Match = 0.5 (blend width/height) β€” pick 1.0 if your HUD is height-critical.

3. Safe-area inset for notches / overscan

# Godot 4.7. Inset a margin container to the OS-reported safe rect (phones, TVs).
func _apply_safe_area() -> void:
    var safe: Rect2i = DisplayServer.get_display_safe_area()
    var win := DisplayServer.window_get_size()
    $Margin.add_theme_constant_override("margin_left", safe.position.x)
    $Margin.add_theme_constant_override("margin_top",  safe.position.y)
    $Margin.add_theme_constant_override("margin_right", win.x - safe.end.x)
    $Margin.add_theme_constant_override("margin_bottom", win.y - safe.end.y)
# Unity 6.3 LTS: read Screen.safeArea (Rect in pixels) and set a panel's anchorMin/anchorMax to
# safeArea.position / (position+size) normalized by Screen.width/height.

4. Gamepad/keyboard focus (UI is unusable on a controller without it)

# Godot 4.7. Give each screen a default focus and wire neighbors so a stick/d-pad walks it.
func _on_screen_shown() -> void:
    $PlayButton.grab_focus()                               # always focus SOMETHING on open
$PlayButton.focus_neighbor_bottom = $SettingsButton.get_path()
$SettingsButton.focus_neighbor_top = $PlayButton.get_path()
# Unity 6.3 LTS: EventSystem.SetSelectedGameObject(playButton) on enable; set each Selectable's
# Navigation (Explicit or Automatic). RIGHT: a control is focused on open. WRONG: nothing
# selected β†’ the gamepad does nothing and the player is stuck.

5. Event-driven HUD (decouple UI from game logic)

# RIGHT: HUD reacts to a signal; it updates only when health actually changes.
func _ready() -> void:
    player.health_changed.connect(_on_health_changed)     # emitted by gameplay
func _on_health_changed(current: int, max: int) -> void:
    $HealthBar.value = float(current) / max
# WRONG: func _process(dt): $HealthBar.value = player.hp / player.max_hp  # polls every frame,
# couples UI to the player's internals, and runs work even when nothing changed.

Pitfalls

  • Absolute pixel positions / a single design resolution. Looks right on your monitor, broken everywhere else. Anchor to edges/center and flow with containers.
  • No aspect-ratio policy. 16:9-only layouts crop or letterbox badly on ultrawide and phones. Decide expand vs letterbox and anchor HUD to corners that move outward.
  • Ignoring the safe area. HUD under a notch or lost to TV overscan. Inset critical elements.
  • No initial focus / no focus neighbors. The game is unplayable on a gamepad; players land on a menu with nothing selected. Always focus one control and define navigation.
  • Polling game state in _process/Update. Couples UI to internals and wastes work. Push updates via signals/events.
  • Tiny fixed font sizes. Unreadable on a TV-at-distance or a small phone. Scale text with the UI and offer a text-size option.
  • Menu flow as boolean flags (isPaused, inSettings, …) becomes unmanageable. Use a screen stack with push/pop.
  • Hardcoded English strings baked into layout. Translations overflow buttons. Externalize strings and let containers size to content (see references/).
  • Mouse-only or focus-only. Support both; switching input device should not strand the user.

References

  • For stretch/scale modes per engine, the safe-area math, a complete focus-navigation and screen-stack pattern, diegetic vs non-diegetic UI, accessibility (text size, contrast, colorblind-safe state), and localization-ready layout, read references/layout-and-flow.md.

Related skills

  • godot-ui-control, Unity UI (UGUI/UI Toolkit) β€” the concrete widgets, themes, and styling.
  • game-feel β€” button pops, transitions, and HUD juice that ride on top of this layout.
  • dialogue-systems β€” conversation/choice UI that lives inside this UI shell.
  • input-systems β€” device switching, rebinding screens, and accessible controls.
  • rpg, card-game, tower-defense, visual-novel β€” UI-heavy genres that compose this skill.

Related Skills

View on GitHub
GitHub Stars8.9k
CategoryOperations
Updated4d ago
Forks905

Languages

Python

Trust signals

100/100

From repository metadata: license, adoption, age and documentation. Not a code audit β€” see the Safety scan above for what the skill file itself contains.

No cautions
game-ui-ux β€” Universal Skill: Install & Safety Check | SkillAgent