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:
- Horizontal plane detection via ARPlaneDetection (ARKit) or Plane Finding (ARCore).
- LiDAR on supported devices—scene mesh with classification (floor/wall).
- 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:
- Request camera and ARKit/ARCore permission in Info.plist / AndroidManifest.
- Initialize the session with a config that includes plane detection and (if available) scene reconstruction.
- Upon plane detection, create an anchor and place the model with correct scale.
- Enable a drag gesture for manual position correction.
- 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.
| Parameter | ARKit | ARCore |
|---|---|---|
| Plane detection | Excellent on textured surfaces, poor on solid colors | Better on solid colors thanks to Visual-Inertial Odometry |
| Tracking in low light | Good above 50 lux | Requires >100 lux, worse in darkness |
| Lighting estimation | Environment probe + directional light estimate | HDR environment map only on limited devices |
| LiDAR support | Yes, on iPhone 12 Pro+ | No |
| Max simultaneously tracked images | 25 | 20 |
| Cross-platform integration | Reality Composer | Scene Viewer/ARCore Cloud Anchors |
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.
More about technical requirements
For stable AR performance, you need at least A12 Bionic (iOS) or Snapdragon 845 (Android). Recommended Snapdragon 8 Gen 2 and later for Android devices without LiDAR. For model loading, we recommend CDN caching with a Time To Live of at least 24 hours.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
| Stage | What We Do | Result |
|---|---|---|
| Analysis | Audit of current app, catalog study, 3D content requirements | Technical specification and architecture diagram of the AR module |
| UX Design | Use cases, wireframes, interaction prototype | Design mockups of AR screens |
| Development | Implementation of AR module, catalog integration, CDN setup | Working build for testing |
| QA | Testing on 10+ devices, different conditions and surfaces | Test report, bug fixes |
| Release | Metadata preparation, App Store Review Guidelines check, publication | App in stores |
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.