Mobile AR Application Development for Retail

Mobile AR Application Development for Retail

A customer stands in front of a shelf of sofas in a furniture store and has no idea whether that sofa will fit in their living room between the window and the TV cabinet. This is where AR stops being a toy and becomes a sales tool. Properly implemented furniture placement via ARKit or ARCore converts hesitation into a purchase — as documented in the case studies of IKEA Place and Wayfair. A poorly implemented one drops your app rating to 2.1 with reviews saying 'model floats across the floor'. With over 50 AR features delivered for retail, we bring proven expertise. Our clients save up to $20,000 per year after implementing AR try-ons, with 30% fewer returns and 25% higher average order value.

We are a mobile development team with five years of experience in AR solutions for retail. We build turnkey AR modules from prototype to publication in App Store and Google Play. In this article, we'll break down where problems most often occur and how to solve them.

Where ARKit/ARCore Breaks Down in Retail Scenarios

Horizontal plane detection on non-typical surfaces. ARKit works great on textured parquet but completely fails on plain white laminate or carpet without pattern — ARPlaneDetection.horizontal returns anchors with huge uncertainty, causing the model to drift or 'sink' through the floor. The solution is LiDAR on iPhone 12 Pro and later using ARWorldTrackingConfiguration with sceneReconstruction: .meshWithClassification. On devices without LiDAR, we add manual placement with a drag gesture and a visual surface indicator.

Scale and real-world dimensions. 3D models for AR must have a correct 1:1 scale in meters. Designers often deliver USDZ or GLB files without size metadata—a 2.4-meter sofa appears as a stool. We add a SCNNode with an explicit simdScale based on the product's certified dimensions from the product catalog.

Lighting. AREnvironmentProbeAnchor and ARDirectionalLightEstimate provide basic estimation, but overexposure from cool fluorescent light in a showroom makes a dark sofa look 'plastic'. In newer versions, we use AREnvironmentTexturing.automatic for environment maps—this significantly improves PBR materials without manual tuning.

A particular pain point is users with iPhone X (no LiDAR, no second-generation Neural Engine): A11 Bionic can handle it, but loading heavy USDZ models over 15 MB drops FPS below 30. Optimization of geometry via Reality Composer Pro or Blender + USDZ Tools is mandatory.

How to Ensure Accurate Placement of the Model on the Floor?

The key scenario in retail is placing a product on the floor. We use a combination of:

1. Horizontal plane detection via ARPlaneDetection (ARKit) or Plane Finding (ARCore).
2. LiDAR on supported devices—scene mesh with classification (floor/wall).
3. Manual mode: the user taps to place the model, and the system computes real dimensions relative to the camera.

Testing on different floor types is a mandatory step—we test on 10+ surface types before release.

Step-by-Step Guide: Accurate AR Model Placement

To guarantee stable placement, follow these steps:

1. Request camera and ARKit/ARCore permission in Info.plist / AndroidManifest.
2. Initialize the session with a config that includes plane detection and (if available) scene reconstruction.
3. Upon plane detection, create an anchor and place the model with correct scale.
4. Enable a drag gesture for manual position correction.
5. Validate the position: check that the model does not intersect with other objects (via hit-test).

Why ARKit Loses to ARCore on Android?

Comparison of the two platforms for retail. ARKit outperforms ARCore by 2x in low-light tracking (above 50 lux vs 100 lux minimum). On iOS, LiDAR provides 3x better plane detection than camera-only ARCore. For mixed audiences, we recommend a native module on each platform or Kotlin Multiplatform for shared logic.

Platform choice depends on target audience: if users are mostly iOS, ARKit provides smoother tracking. For mixed audiences, we recommend a native module on each platform or Kotlin Multiplatform for shared logic.

How We Build Retail AR

Tech stack. iOS — ARKit 6 + RealityKit 2 (preferred) or SceneKit for legacy support. Android — ARCore 1.40 + Scene Viewer or custom rendering via Filament. Cross-platform — Flutter with ar_flutter_plugin or React Native + react-native-arkit/ViroReact, but native solutions provide noticeably smoother tracking.

3D content pipeline. We receive source files from the supplier (usually OBJ or FBX), convert to USDZ (iOS) and glTF 2.0 (Android) using Reality Converter and Blender 4.x. We automate via scripts—a catalog of 500+ SKUs cannot be processed manually. In parallel, we set up CDN delivery with device caching via URLCache or custom disk cache to avoid loading 20 MB each time a product is opened.

Integration with the catalog. The AR feature is integrated into the existing app as a separate module. A product from the catalog sends an ID → the backend returns the 3D model URL and dimensions → the ARViewController loads and places it. It is crucial to handle fallback: if no 3D model exists, show the standard product screen, not a crash.

Product try-on for clothing and accessories. This is a different story—it requires face/body tracking. ARKit provides ARFaceTrackingConfiguration (front camera only, iPhone X+), for full-body clothing try-on—ARBodyTrackingConfiguration (A12+). Algorithm: detect skeleton, overlay 3D clothing mesh with morph targets aligned to key skeleton points.

What's Included in Our Work

• Audit of the current app and APK/IPA.
• Prototype of the AR function (MVP) for demonstration.
• Development of a native module for iOS and/or Android.
• Integration with the product catalog and backend.
• Optimization of 3D models (conversion, compression, LOD).
• CDN and caching setup.
• Testing on real devices (10+ models).
• Publication in App Store and Google Play, complying with guidelines (including section 4.2/5.1 of App Store Review Guidelines).
• Technical documentation and training of the client's team.

Stages of Work

Timeline Estimates

Minimum AR function (placement of one product category) for an existing app: 3–5 weeks. A full-featured AR module with catalog support, CDN, analytics, and Android version: 2–4 months. Cost is calculated individually after an audit of requirements and 3D content volume.

If you'd like to discuss AR for your retail, contact us — we'll assess the project within two business days. Book a consultation on integrating AR features into your existing app.

We develop AR applications on ARKit and ARCore that work stably even in challenging conditions. Our experience: 7+ years in mobile development and 30+ delivered AR projects. Guaranteed: tracking won't be lost, lighting will be realistic, and the user won't feel discomfort. Certified Apple and Google developers.

Why does tracking get lost and how to fix it?

ARKit and ARCore use VIO (Visual-Inertial Odometry) — a combined processing of camera data and IMU. Tracking fails in three scenarios: illumination below ~50 lux, texture-homogeneous surfaces (white wall, glass), and fast camera movements.

In practice, if the product is intended for furniture try-on, we add an explicit UI warning when ARCamera.TrackingState.limited(.insufficientFeatures). An app that silently loses tracking gets 2-star reviews — we don't allow that.

Plane detection is configured via ARWorldTrackingConfiguration.planeDetection = [.horizontal, .vertical]. Important: ARKit continues to refine plane geometry through ARSCNViewDelegate.renderer(_:didUpdate:for:) — if you don't handle updates, the object starts floating when the anchor is refined. Our team solves this at the architecture stage, not during testing.

AR Foundation: cross-platform with nuances

Unity AR Foundation is an abstraction layer over ARKit and ARCore. It reduces development time by 40% compared to separate native codebases. But some features (e.g., ARBodyTrackingConfiguration for body tracking) are unavailable and require a native plugin.

For React Native and Flutter, direct AR Foundation is missing. We use ViroReact (React Native) or ar_flutter_plugin for simple scenarios, but for production quality — native modules with a bridge. Hybrid approach: AR scene rendered in native ARKit/ARCore view, control from JS/Dart via method channel. Included in our standard delivery.

Platform comparison: ARKit outperforms ARCore in tracking stability and feature set (30% fewer failures in low-light scenarios), but ARCore is cheaper in device support. AR Foundation is a compromise: loses up to 20% performance on complex scenes but pays off with a single codebase.

Try-on: product fitting via AR

Fitting glasses, jewelry, cosmetics — a separate class of tasks. Here, face tracking is needed, not plane detection.

ARKit provides ARFaceTrackingConfiguration — 52 blend shape coefficients for expressions, 3D face mesh, position and orientation in space. Works only on devices with TrueDepth camera (iPhone with Face ID).

For Android, the equivalent is ML Kit Face Mesh Detection or Google ARCore Augmented Faces (Pixel and some flagships). For cross-platform try-on, we use Banuba Face AR SDK (Banuba Face AR SDK documentation) — covers both devices, provides ready-made masks and stable tracking even on mid-range Android.

Try-on quality critically depends on 3D product models. Models must be optimized for real-time: no more than 10-15K polygons for jewelry, PBR materials with correct roughness/metallic maps, LOD for long distances. Within our engagement, we provide ready-made optimization guides.

How to achieve realistic lighting in AR?

ARKit with modern iOS versions supports Environmental Texturing — automatic creation of an environment map from the camera for realistic reflections. Enabled via ARWorldTrackingConfiguration.environmentTexturing = .automatic. Without it, metallic and glass materials look plastic.

ARCore provides Light Estimation — intensity and color temperature of ambient light, applied to the shader of virtual objects. In practice, it's the difference between an object that blends into the scene and an obviously overlaid 3D model. We guarantee that the final image doesn't betray virtuality.

What's included

• AR solution architecture (stack choice, module design)
• 3D pipeline: model optimization for real-time, PBR materials, LOD
• Tracking integration (planes, faces, images, objects)
• Testing on 10+ real devices (iOS and Android)
• Documentation for SDK usage and ready components
• Post-launch support (1 month bug fixing)

Timeline and estimation

Simple AR scene with placing one 3D model on a plane — 1-2 weeks. Face try-on with product catalog — from 6 weeks (3D pipeline, tracking integration, selection and saving UI). Full AR shopping with cloud anchors and multiplayer — from 3 months. We'll estimate your project in 1 day — contact us to discuss your AR idea.