unity-ui
Build and optimize Unity UI with UI Toolkit and UGUI. Masters responsive layouts, event systems, and performance optimization. Use for UI implementation, Canvas optimization, or cross-platform UI challenges.
Best use case
unity-ui is best used when you need a repeatable AI agent workflow instead of a one-off prompt.
Build and optimize Unity UI with UI Toolkit and UGUI. Masters responsive layouts, event systems, and performance optimization. Use for UI implementation, Canvas optimization, or cross-platform UI challenges.
Teams using unity-ui should expect a more consistent output, faster repeated execution, less prompt rewriting.
When to use this skill
- You want a reusable workflow that can be run more than once with consistent structure.
When not to use this skill
- You only need a quick one-off answer and do not need a reusable workflow.
- You cannot install or maintain the underlying files, dependencies, or repository context.
Installation
Claude Code / Cursor / Codex
Manual Installation
- Download SKILL.md from GitHub
- Place it in
.claude/skills/unity-ui/SKILL.mdinside your project - Restart your AI agent — it will auto-discover the skill
How unity-ui Compares
| Feature / Agent | unity-ui | Standard Approach |
|---|---|---|
| Platform Support | Not specified | Limited / Varies |
| Context Awareness | High | Baseline |
| Installation Complexity | Unknown | N/A |
Frequently Asked Questions
What does this skill do?
Build and optimize Unity UI with UI Toolkit and UGUI. Masters responsive layouts, event systems, and performance optimization. Use for UI implementation, Canvas optimization, or cross-platform UI challenges.
Where can I find the source code?
You can find the source code on GitHub using the link provided at the top of the page.
SKILL.md Source
# Unity UI - User Interface Systems
## Overview
Unity UI systems covering both UI Toolkit (modern) and UGUI (Canvas-based legacy).
**Foundation Required**: `unity-csharp-fundamentals` (TryGetComponent, FindAnyObjectByType, null-safe coding)
**Core Topics**:
- UI Toolkit (UIElements) for editor and runtime
- UGUI (Canvas) for game UI
- Responsive layouts and anchors
- Event systems
- UI performance optimization
- Data binding patterns
## Quick Start
### UGUI Button
```csharp
using UnityEngine.UI;
public class UIController : MonoBehaviour
{
[SerializeField] private Button mActionButton;
[SerializeField] private Text mStatusText;
void Start()
{
mActionButton.onClick.AddListener(OnButtonClick);
}
void OnButtonClick()
{
mStatusText.text = "Button clicked!";
}
}
```
### UI Toolkit (Runtime)
```csharp
using UnityEngine.UIElements;
public class UIController : MonoBehaviour
{
void OnEnable()
{
UIDocument uiDocument;
if (TryGetComponent(out uiDocument))
{
VisualElement root = uiDocument.rootVisualElement;
Button button = root.Q<Button>("action-button");
button.clicked += OnButtonClick;
}
}
void OnButtonClick()
{
Debug.Log("Button clicked!");
}
}
```
## UI Systems Comparison
| Feature | UI Toolkit | UGUI |
|---------|-----------|------|
| Performance | Better | Good |
| Styling | USS (CSS-like) | Inspector |
| Layout | Flexbox | RectTransform |
| Best For | Complex UI, tools | Game UI |
| Learning Curve | Steeper | Easier |
## Canvas Optimization (UGUI)
```csharp
// Separate static and dynamic UI into different canvases
// Static canvas: rarely changes
// Dynamic canvas: updates frequently
// Disable raycasting on non-interactive elements
[SerializeField] private Image mBackground;
void Start()
{
mBackground.raycastTarget = false; // Not clickable
}
// Use CanvasGroup for fade effects (TryGetComponent for null-safe access)
CanvasGroup canvasGroup;
if (panel.TryGetComponent(out canvasGroup))
{
canvasGroup.alpha = 0.5f; // Fade without rebuilding Canvas
}
```
## Responsive Layout
```csharp
// Use anchors for responsive design
// Anchor presets: Stretch, Top-Left, Center, etc.
// Canvas Scaler settings (TryGetComponent pattern)
CanvasScaler scaler;
if (TryGetComponent(out scaler))
{
scaler.uiScaleMode = CanvasScaler.ScaleMode.ScaleWithScreenSize;
scaler.referenceResolution = new Vector2(1920, 1080);
scaler.matchWidthOrHeight = 0.5f; // Balance between width/height
}
```
## Reference Documentation
### [UI Systems Reference](references/ui-systems.md)
Comprehensive UI guide:
- UI Toolkit vs UGUI decision guide
- Layout and styling patterns
- Performance optimization techniques
## Best Practices
1. **Separate canvases**: Static vs dynamic content
2. **Disable raycasts**: On non-interactive elements
3. **Use CanvasGroup**: For fade effects without rebuild
4. **Atlas textures**: Pack UI sprites for batching
5. **Hide instead of destroy**: Pool UI elements
6. **Test multiple resolutions**: Ensure responsive design
7. **Profile UI**: Check Canvas rebuild overheadRelated Skills
unity-vcontainer
VContainer dependency injection expert specializing in IoC container configuration, lifecycle management, and Unity-optimized DI patterns. Masters dependency resolution, scoped containers, and testable architecture design. Use PROACTIVELY for VContainer setup, service registration, or SOLID principle implementation.
unity-unitask
UniTask library expert specializing in allocation-free async/await patterns, coroutine migration, and Unity-optimized asynchronous programming. Masters UniTask performance optimizations, cancellation handling, and memory-efficient async operations. Use PROACTIVELY for UniTask implementation, async optimization, or coroutine replacement.
unity-unirx
UniRx (Reactive Extensions) library expert for legacy Unity projects. Specializes in UniRx-specific patterns, Observable streams, and ReactiveProperty. Use for maintaining existing UniRx codebases. For new projects, use unity-r3 skill instead.
unity-textmeshpro
TextMeshPro (TMPro) expert for Unity text rendering with advanced typography, performance optimization, and professional text effects. Masters font asset creation, dynamic fonts, rich text formatting, material presets, and text mesh optimization. Use PROACTIVELY for text rendering, font management, localization text, UI text performance, or text effects implementation.
unity-testrunner
Unity Test Framework CLI automation and test writing patterns. Masters batchmode execution, NUnit assertions, EditMode/PlayMode testing, and TDD workflows. Use PROACTIVELY for test automation, CI/CD pipelines, or test-driven development in Unity.
unity-r3
R3 (Reactive Extensions) library expert specializing in modern reactive programming patterns, event-driven architectures, and Observable streams. Masters R3-specific features, async enumerable integration, and Unity-optimized reactive patterns. Use PROACTIVELY for R3 implementation, reactive programming, or MVVM/MVP architecture.
unity-performance
Optimize Unity game performance through profiling, draw call reduction, and resource management. Masters batching, LOD, occlusion culling, and mobile optimization. Use for performance bottlenecks, frame rate issues, or optimization strategies.
unity-networking
Implement multiplayer games with Unity Netcode, Mirror, or Photon. Masters client-server architecture, state synchronization, and lag compensation. Use for multiplayer features, networking issues, or real-time synchronization.
unity-mobile
Optimize Unity games for mobile platforms with IL2CPP, platform-specific code, and memory management. Masters iOS/Android deployment, app size reduction, and battery optimization. Use for mobile builds, platform issues, or device-specific optimization.
unity-csharp-fundamentals
Unity C# fundamental patterns including TryGetComponent, SerializeField, RequireComponent, and safe coding practices. Essential patterns for robust Unity development. Use PROACTIVELY for any Unity C# code to ensure best practices.
unity-collection-pool
Unity Collection Pool expert for GC-free collection management using ListPool, DictionaryPool, HashSetPool, and ObjectPool. Masters memory optimization, pool sizing, and allocation-free patterns. Use PROACTIVELY for collection allocations, GC pressure reduction, temporary list/dictionary usage, or performance-critical code paths.
unity-async
Handle Unity's asynchronous programming patterns including coroutines, async/await, and Job System. Masters Unity's main thread restrictions and threading models. Use when guidance needed on Unity async operations, coroutine optimization, or parallel processing in Unity context.