Unity Performance Optimization

Overview

Systematic approach to profiling and optimizing Unity games. Covers profiling tools, CPU/GPU optimization, memory management, rendering optimization, and platform-specific considerations.

Profiling Tools

Tool	What It Shows	When to Use
Unity Profiler	CPU, GPU, memory, audio, physics per frame	First stop for any perf issue
Frame Debugger	Draw call breakdown, shader/material state	Rendering bottlenecks
Memory Profiler	Heap snapshots, texture/mesh memory	Memory leaks, bloat
Profile Analyzer	Compare captures, statistical analysis	Before/after optimization
Physics Debugger	Collider visualization, contact points	Physics performance

Profiler Workflow

Build with Development Build + Autoconnect Profiler enabled
Profile on target device (not in Editor -- Editor overhead distorts results)
Identify the bottleneck category: CPU-bound, GPU-bound, or memory pressure
Drill into the specific system causing the issue
Optimize, re-profile, and compare

Reading the Profiler

If frame time > 16.6ms (60 FPS target):
  CPU timeline > GPU timeline -> CPU-bound
  GPU timeline > CPU timeline -> GPU-bound
  GC.Alloc column shows per-frame allocations -> GC pressure

Look for spikes (single bad frames) vs. sustained high times (baseline too heavy).

CPU Optimization

Reduce Per-Frame Allocations (GC)

Anti-Pattern	Fix
`string + string` in Update	Use `StringBuilder` or cache
`new List<T>()` every frame	Allocate once, `Clear()` and reuse
LINQ in hot paths	Replace with manual loops
`GetComponent<T>()` per frame	Cache in Awake/Start
`GameObject.Find()` per frame	Cache reference or use events
`foreach` on non-generic collections	Use `for` loop or generic collections
`SendMessage()` / `BroadcastMessage()`	Use direct calls, events, or interfaces
Boxing value types	Use generic collections, avoid `object` casts

Object Pooling

public class ObjectPool<T> where T : Component
{
    readonly Queue<T> _pool = new();
    readonly T _prefab;
    readonly Transform _parent;

    public ObjectPool(T prefab, int preWarm, Transform parent = null)
    {
        _prefab = prefab;
        _parent = parent;
        for (int i = 0; i < preWarm; i++)
            _pool.Enqueue(CreateInstance());
    }

    public T Get(Vector3 position, Quaternion rotation)
    {
        var obj = _pool.Count > 0 ? _pool.Dequeue() : CreateInstance();
        obj.transform.SetPositionAndRotation(position, rotation);
        obj.gameObject.SetActive(true);
        return obj;
    }

    public void Return(T obj)
    {
        obj.gameObject.SetActive(false);
        _pool.Enqueue(obj);
    }

    T CreateInstance()
    {
        var obj = Object.Instantiate(_prefab, _parent);
        obj.gameObject.SetActive(false);
        return obj;
    }
}

Pool bullets, particles, enemies, UI elements -- anything instantiated/destroyed frequently. Unity 2021+ also has UnityEngine.Pool.ObjectPool<T> built-in.

Update Optimization

Technique	Description
Stagger updates	Don't update all AI every frame; use tick groups
Distance-based LOD	Reduce update frequency for distant objects
Event-driven	Replace polling with events where possible
Disable unused scripts	`enabled = false` on off-screen components
Use `InvokeRepeating`	For periodic checks (cheaper than coroutine yielding)

GPU / Rendering Optimization

Draw Call Reduction

Technique	How	Savings
Static Batching	Mark non-moving objects as Static	Combines meshes at build time
Dynamic Batching	Automatic for small meshes (<300 verts)	URP/Built-in only
GPU Instancing	Enable on materials for repeated objects	Trees, grass, rocks
SRP Batcher	Enabled by default in URP/HDRP	Reduces SetPass calls
Texture Atlasing	Combine textures into atlas	Fewer material switches
Mesh Combining	`CombineMeshes()` at runtime	Custom batching

LOD (Level of Detail)

LOD Group Setup:
  LOD 0 (0-30%):  Full-detail mesh (5000 tris)
  LOD 1 (30-60%): Medium mesh (2000 tris)
  LOD 2 (60-90%): Low mesh (500 tris)
  Culled (90%+):  Not rendered

Use LOD for meshes, but also reduce script complexity, particle counts, and physics at distance.

Occlusion Culling

Bake occlusion data for indoor/complex scenes. Mark large static occluders (walls, floors). Configure cell size based on scene scale. Use the Occlusion Culling window to visualize and test.

Shader Optimization

Issue	Solution
Complex fragment shaders	Reduce texture samples, simplify math
Overdraw	Minimize transparent objects, use opaque when possible
Too many variants	Strip unused shader variants in build settings
Expensive post-processing	Disable effects on mobile, use cheaper alternatives

Memory Management

Common Memory Issues

Issue	Symptom	Fix
Texture bloat	High memory, long loads	Compress textures, reduce max size per platform
Unloaded scenes holding refs	Memory climbs over time	Use `Resources.UnloadUnusedAssets()` after scene transitions
Addressables not released	Bundles stay in memory	Call `Addressables.Release(handle)`
Audio clips uncompressed	Huge memory footprint	Use compressed in memory for music, decompress on load for SFX
Mesh read/write enabled	Double memory per mesh	Disable Read/Write if not needed at runtime

Texture Compression Per Platform

Platform	Format	Notes
PC/Console	BC7 (DXT)	Best quality/size ratio
Android	ASTC 6x6	Universal, scalable quality
iOS	ASTC 6x6	Same as Android
WebGL	ETC2 / DXT	Depends on target GPU

Use "Override for [Platform]" in texture import settings. Set max texture size to the minimum needed (512 for UI icons, 1024 for props, 2048 for hero assets).

Platform-Specific Considerations

Platform	Key Constraints
Mobile	Thermal throttling, limited memory, battery drain, fill-rate limited
WebGL	No threads (pre-Unity 6), large download size, no compute shaders
Console	Certification requirements, fixed hardware, memory budgets
VR/XR	72-90 FPS minimum, stereo rendering cost, motion sickness from drops

Addressables and Asset Loading

Use Addressables for async asset loading to avoid load-time hitches:

// Preload during loading screen
var handle = Addressables.LoadAssetAsync<GameObject>("enemy_boss");
await handle;

// Release when done
Addressables.Release(handle);

Use Addressable groups to control bundle granularity. Mark infrequently used assets as remote/on-demand. Profile bundle memory with the Addressables Event Viewer.

Quick Optimization Checklist

Additional Resources

Reference Files

references/profiling-deep-dive.md -- Advanced Profiler usage, memory profiler snapshots, frame-by-frame analysis, custom profiler markers, automated performance testing, build size analysis, ECS/DOTS performance patterns

unity-performance