Dunelm: LiDAR Supported AR "View-in-Room" Experience

Quick Summary

• Role: Co-Founder & Lead Developer
• Duration: September 2017 - January 2021
• Platforms: iOS, Android
• Engine: Unreal Engine (C++)
• AR Frameworks: ARKit, ARCore
• Distinguishing: LiDAR depth-based occlusion + unified AR abstraction layer

Timeline (2017-2022)

• 2017: MVP/PoC and first customer demos.
• 2018-2020: productization, Dunelm partnership, asset pipeline and AR deployment flows.
• 2021: final improvements and handover (closing of my active contribution).
• 2022: Dunelm customer launch (after my active contribution).

Problems and Constraints

• Need for accurate scale and realistic placement to reduce return rates.
• Performance limits and different sensor capabilities on mobile devices.
• ARKit/ARCore API differences and cross-platform consistency.
• Making the large product catalog AR-ready.
• E-commerce integration and up-to-dateness of data.

Solution Summary

I designed a unified abstraction layer for ARKit/ARCore by building the view-in-room experience on Unreal Engine. Both visual realism and compatibility with e-commerce flows were achieved with LiDAR-supported depth occlusion, PBR materials and product data pipeline.

Architecture at a Glance

• Unified AR session layer: Bringing ARKit/ARCore differences into a single API.
• Coordinate transform and plane detection normalization.
• Render pipeline: PBR materials, shadow/light adaptation, LOD.
• Product data flow: REST API -> cache -> streaming -> AR scene.

LiDAR Occlusion (Depth-Based) + Fallback Strategy

I applied per-pixel occlusion using depth map on LiDAR supported iOS devices and ensured that real objects correctly concealed virtual products. On non-LiDAR devices, I used a lighter fallback flow with plane-based occlusion and depth estimation.- Depth map -> occlusion shader -> stable mask with temporal filtering.

• Non-LiDAR fallback: plane occlusion + simplified edge smoothing.
• Trade-off: high realism vs battery/performance cost.

Cross-Platform AR (ARKit + ARCore)

I normalized ARKit and ARCore's different coordinate systems with runtime transformations to provide a single positioning and scaling flow. Parity was preserved with session initialization and feature gating according to device capabilities.

Product Data & Asset Pipeline

Product information and 3D assets were retrieved via REST API; A fast start was aimed with the cache layer and progressive streaming. 3D models are optimized for mobile with LOD, texture compression and PBR material standardization.

Performance & QA

• Profile and regression tests on iOS/Android device matrix.
• LOD and texture quality adjustments according to GPU/CPU budget.
• Limit tests for battery consumption and thermal throttling.

Impact/Results

• App adoption - 100k downloads (first 3 months) - source: App Store Connect/Play Console (verifiable via Dunelm internal analytics).
• Conversion increase - +35% - period: [X], baseline: AR sessions vs. non-AR sessions - source: GA4/Firebase (can be added if verified).
• Return rate reduction - -40% - period: [X], baseline: pre-AR - source: Dunelm internal BI (may be added if confirmed).
• Session duration increase - +50% - period: [X] - source: analytics (can be added if verified).

Key Trade-offs

• Unreal Engine choice: visual quality increase, but at the cost of mobile optimization.
• LiDAR-only quality vs coverage: balance with non-LiDAR fallback.
• High resolution assets vs fast opening: streaming + LOD.
• Realism vs battery consumption: shader and post-processing limits.

FAQ

How does LiDAR occlusion work?

Per-pixel occlusion is applied via the depth map; real objects accurately hide virtual objects.

What happens with non-LiDAR devices?

Basic realism is preserved with plane-based occlusion and attenuated depth estimation.

How was scale accuracy achieved?

Product dimensions are pulled from the REST API with metric values ​​and applied exactly to the scene.

How was performance measured?

FPS, memory and loading times were tracked with profile tools and device matrix tests.

How was the asset pipeline constructed?

Product models were optimized with LOD + texture compression and loaded with progressive streaming.

How were the telemetry and quality tracking?

Error, performance and usage logs were monitored regularly with device/OS segmentation.

How were ARKit/ARCore differences handled?

A single flow was achieved with the unified abstraction layer and runtime feature gating.

Related Projects

• Rapid Render: Real-Time 3D Product Configurator
• Mulcol: VR Firestop Assembly Simulation
• Mulcol: AR Assembly Catalog (Marker-Based)

Project Imprint

• Company/Client: Dunelm (UK)
• Company: Lindow Labs (co-founder)
• Role: Co-Founder & Lead Developer
• Duration: September 2017 - January 2021
• Platforms: iOS, Android
• Engine: Unreal Engine (C++)
• AR Frameworks: ARKit, ARCore, LiDAR
• Launch: June 2022 (Dunelm side; after my active contribution)
• Location: London, UK / Istanbul, Türkiye (remote)