Draw calls, memory, and battery—three enemies of any mobile Unity project. Even at 60 FPS on a flagship, the game can lag on Xiaomi Redmi Note 8 with 3 GB RAM: frames drop to 15 FPS when enemies appear, and the battery heats up in 20 minutes. Typical causes are lack of object pooling, unoptimized textures, and neglecting IL2CPP.
We are a Unity development team with 7+ years of proven experience. We have shipped over 20 mobile games, from hypercasual arcades to open-world RPGs. Our specialty is performance on devices with 2 GB RAM. We guarantee stable 30 FPS on targeted low-end devices after optimization. Order mobile game development on Unity—get a consultation for your project.
How to Ensure Performance on Low-End Devices
Draw calls and batching. On mobile GPUs the draw call budget is tight: 100–200 depending on the device. Static geometry → Static Batching. Same materials → GPU Instancing. Dynamic objects → Dynamic Batching (works for mesh objects < 900 vertices). We verify using Frame Debugger in Unity Editor.
Textures and memory. ASTC is the compression format for iOS and Mali/Adreno GPUs on Android. No PNG in 2048×2048 for UI icons sized 64×64. Use atlases via Sprite Atlas or manual packing. Monitor memory with Memory Profiler (package com.unity.memoryprofiler). A typical iOS issue: Texture2D is not removed from memory after Destroy() without explicitly calling Resources.UnloadUnusedAssets().
Object Pooling. Instantiate/Destroy on the hot path is the enemy of performance. Use UnityEngine.Pool.ObjectPool<T> (built-in) for pooling. Bullets, enemies, particles—everything through a pool.
IL2CPP and AOT. Mobile builds always use IL2CPP, not Mono. IL2CPP is 2–3 times faster than Mono when executing code on mobile devices. Reflection breaks the strip level: if ReflectionProbe or a custom serializer uses reflection, add a link.xml with explicit preserve directives. Otherwise, you get MissingMethodException in release builds that didn’t appear in Debug.
Why Project Architecture Matters
For mid-core mobile games we use MVVM + Services without a full ECS. Unity documentation recommends DOTS for maximum performance, but it’s overkill for most mobile projects up to arcade genre: Burst Compiler, Jobs System, and NativeArray require experience and increase development time.
State management via Zenject or VContainer (lighter alternative). Each service (AudioService, ScoreService, InventoryService) is injected via constructor, not FindObjectOfType. Use ScriptableObjects for game data configuration—levels, enemy stats, progression curves. Change balance without rebuilding APK/IPA using Addressables + remote config (Firebase Remote Config or Unity Remote Config).
Integrations for Mobile Production
Ads. Google AdMob via com.google.ads.mobile—banners, interstitials, rewarded video. Unity Ads as an alternative. Mediation via IronSource or AppLovin MAX to maximize eCPM.
In-App Purchases. Unity IAP (package com.unity.purchasing)—unified API for App Store and Google Play. StoreKit on iOS, Google Play Billing on Android. Server-side receipt validation is mandatory—client validation can be bypassed by Jailbreak/Root.
Analytics. Firebase Analytics (com.google.firebase.analytics) is the standard. Key events: level_start, level_end, level_fail, ad_impression, iap_purchase. Unity Analytics as a built-in alternative.
Crashlytics. Firebase Crashlytics—real-time crash reports. Integrated via com.google.firebase.crashlytics. Custom keys for context: Crashlytics.SetCustomKey("level", currentLevel).
CI/CD and Publishing
Fastlane for automation: gym for iOS build, supply for upload to Google Play, deliver for App Store. Unity Build Automation as an alternative for teams without custom CI.
GitHub Actions + game-ci/unity-builder—free CI for Unity with caching of Library folder (saves 10–30 minutes per build).
App size. APK split by ABI—separate files for arm64-v8a, armeabi-v7a, x86_64. On iOS, App Thinning automatically via Xcode. Asset Bundle Compression—LZ4 for fast loading, LZMA for minimal size.
Deliverables and Post-Release Support
- Project architecture documentation and Game Design Document
- Core gameplay prototype and vertical slice with source code access
- Integration of ads, purchases, and analytics (including SDK documentation)
- Performance optimization for dozens of devices (profiling on real hardware, report provided)
- Publishing to App Store and Google Play (certificates, metadata, store listing assistance)
- Post-release support: bug fixing, content updates, crash monitoring via Crashlytics
- Training for your team on maintaining and updating the game
Step-by-step game optimization plan
- Profiling: run on a low-end device (Snapdragon 660, iPhone SE 2nd gen), record frame time, identify bottlenecks using Profiler and Frame Debugger.
- Graphics optimization: reduce draw calls (batching, atlases), downscale textures, use LOD.
- CPU optimization: object pooling, component caching, avoid
Update()on inactive objects. - Memory optimization: timely resource unloading, Asset Bundle compression, limit loaded textures.
- Testing: re-profile, check FPS and stability on multiple devices.
| Approach | Performance | Implementation Complexity |
|---|---|---|
| Static Batching + GPU Instancing | High | Low |
| Additional: Object Pooling | Medium | Medium |
| Full: ECS (DOTS) | Maximum | High |
According to Unity documentation, "Proper memory management can increase FPS by 20–30%."
Development Stages
Prototype (core gameplay loop) → vertical slice (one full-content level) → alpha (all mechanics, no polish) → beta (device testing, optimization) → release.
Between alpha and beta—mandatory profiling on real hardware: old Android (Snapdragon 660, Mali G72) and iPhone SE 2nd gen. If these devices maintain stable 30 FPS, the product is ready for a wide audience.
Timelines and Cost
| Game Type | Team Size | Estimated Time | Estimated Cost |
|---|---|---|---|
| Hypercasual / Casual | 2–3 people | 2–4 months | $10,000 – $25,000 |
| Midcore (RPG, strategy) | 4–6 people | 6–12 months | $30,000 – $100,000 |
| Complex mechanics, online multiplayer | 6+ people | 12+ months | $100,000+ |
Cost is calculated after reviewing the GDD (Game Design Document) and platform technical requirements.
Get a consultation on optimization and monetization of your game—contact us to discuss details. Order mobile game development on Unity—we’ll help you take the project from idea to release.