Mobile AR Content Optimization: LOD, Shaders, Testing

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.