Why does my Unity game lag on Android, and how do you fix it?

You play your game in the Unity editor and it is silky smooth. You install it on an Android phone and it stutters, freezes for a moment every few seconds or slows down after a few minutes. This is one of the most common problems in mobile game development, and the good news is that it usually has a findable cause. This guide explains why a Unity game lag on Android happens, how to diagnose it properly and which fixes usually help most. If you would rather have specialists find it for you, see our game performance optimization service.

Quick answer: Unity games lag on Android for a handful of reasons: a default 30 fps cap, too many draw calls, transparent overdraw, heavy shaders or post-processing, memory allocations that trigger garbage collection pauses, oversized textures, expensive physics or scripts, and phones slowing down when hot. Profile a development build on a real phone, find whether the CPU or GPU is the bottleneck, fix the biggest cost first, and measure again after every change.

First, check it is real lag and not a frame-rate cap

Before anything else, check your frame rate settings. According to Unity’s targetFrameRate documentation, when vSync is off and the target frame rate is left at its default, Android renders at a fixed 30 fps to save battery. A game designed and tested at 60 in the editor will feel sluggish at 30.

If you want 60 fps, set Application.targetFrameRate = 60 early in the game, then test whether the phone can actually hold it. If it cannot, you have real performance work to do.

Unity game lag on Android: the usual causes

Symptom	Likely cause	Where to look
Smooth but feels slow, never above 30 fps	Default frame-rate cap	Application.targetFrameRate
Regular short freezes every few seconds	Garbage collection	Per-frame memory allocations
Slow in busy scenes, fine in empty ones	Draw calls or physics	Frame Debugger, Profiler
Slow with particles, UI or foliage on screen	Transparent overdraw	GPU profiling, scene view overdraw
Slow on all scenes on older phones	Shaders, resolution or post-processing	Render pipeline settings
Hitch when entering a level or opening a menu	Loading or instantiating on the main thread	Profiler timeline
Smooth at first, slower after a few minutes	Thermal throttling	Long-session tests
Crashes on cheaper phones	Memory: textures, audio, duplicates	Memory Profiler

Draw calls

Every separate object and material can mean a draw call, an instruction from the CPU to the GPU. Phones handle far fewer than PCs. Shared materials, texture atlases, static batching, GPU instancing and the SRP Batcher in the Universal Render Pipeline all reduce them.

Overdraw

Transparent pixels drawn on top of each other, such as particles, layered UI, smoke and foliage, make the GPU paint the same pixel many times. Large full-screen transparent effects are a frequent cause of lag on mid-range phones.

Heavy shaders and post-processing

Bloom, depth of field, real-time shadows and complex shaders look great on a PC and cost a lot on a phone. Lower the render scale, simplify shaders and turn off or reduce effects on lower device tiers.

Garbage collection pauses

In C#, creating new objects every frame, such as building strings, using LINQ in Update or allocating new lists, fills memory that the garbage collector must later clean up. Each clean-up can pause the game. The result is a hitch every few seconds, even in a light scene.

Scripts and physics

Calling Find, GetComponent or heavy calculations every frame adds up. So does physics left at default settings, with too many colliders, mesh colliders where simple shapes would do, or a fixed time step that runs physics more often than needed.

Textures, audio and memory

Uncompressed or oversized textures waste memory and bandwidth. Use compressed texture formats suited to Android, such as ASTC, and sensible maximum sizes. Long music files loaded fully into memory can cause problems too; stream them instead.

Loading and spawning hitches

A freeze when a level starts, a menu opens or a wave of enemies appears usually means heavy work is happening on the main thread in one frame: loading assets, instantiating many objects or building UI. Load content asynchronously, pre-warm object pools during loading screens and spread large set-up jobs over several frames so the player never sees a stall.

Heat

Phones protect themselves by slowing the chip when it gets hot. A game that pushes the device hard can run well for two minutes and then drop sharply. Steady, modest load beats peaks.

How to diagnose lag properly

Guessing is the slowest way to fix performance. Follow a measured process.

1. Pick your test devices

Choose your minimum supported phone and one typical mid-range phone. Use the same devices every time, so results are comparable.

2. Build a development build and connect the Profiler

Make a development build with profiling enabled, install it on the phone and connect the Unity Profiler. Do not trust editor numbers for mobile performance.

3. Find out whether the CPU or GPU is the bottleneck

The Profiler shows where frame time goes. If scripts, physics, animation or rendering preparation take most of the frame, you are CPU-bound. If the CPU is waiting for the GPU, you are GPU-bound. Fixing the wrong side wastes time.

4. Dig deeper with the right tool

• Frame Debugger shows each draw call and why objects were not batched.
• Memory Profiler shows what is using memory and finds duplicates.
• Android GPU Inspector (AGI) and Android Studio’s profilers show GPU and system behaviour on the device.

5. Fix the biggest cost first, then measure again

Rank problems by how much frame time they cost. Change one thing, rebuild, measure on the same devices. If several changes go in at once, you will not know which helped.

6. Test longer sessions

Play for 15 to 20 minutes on your minimum device and watch the frame rate over time. That is where thermal problems show up.

Fixes that usually help most

• Set a sensible target frame rate for the game type, and hold it steadily.
• Cut draw calls with shared materials, atlases, batching and instancing.
• Reduce overdraw by trimming particle counts and sizes, tightening sprite meshes and avoiding stacked transparent UI.
• Lower render cost on weaker phones with render scale, simpler shaders and fewer real-time shadows.
• Remove per-frame allocations by caching references, reusing lists and pooling objects instead of creating and destroying them.
• Move occasional work out of Update onto events or timers.
• Compress textures and audio with formats and sizes suited to the device.
• Use quality tiers so newer phones keep the full look and older ones get a lighter version.

Some of these overlap with general Android app performance; our guide to optimising an Android app for low-end devices covers the app side.

Mistakes to avoid

• Optimising by feel. Without a baseline, you cannot prove anything improved.
• Testing only on a flagship phone. Your players may be on far cheaper devices.
• Lowering graphics for a CPU problem. It makes the game uglier without making it faster.
• Making many changes at once. Change one thing and re-measure.
• Fixing it all at the end. Performance budgets set early prevent most problems.
• Ignoring store requirements. While fixing performance, also check you meet current Google Play technical requirements so an update is not blocked.

Unity Android performance checklist

• Target frame rate set deliberately
• Minimum and typical test phones chosen
• Development build profiled on device, not in the editor
• CPU-bound or GPU-bound identified
• Draw calls and batching checked in the Frame Debugger
• Transparent overdraw reduced
• Per-frame allocations removed
• Textures compressed and sized for mobile
• Quality tiers for older phones
• 15 to 20 minute session tested for heat
• Before-and-after numbers recorded

How Omebly can help

Omebly profiles and fixes Unity and Unreal games on real devices as part of our game development service. We record a baseline on agreed phones, rank problems by frame-time cost, make fixes on a separate branch with weekly test builds, and share before-and-after numbers. You do not need us to have built the game. If you are planning a new project, our Unity game development team profiles on real phones from the first week, so lag is caught early. Projects are led by our founder, Nazmul Hussain, who has 10+ years building websites, apps and digital products.

You get a fixed written quote after a free consultation, and an NDA is available before we open your project. Learn how our game optimisation service works, or contact us with your symptoms and target devices.

Send us a short video of the lag and the phone model, and we will suggest where to look first.