Optimising a Unity game for mobile sounds straightforward until you are staring at a profiler that says your frame time is 28ms on a device that needs to hit 16ms. We went through this on our first mobile project — here is what actually made a difference.
This is not a comprehensive list. It is the specific things we found, in order of impact, that moved the needle on mid-range Android hardware.
1. Texture compression is the first conversation
The single largest win we found was switching from RGBA32 to ASTC for all textures. ASTC is the modern standard for Android and compresses to roughly a quarter of the size at similar quality. The GPU reads less data per frame and your APK size drops significantly.
For iOS, ASTC is similarly supported. Enable GPU instancing at the same time — if you have any repeated objects (trees, enemies, pickups), instancing collapses their draw calls into one.
2. Atlas your UI sprites aggressively
Every unique UI texture is a draw call. On a screen with 20 UI elements from 20 different sprites, you have at minimum 20 draw calls just for your HUD. Atlas packing combines them into a single texture — Unity's Sprite Atlas component handles this automatically if you set it up correctly.
Target under 5 draw calls for your entire UI layer. It is achievable with proper atlasing.
3. The profiler is your only source of truth
This sounds obvious but most mobile optimisation advice you find online is based on desktop assumptions. What kills performance on a mid-range Android is often different from what kills it on a PC. Connect the profiler to a real device — not the editor, not the emulator — before you optimise anything.
The Deep Profile mode in Unity's profiler shows you exactly which C# methods are consuming time. Run it for 60 seconds on a typical gameplay session. The culprits are usually obvious once you can see them.
4. Object pooling for anything that spawns repeatedly
Instantiate and Destroy are expensive. If your game spawns bullets, enemies, particles, or collectibles at any frequency, pool them. Unity 2021+ has a built-in Object Pool API under UnityEngine.Pool — use it instead of rolling your own.
The frame spike from a sudden Instantiate call is invisible on PC. On mobile it shows up as a dropped frame that players feel even if they cannot identify it.
5. Camera configuration on mobile
Two changes that consistently improved frame time on our project:
- Disable HDR on the main camera if you are not using post-processing that requires it. HDR doubles the bandwidth for the render target.
- Set the camera's Depth Texture mode to None unless depth is actively needed. This eliminates a full-screen depth prepass on tile-based GPUs (which all mobile GPUs are).
6. Reduce SetPass calls, not just draw calls
Most optimisation guides focus on draw calls. SetPass calls are more important on mobile — these are the expensive state changes that happen when the GPU needs different shader state for a new object. The way to reduce them is to batch objects that use the same material.
Check your Frame Debugger regularly. If you see the same shader being set repeatedly for similar objects, that is a batching problem, not a draw call problem.
What did not help (for us)
Reducing polygon count was a common suggestion we followed early on. It made almost no difference. Mobile GPU performance is almost never vertex-bound — it is bandwidth-bound and overdraw-bound. Optimise textures and fill rate before you spend time on mesh simplification.
LOD groups also made minimal difference for our game's scale. They are genuinely useful for open-world PC games. For a mobile game with a constrained view distance, the overhead of managing LOD transitions can cost more than it saves.
The test matrix
One thing we wish we had set up earlier: a consistent device test matrix. Pick three real devices that represent your target audience — low-end, mid-range, and flagship — and test on all three after every significant change. Emulators will lie to you about performance in ways that cost you weeks of debugging after the fact.