Mobile Game VFX and Particle System Development

We develop particle systems and VFX for mobile games that look convincing even on budget devices. In our practice, a desktop effect with 50,000 particles on an iPhone 11 led to overheating and 20 FPS. We found the limit: the effect looks quality at 10,000 particles or fewer while maintaining thermal stability. With over 5 years of accumulated experience, we select the optimal stack and technique for each platform. A proper particle system increases player retention by 15% according to our data, without requiring expensive devices.

Tool selection: Unity vs SpriteKit vs Metal

Most mobile games use one of three: Unity's built-in Particle System (Shuriken), Apple SpriteKit SKEmitterNode, or a custom system on Metal/OpenGL ES/Vulkan for special requirements. Compare them in the table.

Unity's Shuriken is the de facto standard. Visual editor, Sub Emitters support, GPU Instancing, Burst compiler for CPU simulation. VFX Graph (GPU simulation via Compute Shaders) works on mobile starting from Metal (iOS 12+) and Vulkan (Android API 24+). On older devices VFX Graph is not available — a fallback to Shuriken is needed.

SpriteKit SKEmitterNode is for 2D games natively on iOS. Simple, fast, no Unity overhead. But limited: no Sub Emitters, no custom shaders without Metal. For simple effects (fire, rain, confetti) it's sufficient.

Which tool to choose for VFX in a mobile game?

If the project is cross-platform, take Unity's particle system. For iOS-only 2D games, SpriteKit is enough. If you need unique effects with full control, write custom shaders on Metal. Our team ensures that the chosen stack does not hit GPU limitations on target devices.

Particle budget and GPU limitations

On mobile GPUs (Apple A-series, Adreno, Mali) the bottleneck is often not the number of particles, but overdraw — the number of times a single pixel on screen is redrawn per frame. Source: Apple Developer Documentation

Transparent particles with additive blending give overdraw multiplied by the number of layers. An explosion of 5000 particles in the center of the screen can have real overdraw of 50–100x. This kills fill rate even on A15.

Strategies to reduce:

• Texture Atlasing: all particle sprites into one 512×512 or 1024×1024 atlas. Reduces draw calls on texture change.
• Billboard imposters: for volumetric effects (explosion cloud) — a quad with baked texture instead of hundreds of spheres.
• Particle LOD: at distance/low fps — reduce maxParticles by half via QualitySettings.particleRaycastBudget or custom LOD manager.

How to optimize particle overdraw step by step:

1. Identify the worst overdraw using GPU profiler (e.g., Xcode Metal Debugger).
2. Reduce the number of transparent layers by using additive blending only for glowing parts.
3. Apply texture atlasing to all particle sprites.
4. Set up LOD system to halve particle count below 45 FPS.
5. Test on weakest target device (e.g., iPhone SE 2016) to confirm 60 FPS.

// Unity: dynamic LOD for particle system based on FPS public class ParticleLODManager : MonoBehaviour { [SerializeField] private ParticleSystem targetSystem; private ParticleSystem.MainModule _main; private float _fpsTimer; private int _originalMax; void Start() { _main = targetSystem.main; _originalMax = _main.maxParticles; } void Update() { _fpsTimer += Time.deltaTime; if (_fpsTimer < 1f) return; _fpsTimer = 0; float fps = 1f / Time.smoothDeltaTime; if (fps < 45f) { _main.maxParticles = Mathf.Max(100, _main.maxParticles / 2); } else if (fps > 58f && _main.maxParticles < _originalMax) { _main.maxParticles = Mathf.Min(_originalMax, _main.maxParticles * 2); } } } 

Why is overdraw the main performance enemy?

GPU simulation via VFX Graph runs 4x faster than CPU simulation on A14 Bionic, but overdraw eats that gain. With additive blending, each pixel can be redrawn dozens of times. To avoid this, we apply texture atlasing and reduce the number of particles with high alpha overlap.

Custom shaders for mobile VFX

Built-in Unity shaders for particles (Particles/Standard Unlit) are safe but limited. For dissolve effect, heat distortion, energy shield — a custom shader is needed.

On mobile the rules are strict: no discard in shader (breaks early Z-test, fill rate drops), minimal texture samples, avoid dependent texture reads. Shader Model 2.0 as baseline for wide coverage.

Example of a simple distortion effect for an explosion (Unity HLSL):

CGPROGRAM #pragma vertex vert #pragma fragment frag #include "UnityCG.cginc" sampler2D _NoiseTex; float _DistortionStrength; float _FadeEdges; fixed4 frag (v2f i) : SV_Target { float2 noise = tex2D(_NoiseTex, i.uv + _Time.y * 0.3).rg * 2 - 1; float2 distortedUV = i.uv + noise * _DistortionStrength * i.color.a; float edge = 1 - saturate(distance(distortedUV, float2(0.5, 0.5)) * _FadeEdges); fixed4 col = tex2D(_MainTex, distortedUV) * i.color; col.a *= edge; return col; } ENDCG 

i.color.a is the particle alpha from Unity Particle System, synchronized with lifetime. Distortion fades with the particle automatically.

Effects on SpriteKit: fire and confetti

SKEmitterNode can be configured either in Xcode editor (.sks file) or programmatically. Programmatically is preferable for dynamic parameters:

func makeFireEmitter() -> SKEmitterNode { let emitter = SKEmitterNode() emitter.particleTexture = SKTexture(imageNamed: "spark") emitter.particleBirthRate = 120 emitter.particleLifetime = 1.2 emitter.particleLifetimeRange = 0.4 emitter.particleSpeed = 80 emitter.particleSpeedRange = 40 emitter.emissionAngle = .pi / 2 // upward emitter.emissionAngleRange = .pi / 8 emitter.particleScale = 0.15 emitter.particleScaleSpeed = -0.1 emitter.particleAlphaSpeed = -0.8 emitter.particleColorSequence = SKKeyframeSequence( keyframeValues: [SKColor.yellow, SKColor.orange, SKColor.red, SKColor.clear], times: [0, 0.3, 0.7, 1.0] ) emitter.particleBlendMode = .add return emitter } 

.add blending — additive blending. Fire and sparks look luminous. Not used for smoke and dust — there .alpha is needed.

GPU profiling tools

Xcode Metal Debugger — frame capture for Metal games. See every draw call, textures, overdraw visualization. For Unity on iOS: through Xcode GPU Frame Debugger when connected via USB.

Android GPU Inspector (AGI) — from Google for Adreno and Mali. Frame Profiler shows pipeline stages where GPU waits.

Unity Profiler — built-in, shows CPU/GPU time for each effect render. Rendering → ParticleSystem.Update takes more than 2ms — look at CPU simulation and reduce maxParticles or switch to GPU Mode.

What is included in the work

• Custom shader development for target platform
• Optimization of existing particle systems (LOD, atlasing, overdraw)
• Integration into game engine (Unity, SpriteKit, custom)
• Profiling and tuning for weak devices (e.g., iPhone SE 2016)
• Documentation of parameters and support
• Training for your team on how to use and extend the VFX
• Ongoing support for the first month after delivery

Process of work

Technical art direction: what effects are needed, their frequency on screen simultaneously, target devices. Development of shaders and particle systems in the editor with profiling on a weak Android device. LOD system setup. Integration into the game engine, thermal throttling test (10-minute gaming session with temperature analysis).

Time estimates

3–5 working days for a basic VFX set (3–5 effect types) starting at $500. Complex custom system on Metal Compute Shaders — from 2 weeks, starting at $2000. The exact cost is calculated individually after analyzing your requirements. We will evaluate your project: contact us for a preliminary analysis. Get a consultation on tool selection for your effects.

Overdraw reduction techniques comparison table