Why Your Mobile Game Won't Hit 60 FPS

On Samsung Galaxy A52 (Adreno 618) the game runs at 28–32 FPS with a target of 60. On Xiaomi Redmi Note 11 with Helio G96 and Mali-G57 — stable 55–60 FPS. Different performance on similarly priced devices is a typical scenario in mobile gamedev. Mobile game rendering optimization begins with analyzing bottlenecks on specific chips. Achieving 60 FPS on mid-range devices requires careful profiling. We have helped clients cut GPU costs in half, avoiding expensive reworks — saving up to $10,000 per project.

We specialize in cross-platform optimization: we work with Unity, Unreal Engine, and custom engines. With over 15 projects, we have achieved stable 60 FPS on target devices. As a result of rendering optimization, we have delivered 20–30% FPS gains without quality loss. The key to stable performance is understanding mobile GPU architecture. Unlike desktop GPUs, they use tile-based renderingWikipedia, which imposes specific requirements on shaders and batching. Mobile graphics performance must be optimized for each target.

How to Identify the Bottleneck on Mobile GPUs

Before optimizing, understand what is the bottleneck. In Unity: Frame Debugger + Profiler. Enable Profile GPU in Android Player Settings and check Profiler → GPU. If GPU time per frame is close to 16ms (60 FPS) and CPU time is significantly less — you are GPU-bound. Otherwise — CPU-bound.

On Unreal Engine: stat GPU in console, ProfileGPU command, RenderDoc for frame capture. r.ScreenPercentage 50 — quick test: if FPS jumps drastically when resolution is halved, you are GPU-bound. Commands stat unit, stat drawcalls, r.ShowFlag.Rendering 1 give CPU/GPU breakdown and draw call count. GPU profiling is essential.

Why Draw Calls Are Critical for Mid-Range Devices

On mobile GPUs, draw call overhead is higher than on consoles/PC. 500+ draw calls per frame is the red zone for mid-range Android. Each unique material = a separate draw call. Each MeshRenderer with a unique material adds one more. The following draw call optimization techniques reduce this overhead.

Static batching Unity: Objects with the same material are merged into one mesh. Requirement: identical Material asset (not just identical settings). Mark as Static in Inspector. Works automatically at build time.

GPU Instancing: For repeated objects (grass, trees, enemies of one type):

// Material must support instancing material.enableInstancing = true; // Draw 1000 instances in one draw call Graphics.DrawMeshInstanced(mesh, 0, material, matrices, 1000); 

SRP Batcher (Unity URP/HDRP): Automatically batches objects with different materials but the same shader. Enable in URP Asset → SRP Batcher = enabled. The easiest way to reduce draw calls without manual batching.

How We Optimize Rendering

Shaders for Tile-Based GPUs

Mobile GPUs (Adreno, Mali, PowerVR, Apple) use Tile-Based Immediate Mode Rendering. The screen is divided into tiles, each rendered completely in fast on-chip memory. This means:

• Framebuffer fetch — reading from the current framebuffer within a tile is practically free. Use it for deferred lighting: gl_LastFragData in GLSL (GLES extension EXT_shader_framebuffer_fetch).
• Depth pre-pass on mobile is often unnecessary overhead — TBIMR already handles depth test efficiently inside the tile.
• Discard in fragment shaders (alpha-test, clip) kills early depth test for the whole tile. Replace with alpha-blend or alpha-to-coverage where possible.

Precision Qualifiers in GLSL/Metal

// SLOW — highp everywhere by default uniform highp mat4 ModelMatrix; varying highp vec2 TexCoord; // FAST — minimal required precision uniform highp mat4 ModelMatrix; // matrices need highp varying mediump vec2 TexCoord; // UV coords — mediump enough varying lowp vec4 VertexColor; // color — lowp 

On Mali GPUs, switching from highp to mediump for texture samplers yields a 10–25% performance boost in the fragment shader. Optimizing Mali GPU shaders with reduced precision is key.

ALU vs Texture Fetch

On most mobile GPUs, texture fetch is cheaper than heavy ALU computations (sin, pow, sqrt). Pre-baked lookup tables in textures are faster than computing in the shader:

// Slow: compute fresnel in shader float fresnel = pow(1.0 - dot(viewDir, normal), 5.0); // Fast: lookup texture float fresnel = texture2D(fresnelLUT, vec2(dot(viewDir, normal), roughness)).r; 

Dynamic Resolution (Unity URP):

ScalableBufferManager.ResizeBuffers(0.75f, 0.75f); // 75% of native 

Unreal Mobile Super Resolution (MSR) — built-in temporal upscaler for mobile platforms from Unreal 5.1+. r.Mobile.TemporalAA 1. Delivers near-native quality with significantly lower GPU load.

Adaptive Performance (Samsung Game SDK + Unity): Automatically reduces load when overheating. Thermal status and performance metrics available via UnityEngine.AdaptivePerformance.

FPS Optimization Case Study: 40 → 58 FPS on Adreno 618

From our practice: a runner game on Galaxy A52 — 40 FPS. Profiling via AGI showed: Fragment ALU 87%, fragment bandwidth overloaded. Three changes:

1. Water shader: replaced pow(fresnel, 5.0) with LUT texture → -8ms GPU
2. Switched highp to mediump for all texture samplers → -4ms GPU
3. Dynamic resolution 0.80 instead of native → -6ms GPU

Result: from 40 to 58 FPS without changing visual style. On Pro devices — no change, they held 60 FPS with headroom.

The optimization saved the client $10,000 in avoided rework.

Work Process

1. Analysis: Collect logs, profile on target devices, identify bottlenecks.
2. Design: Choose optimization methods (batching, shaders, dynamic resolution).
3. Implementation: Apply changes to code and assets.
4. Testing: Run on 5+ different devices, compare FPS and quality.
5. Deployment: Prepare release build, configure Adaptive Performance.

Timeframes: Profiling and analysis take 2–3 days. Shader optimization, batching, dynamic resolution — from 1 to 3 weeks depending on project state.

What You Get

• Detailed report with rendering analysis and bottlenecks
• Optimized shaders with minimal precision (mediump/lowp)
• Configured automatic batching (static batching, SRP Batcher, instancing)
• Dynamic Resolution configuration tailored to target devices
• Build and deployment instructions
• Guaranteed stability on agreed set of devices
• Our optimization packages start at $2,000 and typical savings are $5,000–$15,000

Contact us for a consultation on your project. Order a rendering audit and receive an optimization plan for your target hardware. Our mobile game rendering optimization service ensures stable 60 FPS on mid-range devices.