Developing AR Furniture Try-On: From Concept to App Store

The standard was set by IKEA Place, but today users demand more: furniture must stand strictly horizontal, cast shadows correctly, interact realistically with room lighting, and not fall through the floor on devices without LiDAR. We have implemented similar projects for clients with catalogs up to 1000 items — and we know every detail. Our 5+ years of experience and over 10 delivered projects guarantee that a sofa won't sink into the floor and a cabinet will align perfectly with the wall.

Problems Without LiDAR

On devices without LiDAR, ARKit relies solely on a monocular image. The error in detecting horizontal planes can reach 10 cm, and object occlusion does not work — virtual furniture always renders over real. LiDAR solves both problems: plane detection accuracy improves to 2 cm (5 times more accurate), and through sceneReconstruction, correct occlusion is enabled. Here's a comparison:

Plane detection accuracy without LiDAR is 5 times worse, which is critical for large furniture — a cabinet may have a noticeable tilt.

Preparing 3D Models for AR: Common Mistakes

This is often an underestimated part of the project. A catalog of 500 items, each as GLTF with correct PBR materials, proper real-world size metadata, and pivot point strictly at the bottom plane of the object.

Typical problems when receiving models from the client:

• Pivot point at object center — a table floats in the air at its center height
• Scale in centimeters instead of meters — a sofa the size of a kitchen
• Textures in separate files (not embedded in GLB) — model loads without textures
• Y-up vs Z-up mismatch — a table lies on its side

Conversion and normalization of the catalog via Blender Python API (batch script) or through Cesium ion / Sketchfab API — depends on catalog scale. ARKit documentation recommends using a consistent coordinate system.

Placing the Object: From Raycast to Stable Position

The standard pipeline uses ARRaycastQuery, but for furniture there are specifics: objects are large, and the user wants to place them not in the center of the room but against a specific wall. This means:

1. Detecting both horizontal and vertical planes simultaneously
2. Snapping to walls — the object 'sticks' at a distance of 15 cm from a vertical plane
3. Collision detection between objects — two sofas should not overlap

Collision detection in RealityKit — CollisionComponent with ShapeResource.generateBox(size:). ARView.scene.subscribe(to: CollisionEvents.Began.self) — collision event. On intersection — visual red highlight and placement forbidden.

How to Automate the Conversion of 500 Models?

We use a batch script on Blender Python API that processes up to 200 models per hour. This cuts catalog preparation time from weeks to 2–3 days. Time savings — up to 70% compared to manual editing of each model.

Realistic Lighting: Automatic vs Manual

ARWorldTrackingConfiguration.environmentTexturing = .automatic — ARKit builds an HDR environment map from the camera. This works, but with a delay: the first 5–10 seconds the object is lit incorrectly. For a furniture app where the user sees the object immediately after placement — this is noticeable.

Improvement: AREnvironmentProbeAnchor with manual placement in the center of the room. Allows forced update of the environment map on demand (e.g., via a 'refresh lighting' button).

Multi-Object Placement and Scene Saving

The user places several items, wants to save the result and return later. ARSession.getCurrentWorldMap(completionHandler:) — saves the ARWorldMap state with anchors as Data. On next launch: ARWorldTrackingConfiguration.initialWorldMap = savedMap, ARKit relocalizes and restores object positions.

Works only in the same room with sufficient lighting. Relocalization takes 3–15 seconds.

Comparison of saving methods:

Screenshot for sharing — ARView.snapshot(saveToHDR:completion:) + UIActivityViewController.

What's Included in the Work

• Preparation and conversion of 3D models (up to 500 items)
• Integration of ARKit (iOS) / ARCore (Android) with plane detection, raycasting, collisions
• Configuration of LiDAR occlusion and scene reconstruction
• Implementation of wall snapping and inter-object collisions
• Scene saving and loading (ARWorldMap / Cloud Anchors)
• Testing on 10+ real devices
• Publishing to App Store and Google Play (documentation, metadata)
• Training the client's team on the toolset

Timelines

Basic single-object placement with plane detection — 5–7 days. Multi-object with collisions, wall snapping, scene saving — 3–5 weeks. LiDAR occlusion support — plus 1 week. Catalog model conversion is estimated separately by volume. Cost is calculated individually based on analysis of your catalog and technical requirements. Contact us for a detailed discussion of your project — we will prepare a technical specification and commercial proposal. Get a consultation right now.

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.