Why a mobile game can't hold a stable 60 FPS
Frame drops are almost never about the "hardware" — they are a consequence of how the game uses the graphics pipeline.
Optimizing a mobile game's rendering starts with finding the bottleneck: the same drop from 60 to 40 FPS can be caused by UI overdraw on top of the scene, redundant draw calls per object, memory leaks for textures, and heavy effects like transparency and post-processing. Until the cause is localized, any changes are guesswork.
UI overdraw is the most common hidden culprit. Every HUD element that updates in the game loop forces the layer on top of the scene to be rebuilt, and the cost grows linearly with the number of such elements.
Redundant draw calls have a similar effect: hundreds of separate objects instead of those batched together load the CPU more than the geometry itself.
Memory leaks for textures and buffers don't show up immediately — for the first few minutes the game holds its frame rate, but by mid-session stutters and forced unloading begin.
From the player's perspective it looks predictable: device heating, throttling after 10-15 minutes, frame drops in dynamic scenes, and complaints that "it lags on my phone." Let's break down how each of these bottlenecks is closed at the rendering level, rather than with crutches in the game logic.
What mobile game rendering optimization delivers
Rendering optimization is not about "making the picture faster" — it's about removing unnecessary work from the critical path of a frame.
When the frame budget is met, the engine has time to render the scene and prepare the next frame instead of catching up on what it missed.
In practice, it looks like this: instead of frame drops in complex scenes, you get a smooth graph where frame time stays within the limits set by the screen's refresh rate.
The first thing a player notices is a stable frame rate and predictable animation smoothness. The second thing they feel is control response time: a tap is processed in the same frame, not two or three frames later.
This directly affects retention — in fast-paced scenes, a delay of a couple of frames is perceived as "the game is lagging," even if the average metric is high.
Next comes the game's power consumption. When rendering doesn't do unnecessary work, the device heats up less and throttles less often under load.
This removes the main cause of "drifting" performance: the phone doesn't go into throttling after ten minutes of play, and frames don't start dropping toward the middle of a session.
And last in order, but not in importance — support for low-end devices. Optimized rendering expands the list of models on which the game runs comfortably, without a separate stripped-down build for each device class.
We work on Unity and profile real scenes on target devices, not just in the editor — which is why the effect of optimization is visible in live measurements, not in theory.
Rendering approaches: what to choose for the task
The choice of rendering pipeline determines the performance ceiling of the entire game: changing it mid-project is more expensive than getting it right from the start.
The forward pipeline draws each object in turn — predictable and cheap on a scene with a hundred objects, but on a dense scene it hits the limit of draw calls.
Batching merges objects of the same type into a single call and removes this limitation, while deferred rendering moves lighting calculations into a separate pass and keeps a stable frame rate where there are many light sources.
| Option | When it fits | Limitations |
|---|---|---|
| Forward pipeline | Simple scenes, 2D, early prototype | Growing number of draw calls, frame drops on dense scenes |
| Batching | Many objects of the same type, mobile 3D scenes | Requires shared materials and textures, more difficult with transparency |
| Deferred rendering | Lots of dynamic light, complex scenes | Higher memory load, weaker on low-end devices |
The level of detail works on top of any pipeline: distant objects get simplified geometry and textures, and this frees up the frame budget for what the player sees up close.
Rendering limitations on mobile are set not only by the chip, but also by thermal throttling — stable 60 frames is more important than peak 120 that holds for the first few minutes.
We break down how to pick a pipeline for a specific scene and keep the frame rate without drops.
How mobile game rendering optimization works
Rendering optimization isn't "tweak the shaders and it got faster" — it's a cycle: measure, find the bottleneck, fix, re-measure on a live device. Below is how this work is done by our engineers.
- Capture baseline metrics. We measure frame rate and frame render time on reference devices — from budget to flagship. We record not the average but the distribution: dips at the 90th percentile are more noticeable to the player than a smooth average frame rate.
- Profile the rendering. We break down the frame by stages: scene preparation, geometry rendering, transparency handling, post-processing. The profiler shows which stage is eating the frame budget — then we work in a targeted way, rather than "optimizing everything."
- Find the bottlenecks. Typical causes of dips: excessive draw calls, overdraw of pixels on top of each other, heavy shaders, extra light sources, suboptimal textures. We confirm each one with a measurement, not a guess.
- Fix shaders and materials. We simplify calculations in shaders, remove extra passes, merge materials to reduce the number of draw calls. The goal is to fit the frame within budget at the target frame rate.
- Test on devices. We run the build on a real fleet of devices: different chips, memory sizes, OS versions. An emulator won't show thermal throttling and real degradation — only a live run will.
- Repeat the cycle. After the fixes, we capture metrics again and compare them with the baseline. If dips remain, we go back to profiling until the frame distribution becomes smooth.
- Hand over the result. We deliver before/after measurements, a list of fixes, and recommendations so the team can maintain performance as new content is added.
This cycle addresses the task not as a one-off but as a process: every fix is confirmed by a measurement, not by a feeling that "it seems smoother now."
What the client receives based on the results of the work
Based on the results of rendering optimization, the client receives not a report, but a working kit that the project can continue to use without our involvement. Below is what exactly remains in the repository and in the documentation.
- Graphics quality profiles — a set of switchable configurations from "power saving" to "maximum": draw distance, shadow density, anti-aliasing level, render resolution. Each profile is tied to a device class, so on weak models the game does not fall into frame drops, and on flagships it does not look stripped down.
- Scene map — a map of what and when enters the frame: static geometry, dynamic objects, effects, interface layers. It shows which nodes can be disabled or replaced with simplified ones without breaking the visuals.
- Quality policies — the rules by which the engine itself reduces load: rendering priorities, per-frame budgets, behavior during overheating and battery discharge. The game maintains the target 60 frames/s and does not go into overheating during long sessions.
- Rendering documentation — a description of the pipeline, measurement points, and how each setting affects frame rate. An engineer who joins the project later will be able to figure it out without contacting us.
- Verification procedure — an acceptance checklist: on which devices and scenes we measure, which thresholds we consider normal, and what we record in the report. Frame regressions are caught before release, not in reviews.
- Configured graphics settings in the menu — user-friendly switches with honest labels, so the user can choose the balance between visuals and battery life.
- Measurement scripts — automatic scene runs with recording of frame rate and frame time, so each build can be compared with the previous one.
We hand over the kit with a walkthrough: we show where the bottlenecks were, what was changed, and how to verify the result yourself. Describe the task — we will get back to you with an estimate and a work plan.
Case study: how a game stopped dropping frames on mid-range devices
The project was a casual game with an isometric scene and dozens of animated objects. On the mid-range segment of devices, the frame rate sagged to 40–45, and on mass scenes — down to 30, with regular drops: the share of frames rendered longer than budget reached a quarter.
Players complained about "choppy" controls, not about the graphics — the drops hit input responsiveness.
We started with profiling on real mid-range devices, not on flagships: we measured frame time, the distribution of drops, and the rendering load frame by frame.
It turned out that the bottleneck was not the number of objects, but excessive draw calls and redrawing the static background every frame.
We batched the scene by materials, moved static content into a separate layer, switched animations to a shared atlas, and decoupled physics and logic from the render rate — now they are computed at a fixed step and do not "drift" during drops.
Unity provided the tools for batched rendering and profiling, but what solved it was not the platform but the order of work: first measure, then change, then measure again on the same set of devices.
After optimization, the frame rate on mid-range devices reached a stable 58–60 in mass scenes, the share of dropped frames fell from a quarter to single-digit percentages, and the spread between the best and worst frame shrank severalfold — rendering stopped "jittering." On the low-end segment we held 45–50 without visual simplifications that a player would notice.
We separately checked rendering stability under load: long sessions, heating, background processes. The drops that used to accumulate by the tenth minute of play disappeared — frame time stays even throughout the entire session.
How does deferred rendering differ from forward rendering?
Forward rendering sends drawing commands to the graphics accelerator immediately, as soon as the scene is updated in the current cycle. The application itself decides what and when to draw, and keeps full control over the order of calls.
This gives minimal latency between a state change and the appearance of the image — critical for responsive control in dynamic scenes, where reaction to touch within a single cycle matters.
Deferred rendering first collects a list of commands into a buffer, sorts and groups them by material and state, and only then sends them in a batch.
The gain is in reducing state switches and the number of calls: objects of the same type are drawn in succession, and the accelerator idles less between texture and shader changes.
On scenes with hundreds of identical objects, this noticeably boosts rendering performance and stabilizes frame time.
The choice of approach comes down to the profile of the scene, not to a "best" method. Forward rendering wins where there are few objects but they frequently change state, or where predictable input latency is needed.
Deferred — where there are many objects, they are static by material, and they can be grouped efficiently. A mixed variant is the most common: the interface and effects are drawn forward, while the background and mass objects go through the buffer.
The limitations of the methods are mirrored as well. Forward rendering hits a ceiling on the number of calls: the more objects, the higher the load on the processor and the more often the frame fails to fit within the budget.
Deferred adds memory for the command buffer and a latency of one to two frames, and also complicates work with transparency and layering order — sorting by state can conflict with sorting by depth.
In practice, the approach is not fixed once and for all: it is chosen for a specific scene and switched between modes according to its profile.
First, measurements are taken — where exactly frame time is lost, on the processor or on the accelerator — and the method is selected based on that.
This way, optimizing the rendering of a mobile game relies on data rather than habit, and maintaining a stable 60 frames becomes a manageable task.
Common technical concerns about rendering optimization
Before starting work, clients ask the same questions: will the game break on older devices, how long will it take, what will happen to the gameplay. Below are direct answers, without generalities.
Will optimization break rendering on weak devices?
No, if it is built on quality profiles rather than a single preset.
We take measurements on real devices from your audience, determine the frame budget for each class, and split the settings: somewhere we reduce particle density and shadow resolution, somewhere we switch the material to a cheaper one.
Weak devices get a stable frame without drops, flagships get the full picture. We verify compatibility before release, not after complaints.
How long does rendering optimization take?
It depends on the scale of the scene and the number of platforms. The initial audit with measurements and a plan takes a few days, then iterations on the bottlenecks.
If the problem is in one heavy effect, the fixes take days; if the entire rendering pipeline is being restructured, weeks. We give the exact timeline after measurements, not "by eye".
What are the risks of the changes and can they be rolled back?
The main risk is visual artifacts from aggressive quality reduction. That is why each change goes into a separate branch with before-and-after measurements, rather than one big commit.
Any step can be rolled back without losing previous improvements, and we keep reference builds for comparison.
Will optimization change the gameplay or the visuals?
The goal is to preserve the gameplay experience by removing unnecessary load. We do not cut what the player notices: key effects, scene readability, and control responsiveness remain. We remove hidden costs — extra draw calls, duplicate materials, invisible geometry. Visually the game looks the same, but runs more smoothly.
Do we need to rewrite the project for a new platform?
Usually not. Rendering optimization is targeted work with the existing code and settings, not a rewrite. We adapt the pipeline to the current architecture, so the release cycle does not stretch out, and the team keeps shipping updates in parallel.
If you still have concerns about your project — describe the task, and we will come back with an estimate and a work plan.
Let's discuss your rendering optimization task
To come back with an estimate and an optimization plan, we need more than an abstract "the game is lagging" request — we need a snapshot of the current rendering state.
The more specific the inputs, the more accurate the work estimate and the fewer iterations for approval.
What to send to get started:
- Frame profile: a profiler capture of a typical scene — where exactly frame time drops (rendering, logic, physics, resource loading).
- Target devices: the models on which the app must maintain stable frames, and current performance on them.
- List of heavy spots: scenes with the highest number of objects, effects, transparency, dynamic lighting.
- Sources and access: repository, branch, build, access to analytics systems and crash reports.
- Constraints: deadlines, platforms, requirements for compatibility with older devices.
From there we work in stages. First we reproduce the drops on a test bench and record baseline metrics — without this, any optimization turns into guesswork. Then we break down the bottlenecks: batching draw calls, resource reuse, offloading the main thread, levels of detail.
After that — an optimization plan with priorities: what delivers results immediately, what requires reworking scenes.
We agree on the plan, start work in short iterations with measurement after each step. The output is not only faster rendering, but also project handover: documentation of the changes, rules for the team, so the drops don't come back with the next content. Describe the task and send the inputs — we'll come back with an estimate and a plan.