# 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.

- Skill: `creator-hian/unity-performance` (Agent Skill, multi-file: 2 files)
- Install (CLI): `npx skillmds@latest add creator-hian/unity-performance`
- Raw SKILL.md: https://api.skillmd.com/api/skills/creator-hian/unity-performance/raw
- Safety review: pending
- Works with: Claude Code, Claude.ai, OpenAI Codex
- Category: Coding & Dev Tools
- Author: creator-hian (https://skillmd.com/u/creator-hian)
- Updated: 2026-09-10
- Page: https://skillmd.com/skills/creator-hian/unity-performance

---


# Unity Performance Optimization

## Overview

Performance optimization for Unity games focusing on profiling and systematic optimization.

**Foundation Required**: `unity-csharp-fundamentals` (TryGetComponent, FindAnyObjectByType, null-safe coding)

**Core Topics**:
- Unity Profiler analysis
- Draw call reduction
- GPU instancing and SRP Batcher
- LOD (Level of Detail)
- Occlusion culling
- Object pooling
- Memory optimization

## Quick Start

### Collection & Object Pooling

GC-free pooling is critical for performance. Use Unity's built-in `UnityEngine.Pool` namespace (2021.1+):

```csharp
using UnityEngine.Pool;

// Temporary collection pooling - eliminates GC spikes
List<Enemy> enemies;
using (ListPool<Enemy>.Get(out enemies))
{
    GetComponentsInChildren(enemies);
    ProcessEnemies(enemies);
} // Auto-released
```

> **See `unity-collection-pool` skill** for comprehensive patterns:
> - ListPool, HashSetPool, DictionaryPool for temporary collections
> - ObjectPool<T> for component/prefab pooling
> - Advanced patterns: Keyed pools, auto-return, ECS integration

## Performance Targets

- **Mobile**: 30-60 FPS, <100 draw calls
- **Desktop**: 60+ FPS, <500 draw calls
- **VR**: 90 FPS minimum, <200 draw calls

## Profiling Workflow

1. **Profile first**: Identify actual bottleneck (CPU/GPU/Memory)
2. **Measure baseline**: Record before optimization
3. **Optimize bottleneck**: Focus on biggest impact
4. **Measure improvement**: Validate changes
5. **Repeat**: Until target performance reached

## Optimization Checklist

### CPU Optimization
- ✅ Reduce Update/FixedUpdate calls
- ✅ Object pooling for frequently spawned objects
- ✅ Cache component references in Awake/Start
- ✅ Use events instead of polling

### GPU Optimization
- ✅ Static batching for static objects
- ✅ GPU instancing for identical meshes
- ✅ Reduce SetPass calls via material sharing
- ✅ LOD groups for distant objects
- ✅ Occlusion culling for large scenes

### Memory Optimization
- ✅ Texture compression
- ✅ Mesh optimization (reduce vertex count)
- ✅ Audio compression and streaming
- ✅ Asset bundle management
- ✅ Unload unused assets
- ✅ **Collection pooling** (see `unity-collection-pool` skill)

## Reference Documentation

### [Profiling and Optimization Patterns](references/profiling-optimization.md)
Detailed profiling workflows:
- Unity Profiler module usage
- Draw call reduction techniques
- GPU instancing and SRP Batcher patterns

## Related Skills

- **unity-collection-pool**: GC-free collection management with ListPool, HashSetPool, DictionaryPool, and ObjectPool. Essential for eliminating GC spikes.

## Best Practices

1. **Profile on target platform**: Editor performance differs
2. **Optimize systematically**: Measure, optimize, validate
3. **Quality settings**: Provide options for different hardware
4. **Balance visuals vs performance**: Adjust based on target
5. **Test on low-end**: Ensure minimum spec performance