Lighting the Way: How I Optimized Mobile Game Performance with Light Baking & Probes

As game developers, we all love the look of real-time dynamic lighting.
Soft shadows. Atmospheric bounces. Reflections that make a scene feel alive.
On mobile, though, that beauty comes at a cost – frame drops, overheating devices and players who quietly uninstall your game.

While working on my recent mobile projects, I ran straight into this problem.
I wanted visuals that felt close to console quality, but real-time lighting was absolutely crushing performance on mid- and low-end Android devices.
That’s when I stopped chasing visual fidelity and started asking a different question:

How do I get the illusion of high-quality lighting without paying the real-time cost?

At first glance, everything looked fine.
The environments were lit nicely. Shadows looked correct. Reflections added depth.
But the profiler told a very different story.

• Real-time shadows from multiple point lights
• Frame rates dipping below 20 FPS on devices like the Samsung M14 5G
• GPU time dominated by lighting and draw calls

This wasn’t something I could fix with minor tweaks. The entire lighting approach needed to change.

The first decision was obvious in hindsight.
Most of my environment wasn’t moving. Buildings, floors, props none of these needed lighting calculated every frame.
So I switched to baked lighting.

• Marked static meshes as Static
• Baked lighting using Unity’s Progressive GPU Lightmapper
• Carefully balanced lightmap resolution to avoid memory spikes
• Combined meshes where possible to reduce draw calls

That worked until I hit a problem I hadn’t planned for.
One of my projects relied on procedural level generation using prefabs.
And Unity doesn’t store baked lightmap data inside prefabs by default.

When those prefabs were spawned at runtime, the baked lighting data was lost.
Levels appeared unlit or inconsistent. And because I was also using object pooling, reused prefabs looked visually wrong when spawned in different areas.
At that point, baked lighting and procedural generation were fighting each other.

The solution came from the community.
I found a free GitHub plugin that allows baked lightmap data to be saved directly inside prefabs.

• Procedurally generated levels stayed properly lit
• Pooled prefabs retained correct lighting
• Baked lighting and object pooling worked together instead of against each other

That single change closed a major gap in Unity’s lighting workflow and made my setup production ready.

Result: The same scene went from ~15 FPS with real-time lighting to ~55 FPS after baking—on the same device.

After baking the environment, a new problem appeared.
My player and collectibles looked flat almost disconnected from the world.

Light Probes solved this.
They sample baked lighting information and apply it to dynamic objects allowing them to blend naturally into the environment.

• Dense probe placement in corridors and gameplay paths
• Higher density near corners and lighting transitions
• Lower density in flat, evenly lit areas

Lighting looked correct but shadows were missing.
Dynamic objects were lit properly, but they weren’t casting shadows on baked surfaces. Characters looked like they were floating.

I considered enabling real-time shadows.
Then I profiled again.
On mobile, they were simply too expensive.

Instead of simulating accurate shadows, I switched to fake blob shadows.

• Simple blob shadow texture projected under the player
• Dynamically scaled based on jump height
• Extremely cheap, but visually convincing

On mobile, this kind of trade-off matters.
Sometimes faking what players expect is far smarter than simulating what they won’t notice.

Interestingly, reflection probes weren’t something I ended up using in this particular project.
But while I was deep into understanding light baking and light probes, reflection probes naturally came up and they changed how I think about realism on mobile.

At one point, I was tempted to push visual fidelity further by experimenting with reflective surfaces.
That’s when I realized an important distinction:
Just because a technique exists doesn’t mean it belongs in every project.

Reflection probes are a powerful middle ground between flat visuals and expensive real-time reflections.

They work especially well when:

• Surfaces are mostly static
• Reflections don’t need to update every frame
• The goal is believability, not physical accuracy

While this project didn’t require reflective surfaces, learning about reflection probes helped me make a clearer decision.

• Reflection probes capture the surrounding environment into a cubemap
• That cubemap is reused at runtime instead of recalculating reflections
• On mobile, this can deliver a strong visual boost at very low cost

I wasn’t avoiding them because I didn’t know how to use them. I was choosing not to use them because the gameplay didn’t benefit from them.

That distinction matters.

Optimization isn’t just about knowing techniques. It’s about knowing when not to use them.

With lighting stabilized and unnecessary features intentionally left out, I could focus on stacking smaller optimizations that actually mattered for performance.

• Object pooling for coins and power-ups
• Occlusion culling to avoid rendering unseen objects
• LODs for distant meshes
• Texture atlasing and compression
• Profiling on real devices (Mali & Adreno GPUs)

After applying these changes, the game consistently ran at 50–60 FPS on mid-range devices.
Visuals still felt polished and immersive. Close to what I originally wanted with real-time lighting, but without the performance cost.
Most importantly, the experience felt smooth.

• Design lighting for mobile first, not as an afterthought
• Bake what doesn’t move
• Use probes to bridge static and dynamic objects
• Balance quality against memory and performance
• Always profile on real hardware

Optimization isn’t about cutting corners.

It’s about making smart trade-offs so your game looks great and runs well where it matters. On the player’s device.

For me, light baking, probes and a mix of classic mobile techniques turned a struggling build into a smooth, visually rich experience and that’s a technical outcome I’m proud of.