AR-app runs flawlessly on A17 Pro but heats up and drops to 20 FPS within two minutes on Snapdragon 720G. This isn't a device bug—it's a consequence of differing capabilities between ARKit and ARCore, and 3D content created without target device constraints will never perform uniformly across the fleet. We face such tasks daily and have developed an approach that guarantees stable AR even on devices with limited resources. With 7+ years of AR development experience and 30+ successful projects, we deliver robust AR content optimization that can save up to 40% on rework costs.

How We Define Target Devices

AR performance directly depends on device class. We divide all smartphones into three tiers and select optimal settings for each.

On iOS, the tier is determined via MTLCreateSystemDefaultDevice().supportsFamily(_:); on Android via Build.VERSION.SDK_INT, ActivityManager.getMemoryClass(), and Session.isDepthModeSupported(). This device tiers approach ensures every user gets an acceptable experience without overheating or lag. Device Tiers reduce testing time by 3x compared to manual per-device tuning, making AR content optimization faster and more cost-effective.

How We Optimize AR Content End-to-End

Our AR content optimization service includes:

1. Audit of current 3D models and shaders: check polygon budget, texture format, PBR usage.
2. LOD and adaptive texture setup: automatic switching to simplified models when far from camera, texture optimization for ASTC.
3. Device Tiers implementation with dynamic switching: code logic to determine device class and load appropriate content.
4. Testing on 5+ real devices of different classes: check FPS, thermal throttling, session stability.
5. Documentation and team training: architecture description, instructions for adding new models.
6. Post-implementation support: integration assistance and updates for new devices.

What's Included in Our Deliverable Package

• Optimized 3D models with LOD
• Device tier configuration script
• Testing report on 5+ devices
• Developer documentation for future maintenance
• Team training session
• 30 days of post-launch support

Platform Limitations: ARCore vs ARKit

ARCore minimally requires OpenGL ES 3.0 or Vulkan. Depth API (obtaining depth map from sensor) is available only on devices from the Wikipedia: ARCore list—roughly 30% of active Android devices. Instant Placement, Scene Semantics cover an even smaller percentage.

ARKit on iOS is more homogeneous, but still has division: LiDAR is available from iPhone 12 Pro. Scene Reconstruction (real-world mesh) requires LiDAR. Without it—only planar detection.

A common mistake: the app is developed on a Pro device with LiDAR, then it turns out 70% of the target audience uses devices without LiDAR, and the entire experience must be reworked. We initially orient towards the client's minimum requirements and test on devices that your customers actually use.

Optimizing 3D Models for AR

The polygon budget for AR on mobile is stricter than for games because AR rendering is added on top of the camera feed, which itself consumes GPU resources.

Practical guidelines:

• Foreground detailed object: up to 10,000 polygons
• Mid-ground auxiliary object: 1,000–3,000
• Small decorative elements: 100–500

LOD (Level of Detail) in AR is mandatory. SceneKit and RealityKit on iOS support LOD via LODComponent. In Unity with AR Foundation — standard LOD Group. Switching to a simplified model when the object moves away from the camera reduces load without visible loss. Comparison: dynamic LOD reduces GPU load by 2–3x compared to a single high-polygon asset. This AR content optimization technique is essential for maintaining 30 FPS on low-end devices.

Textures: ASTC for iOS and Android. For AR objects of normal size, 512×512 is sufficient—the user looks at the real world, texture details aren't that noticeable. 2048×2048 for an AR object the size of a cup is overkill.

Adaptive Quality by Device Capability

Device Tiers strategy: determine device class at launch and adjust content quality.

// iOS: determine tier by GPU family
let device = MTLCreateSystemDefaultDevice()
if device?.supportsFamily(.apple7) == true {
    // A15+: maximum quality, LiDAR features
    loadHighQualityAssets()
} else if device?.supportsFamily(.apple6) == true {
    // A14: medium quality
    loadMediumQualityAssets()
} else {
    // A12-A13: base, no heavy effects
    loadBaseQualityAssets()
}

On Android: Build.VERSION.SDK_INT + ActivityManager.getMemoryClass() + check for ARCore Depth API support via Session.isDepthModeSupported().

Shaders and Post-Processing

Custom PBR shaders in AR are heavier than standard because AR objects must visually blend into the scene: ambient occlusion, shadows on real surfaces, reflections from the environment.

On low-end devices, we disable:

• Real-time shadows (replaced with fake shadow—a sprite under the object)
• Bloom and other post-effects
• Environment reflections (replaced with static cubemap)

In RealityKit, these parameters are controlled via RenderOptions and Environment. In Unity AR Foundation—via Universal Render Pipeline with adaptive Renderer Features.

How to Optimize Shaders for Different Devices?

Shaders are the main GPU consumer. Use Shader Graph with variant branches for different GPU families. For example, for low-end, disable mattes, complex normal maps, and transparency. Our shader optimization improves FPS by up to 50% on mid-range devices, making quality 2x better than unoptimized shaders.

Why Testing on Mid-Range Matters

Mid-range devices constitute >50% of the market. Testing only on a flagship gives a false sense of stability. On mid-range, we check thermal throttling: 5 minutes of active AR → measure FPS via fps metric or CADisplayLink callback. If FPS drops after 3 minutes—overheating, need to dynamically lower quality when ProcessInfo.thermalState >= .serious.

Minimum testing set:

• Current-year flagship (iPhone 15, Pixel 8)
• Mid-range 2–3 years old (iPhone 12, Samsung Galaxy A54)
• Low-end without LiDAR/Depth API (iPhone SE 3rd gen, Xiaomi Redmi Note 11)

Contact us for an audit of your AR project—we will propose an optimal work plan and timeline. Get a turnkey AR optimization solution in just 2–3 weeks. Write to us for a free project evaluation (includes full documentation and developer training). Our services start at $2,500 and can save up to 40% on rework costs. With over 7 years on the market and 30+ projects, we are your reliable partner for AR content optimization.

Mobile App Performance Optimization: Cold Start, Memory, Battery, FPS, Profiling

We often see mobile apps with a cold start time of 4+ seconds losing users before the first screen. Android Vitals in Google Play Console directly affect search ranking: apps with poor metrics get less organic reach. Apple similarly monitors crash rate and launch time via MetricKit. Optimization is not about “making it faster” – it’s about understanding exactly where time is lost and what to do about it. With over 10 years of experience in mobile performance optimization, we’ve helped clients reduce cold starts by 60% and increase retention by 20%. Per Android Vitals documentation, apps with poor performance rank lower, making this a critical revenue driver.

How to Profile Mobile App Performance?

Cold Start: Where Time Is Killed Before the First Frame

Cold start — launching the app when the process is not in memory. On Android, this is the time from tapping the icon to Activity.onWindowFocusChanged(hasFocus = true). On iOS, from tap to viewDidAppear of the first screen.

Android: Main Thread Overloaded During Initialization

Application.onCreate() — the main enemy of fast start on Android. Developers initialize everything here: Firebase, Analytics, database, HTTP client, DI container. Each SDK adds 20–200 ms on the main thread.

Diagnostic tool: Android Studio Profiler → App Startup. Shows the initialization graph with time for each component. Alternative: Tracing.beginSection(“MyInitTag”) in code + systrace.

Solution: App Startup Library (Jetpack) with an explicit dependency graph of initializers. Components needed only in specific scenarios are lazily initialized — by lazy {} or initializer with lazyInit flag. Firebase Analytics, for example, is not needed until the first user action — its initialization can be deferred.

ContentProviders added automatically by SDKs via AndroidManifest merge also run at startup. tools:node=”remove” in the manifest allows disabling a specific provider and initializing the SDK manually when needed.

Another pitfall: Room.databaseBuilder().build() on the main thread. This synchronous database file creation/open operation on slow devices takes 50–300 ms. Move it to a coroutine with Dispatchers.IO, in ViewModel via viewModelScope.launch.

iOS: Dyld Linking and +load

On iOS, cold start is divided into pre-main (before main() is called) and post-main. Pre-main — time for loading dylibs, rebase/binding, Objective-C runtime initialization, and executing +load methods.

Xcode Instruments → App Launch template shows pre-main and post-main time separately. DYLD_PRINT_STATISTICS=1 in the launch scheme outputs detailed load times to the console.

Factors killing pre-main:

• Many dynamic libraries (each dylib adds linking overhead). CocoaPods adds a separate dylib per pod. Solution: Swift Package Manager with static linking (type: .static) or use_frameworks! :linkage => :static in CocoaPods. Static linking through SPM cuts pre-main time by 40% compared to dynamic frameworks.
• +load methods in Objective-C — executed synchronously when the class is loaded, before main(). Third-party SDKs may abuse this. +initialize — lazy alternative, called on first access to the class.

Post-main — application(_:didFinishLaunchingWithOptions:). Same story as on Android: synchronous initialization of everything. Use lazy var for services not needed immediately. SwiftUI @StateObject initializes the object only when the view appears — built-in laziness.

Target metrics (App Store recommendations): cold start < 400 ms for simple apps, < 2 seconds for complex ones. Warm start (process in memory, but Activity/Scene is recreated) — < 1 second. After optimization, we typically see cold start drop from 3.2s to 1.1s on mid-range devices.

Memory: Leaks, OOM, Excessive Pressure

Memory leak on iOS — retention cycle: object A holds a reference to B, B holds a reference to A, neither is released. Classic: Timer with self in closure without [weak self]. Timer holds the closure, closure holds self (ViewController), ViewController is not released when closed. Instruments → Leaks finds alive objects that should not be there.

On Android, garbage collector manages memory, but leaks still happen. Activity or Fragment held by a static reference, singleton, or Handler/Runnable after onDestroy — classic. LeakCanary is mandatory in debug builds. Add one dependency debugImplementation “com.squareup.leakcanary:leakcanary-android” and it automatically detects leaks with full stack traces.

OutOfMemoryError is most often due to image loading. Bitmap in memory occupies width × height × 4 bytes. An image 4000×3000 px — 48 MB in memory, regardless of file size on disk. Glide / Coil handle this correctly: load with downsampling to the View size, cache in LRU cache. Loading into ImageView without Glide/Coil via BitmapFactory.decodeFile is a path to OOM on devices with 2 GB RAM. After switching to Coil, memory consumption dropped by 50% in our projects.

On Flutter, the Dart VM has its own GC, but native resources (images, textures) are not managed by Dart GC. Image.network caches images in memory without automatic release when leaving the widget tree — for long lists with images, use cached_network_image with proper memCacheWidth/memCacheHeight.

Why Does Cold Start Take So Long? Common Causes

What Profiling Tools Are Essential for Mobile Performance?

FPS and UI Performance

60 FPS — 16.67 ms per frame. 120 FPS (ProMotion) — 8.33 ms. Anything taking longer on the main thread causes jank.

Typical causes of FPS drops:

On iOS: synchronous image decoding in cellForRowAt. When a table cell appears, UIImage(contentsOfFile:) decodes JPEG/PNG on the main thread — visible as jerky scrolling on long lists. Solution: UIImage.preparingForDisplay() (iOS 15+) or ImageIO with kCGImageSourceCreateThumbnailWithTransform on a background queue, result via DispatchQueue.main.async.

On Android: RecyclerView.Adapter.onBindViewHolder with synchronous operations. Databases, file system, synchronous network requests on the main thread — StrictMode.ThreadPolicy with detectAll().penaltyLog() in debug builds will show all violations.

On Flutter: build() method is called frequently; it must be cheap. setState() on a top-level widget rebuilds the entire tree. const constructors, RepaintBoundary, splitting into small widgets with local state — main tools. Flutter DevTools → Performance shows janky frames (red) with causes.

Compose profiling: Recomposition Highlighter and tracing via Trace.beginSection in @Composable. Use remember for expensive computations, derivedStateOf for computed values, LazyColumn instead of Column + forEach for long lists. Across projects, jank frames dropped from 12% to 2% after implementing these patterns.

Battery: Wake Locks, WorkManager, Network Requests

An app that tops the battery usage list — users see it in settings and uninstall. Android Battery Historian (from ADB bug report) shows detailed timeline: wake locks, wakeups, network activity, sensor usage.

Main energy consumers:

• Continuous GPS (covered in maps-geo)
• Polling network every N seconds instead of push
• Holding wake lock longer than necessary
• Excessive AlarmManager wakeups

WorkManager with Constraints is the correct way to schedule background tasks: setRequiredNetworkType, setRequiresBatteryNotLow, setRequiresCharging. The OS batches tasks and executes them at convenient times.

On iOS, BGTaskScheduler with BGProcessingTaskRequest (for heavy tasks during charging) and BGAppRefreshTaskRequest (for lightweight updates) — the system decides when to execute, the developer only registers and implements the logic.

Batching network requests: instead of 10 separate requests in a minute — one batch request. Fewer radio activities (LTE radio consumes a lot during connection initialization), fewer wakeups. This typically cuts battery usage by 30% in network-heavy apps.

How We Optimize Your Mobile App Performance: Step by Step

Optimization Process

1. Measure – Profile cold start, memory, FPS, battery using the tools above. Obtain baseline numbers (e.g., cold start 3.2s, memory footprint 180 MB, 12% jank frames).
2. Analyze – Identify top 3 bottlenecks by impact. For a typical e‑commerce app, image loading and SDK init are priority.
3. Implement – Apply fixes: lazy init, static linking, image pipeline swap, background thread offloading. We deliver code changes with diff reports.
4. Test – Profile again; compare before/after numbers. Validate on real devices (including low-end).
5. Monitor – Set up MetricKit (iOS) / Android Vitals alerts to catch regressions after release.

Deliverables:

• Detailed profiling report with before/after metrics
• Annotated code diffs for each optimization
• Configuration recommendations (e.g., ProGuard rules, build settings)
• Monitoring setup (Firebase Performance, Crashlytics alerts)
• Knowledge transfer session for your team

Estimated Timeline

Costs are calculated individually based on app complexity and current codebase state. Contact us for a project estimate and performance review.

Profiling Tools Reference

MetricKit on iOS is especially valuable: real data from user devices, not simulator. MXMetricManager receives aggregated metrics once a day: MXAppLaunchMetric, MXHangDiagnostic, MXCPUExceptionDiagnostic. Diagnostics for hang and CPU-exceptions contain stack traces from real devices — gold for diagnosing production issues.

We guarantee measurable improvements within two weeks of optimization — average cold start improvement of 60% across 50+ completed projects. Get in touch for a tailored performance review.