Unity 6
Mobile Optimization
Performance Checklist
URP
Memory Management
Android
iOS

Unity 6 Mobile Performance Checklist: Profiler, URP, Memory & Thermal QA

13 min read
Eshan Naithani

Shipping a Unity 6 mobile game that holds a stable frame rate across mid-range Android and iOS devices requires systematic verification across CPU execution, GPU tile bandwidth, managed/native memory, and sustained thermal load. Fixing a single shader or Update() script in isolation rarely solves production stutters if an unbatched UI Canvas or uncompressed texture atlas is simultaneously saturating device memory.

Use this bookmarkable Unity 6 Mobile Performance Checklist during milestone QA and pre-launch sign-off. For deep architectural walkthroughs and C# implementation code behind each check, read our comprehensive Unity 6 Mobile Game Optimization Guide.


1. Unity Profiler & CPU/GPU Bottleneck Triage Checklist

Never optimize blind or profile inside the Unity Editor. Always capture baseline traces from an IL2CPP Development Build on physical hardware:

CheckDiagnostic Tool / SettingWhat to VerifyEngineering Action if Failing
[ ]Build Profiles > Development Build + Autoconnect ProfilerProfiling an IL2CPP ARM64 build on a physical mid-range Android/iOS device (not Editor Play Mode or Mono).Switch Scripting Backend to IL2CPP, target ARM64, and connect via USB (adb forward) or Wi-Fi.
[ ]Unity Profiler > Timeline View (PlayerLoop)Compare Main Thread, Render Thread, and Job Worker timelines against frame budget (16.67 ms for 60 FPS; 33.33 ms for 30 FPS).Identify whether frame time is dominated by Main Thread scripts/physics, Render Thread draw submission, or GPU (WaitForPresentOnGfxThread).
[ ]Profile Analyzer (com.unity.performance.profile-analyzer)Compare 300-frame captures (Compare mode) using Median, Upper Quartile, and Max frame times rather than single frames.Prioritize markers with high Median cost for sustained FPS and high Max cost for stutter/hitch elimination.
[ ]Frame Debugger (Window > Analysis > Frame Debugger)Audit total Render Passes, SetPass Calls, and why specific draw calls break SRP Batcher or GPU Instancing.Consolidate material shader variants and disable unnecessary full-screen blit passes.
[ ]Native GPU Profilers (Xcode Metal Debugger / Android GPU Inspector / Snapdragon Profiler)Inspect tile memory bandwidth, fragment overdraw, and shader ALU register pressure on GPU-bound scenes.Lower URP Render Scale, simplify fragment shaders, and reduce transparent particle overdraw.

2. Universal Render Pipeline (URP) & GPU Rendering Checklist

Mobile GPUs (Apple A-series, Qualcomm Adreno, ARM Mali) use Tile-Based Deferred Rendering (TBDR) architectures. Minimizing off-tile VRAM round-trips (Load/Store actions) is critical for both frame rate and battery life:

  • [ ] Disable Unused Camera Textures on Mobile URP Assets:
    • Uncheck Opaque Texture (_CameraOpaqueTexture) and Depth Texture (_CameraDepthTexture) on your mobile URP Pipeline Asset unless a specific shader requires them—each forces an extra full-screen resolve out of fast on-chip tile memory.
  • [ ] Disable HDR on Low/Mid-Tier Mobile Profiles:
    • Uncheck HDR on low- and mid-range URP quality tiers so color targets use 32-bit RGBA8 instead of 64-bit RGBA16F (halving framebuffer memory bandwidth).
  • [ ] Tune URP Render Scale for High-DPI Screens:
    • Modern phones often ship with 2400x1080 or 2796x1290 screens where native resolution overtaxes the fragment stage. Set URP Asset > Render Scale between 0.75 and 0.85 on mid-range tiers (while keeping UI on a Screen Space Overlay Canvas so text remains crisp at native resolution).
  • [ ] Audit MSAA vs. Post-Processing Compatibility:
    • On TBDR mobile GPUs, 2x or 4x MSAA resolves inside on-chip tile memory—provided you do not interrupt rendering with intermediate full-screen blits or heavy post-processing stacks.
  • [ ] Shadow Distance & Cascade Discipline:
    • Limit Max Shadow Distance to the immediate camera gameplay area, use 1 Shadow Cascade (or baked lightmaps + blob shadows for low-end tiers), and disable Soft Shadows on budget hardware.
  • [ ] Unity 6 Render Graph & Pass Merging:
    • Ensure custom ScriptableRenderPass implementations use the Unity 6 Render Graph API (RecordRenderGraph) so compatible passes merge automatically in tile memory without redundant render target loads/stores.

3. Draw Calls, Batching & Shader Variant Checklist

  • [ ] SRP Batcher Enabled & Verified:
    • Confirm SRP Batcher is enabled on the URP Asset and verify in the Frame Debugger that opaque and transparent geometry batches under SRP Batch without breaking due to MaterialPropertyBlock usage on Lit/Unlit shaders.
  • [ ] Static Batching vs. GPU Instancing / GPU Resident Drawer:
    • Non-moving environment props share materials and use Static Batching (watching total combined vertex buffer RAM) or Unity 6's GPU Resident Drawer (BatchRendererGroup under Forward+) for high-instance scenes.
  • [ ] 2D & UI Sprite Atlases (SpriteAtlas):
    • Pack UI icons and 2D gameplay sprites into logical Sprite Atlases grouped by screen/feature so UI canvases render in minimal draw calls.
  • [ ] Shader Variant Stripping (Project Settings > Graphics):
    • Strip unused fog modes, lightmap modes, instancing variants, and debug shader keywords (ShaderVariantCollection prewarming) to prevent runtime shader compilation hitches when a new effect spawns.

4. C# Garbage Collection (GC) & CPU Hot-Path Checklist

In Unity's Boehm incremental/stop-the-world garbage collector, frequent managed heap allocations trigger GarbageCollector.CollectIncremental spikes and expand the managed heap:

  • [ ] Zero Recurring GC.Alloc in Steady-State Gameplay:
    • Sort the CPU Usage Profiler > Hierarchy View by the GC Alloc column during active gameplay and confirm 0 B per frame on steady-state Update(), LateUpdate(), and FixedUpdate() paths.
  • [ ] Object Pooling for Spawned Entities (UnityEngine.Pool.ObjectPool<T>):
    • Replace runtime Instantiate() and Destroy() calls for projectiles, VFX particles, floating combat text, and scrollable UI list rows with ObjectPool<T>.
  • [ ] Non-Allocating Physics & Raycast Queries:
    • Replace Physics.RaycastAll, Physics.OverlapSphere, and Physics2D.OverlapCircleAll with Physics.RaycastNonAlloc / Physics.OverlapSphereNonAlloc (or preallocated NativeArray command batches).
  • [ ] Eliminate LINQ, Boxing & String Concatenation in Loops:
    • Remove System.Linq queries, enum dictionary keys without custom IEqualityComparer<T>, and "Score: " + score string concatenations from per-frame code.
  • [ ] Cache Component & Coroutine Yield Instructions:
    • Cache GetComponent<T>() references and Camera.main in Awake(), and reuse static WaitForSeconds instances across coroutines.
  • [ ] Stagger AI & Off-Screen Logic:

5. Texture, Audio & Addressables Memory Checklist

Out-Of-Memory (OOM) terminations on 3 GB–4 GB RAM Android and iOS devices are overwhelmingly driven by native asset memory rather than C# scripts. Cross-check with our Unity Mobile Memory Profiling Guide:

  • [ ] Hardware Texture Compression (ASTC):
    • Verify all Android and iOS textures use ASTC compression (ASTC 6x6 standard, ASTC 4x4 for normal maps/crisp gradients, ASTC 8x8 for rough background masks). Ensure zero accidental uncompressed RGBA32 textures exist in the build report (see our Unity 6 Build Size Optimization Guide for automated BuildReport auditing).
  • [ ] Uncheck Read/Write Enabled on Textures & Meshes:
    • Leaving Read/Write Enabled checked keeps a duplicate copy of the texture or mesh in CPU system RAM alongside GPU VRAM (doubling memory usage). Disable it on every asset not modified by CPU code at runtime.
  • [ ] Disable Mip Maps on 2D UI & Fixed-Distance Sprites:
    • Uncheck Generate Mip Maps on all UI textures and 2D ortho sprites to save ~33% memory per texture.
  • [ ] Audio Import Load Types:
    • Short, frequent SFX (< 2 seconds): Decompress On Load (PCM/ADPCM).
    • Medium SFX (2–5 seconds): Compressed In Memory (Vorbis).
    • Long BGM & Ambient tracks (> 5 seconds): Streaming (or Compressed In Memory on WebGL) with Force To Mono enabled where stereo imaging is not required.
  • [ ] Deterministic Addressables & Scene Unloading:

6. Unity UI (uGUI) Performance Checklist

  • [ ] Separate Dynamic vs. Static Canvases:
    • Place static background panels/headers on one Canvas and frequently animated elements (health bars, timers, floating notifications) on separate child Canvas components so dirtying one element does not rebuild the entire UI geometry tree.
  • [ ] Disable Raycast Target on Non-Interactive Elements:
    • Uncheck Raycast Target on all decorative Image, RawImage, and TextMeshProUGUI components so GraphicRaycaster only tests actual buttons and interactive sliders.
  • [ ] Avoid Layout Group Rebuild Cascades:
    • Avoid deeply nested VerticalLayoutGroup / HorizontalLayoutGroup / ContentSizeFitter hierarchies on dynamic scroll views; use pooled fixed-size rect transforms for inventory and leaderboard lists.
  • [ ] Zero-Allocation TextMeshPro Updates:
    • Use tmpText.SetText("{0}", scoreInt) instead of tmpText.text = scoreInt.ToString() to avoid per-update string allocations.
  • [ ] Hide Off-Screen Canvases via Canvas.enabled = false:
    • Disable canvas.enabled = false rather than calling gameObject.SetActive(false) on massive UI hierarchies when toggling menus frequently, avoiding expensive OnDisable/OnEnable component callbacks and dirtying rebuilds.

7. Thermal Throttling & Battery Efficiency Checklist

A mobile game that runs at 60 FPS for the first 90 seconds can drop to 25 FPS after 10 minutes once the SoC hits its thermal ceiling and the OS throttles CPU/GPU clock speeds:

  • [ ] Explicit Application.targetFrameRate Management:
    • Disable VSync (QualitySettings.vSyncCount = 0 on mobile) and set Application.targetFrameRate = 30 (or 60 for fast-action genres). Drop Application.targetFrameRate to 30 (or use OnDemandRendering.renderFrameInterval = 2) when the player is sitting on static pause menus, shop screens, or idle dialogs.
  • [ ] 15–20 Minute Unplugged Thermal Soak Test:
    • Run continuous gameplay for 15–20 minutes on an unplugged mid-range device (while not charging, as battery charging adds heat) and record frame-time stability between Minute 2 and Minute 18.
  • [ ] Android Dynamic Performance Framework (ADPF) / Adaptive Performance:
    • Monitor thermal state where supported (e.g., iOS ProcessInfo.thermalState or Android thermal APIs) to dynamically step down particle density, shadow distance, or target frame rate before hard OS throttling kicks in.

8. Before / After Mobile Performance Benchmark Template

Copy this markdown template into your engineering pull requests or QA sign-off tickets to record reproducible before/after measurements on real hardware:

MARKDOWN
### Unity 6 Mobile Performance Benchmark Sign-Off
- **Build / Commit**: [e.g., v1.2.0 - IL2CPP ARM64 Development Build]
- **Target Android Device**: [e.g., Samsung Galaxy A54 / Redmi Note 12 - 4GB/6GB RAM]
- **Target iOS Device**: [e.g., iPhone 12 / iPhone 13]
- **Test Scenario**: [e.g., Level 15 Peak Combat - 300 Frame Capture + 15-Min Thermal Soak]

| Metric (Measured on Physical Device) | Baseline (Before) | Optimized (After) | Target Threshold |
| :--- | :--- | :--- | :--- |
| **Median Frame Time (ms / FPS)** | __ ms (__ FPS) | __ ms (__ FPS) | <= 16.67 ms (60 FPS) or <= 33.33 ms (30 FPS) |
| **99th Percentile / Max Frame Time (ms)** | __ ms | __ ms | Minimal hitch spikes |
| **Main Thread Median Time (ms)** | __ ms | __ ms | Within frame budget |
| **Render Thread Median Time (ms)** | __ ms | __ ms | Within frame budget |
| **Steady-State `GC.Alloc` per Frame** | __ KB | __ B | 0 B in steady state |
| **Peak SetPass Calls / Batches** | __ / __ | __ / __ | Minimized via SRP Batcher & Atlasing |
| **Peak Total Allocated Memory (MB)** | __ MB | __ MB | Safe margin below low-end device RAM ceiling |
| **Peak Texture Memory (MB)** | __ MB | __ MB | All ASTC compressed; Read/Write disabled |
| **Frame Time after 15-Min Thermal Soak** | __ ms | __ ms | < 10% degradation vs. Minute 2 baseline |

Frequently Asked Questions


Official Documentation References

Need help architecting or optimizing your Unity mobile game? Let's discuss your technical roadmap.

Share this article

Get Practical Unity Development Insights

Technical guides on Unity performance, AI gameplay systems, mobile monetization, and game development.

Unsubscribe at any time. Your data is never shared.

Recommended Reading

More articles in Unity 6