Developing a Mobile AR Application for Construction

Developing a Mobile AR Application for Construction

A BIM model of a building weighs 800 MB and lives in Autodesk Revit on a workstation. The site foreman looks at a tablet and tries to correlate the drawing with what stands before them. AR bridges this gap: properly implemented IFC model alignment to real space allows seeing wiring inside a wall before it's plastered. Done wrong, drift accumulates in 10 seconds and reinforcement "floats" half a meter from its real position. We develop AR applications that solve this: positioning accuracy down to 2 cm even on complex construction sites.

Why positioning accuracy is critical in construction AR

Unlike retail, where 5 cm error is acceptable, in construction errors of 2–3 cm are critical. ARKit and ARCore provide visual odometry accuracy of 5–15 mm over short distances in well-lit conditions — acceptable. But on a construction site, everything is harder.

Monotonous surfaces. Concrete floors without texture, white walls — feature points have nothing to grab onto. ARKit loses tracking and resets the session. Our solution: forced initialization via QR markers (ARImageTrackingConfiguration) or ArUco markers attached to structural elements with known coordinates. The marker carries an ID → the app pulls the coordinates of that point from the BIM → the world origin is set with marker accuracy.

LiDAR as a mandatory requirement. For construction use, we recommend iPad Pro 2021+ or iPhone 12 Pro+. ARWorldTrackingConfiguration with sceneReconstruction: .meshWithClassification builds a mesh of real space — this allows checking collisions of the BIM model with physical objects (a wall shifted 8 cm from the design) and correctly displaying AR over them. Comparison: ARKit with LiDAR provides twice the tracking accuracy compared to without LiDAR, especially in low light.

Drift during movement. Over areas of 500+ sq m, visual odometry accumulates error. We integrate with geodetic data via GPS (outdoor) or UWB beacons (indoor, accuracy 10–30 cm) for periodic world anchor correction.

How we achieve stable tracking on complex surfaces

We use a combination of methods: marker initialization, LiDAR mesh, and UWB correction. On sites with monotonous walls, we place ArUco markers every 10–15 m. The app automatically finds the nearest marker and restores the world anchor. In open areas, we connect a GNSS receiver (1–2 m accuracy) or RTK corrections (10 cm). This guarantees stable positioning throughout the shift.

Working with BIM content

IFC models cannot be loaded directly into ARKit. Our conversion pipeline:

• IFC → glTF/USDZ via ifcconvert (IfcOpenShell) or Autodesk Forge API
• Geometry simplification: a full Revit model is unviable on a mobile device. We build an LOD system on the server: based on distance to the object, we deliver models of varying detail
• Streaming: we don't load the entire floor at once; we load tiles by sectors via ARGeoAnchor or a custom coordinate grid

On iOS we use RealityKit with ModelEntity for rendering; on Android — ARCore + Filament renderer. BIM layers (structural, MEP, finishes) are switched as visibility toggles in the UI.

Additional scenarios

Quality control. The camera scans a completed element; an algorithm compares it to the BIM — a deviation map is overlaid on the AR image. We use ARMeshAnchor + point cloud comparison. Deviation accuracy — up to 5 mm.

Defect documentation. A photo with AR markup is linked to a specific point in the BIM model via a world anchor — on the next visit, the defect is found automatically. This speeds up work acceptance by 30%.

Comparison of hardware platforms for AR in construction

Our experience shows that iPad Pro with LiDAR gives the best balance of accuracy and field usability. For mass deployment, iPhones can be used — the accuracy difference is compensated by marker frequency.

What's included in the work

• Audit of your current BIM pipeline and formats
• Development of IFC to glTF/USDZ converter with LOD
• AR module with marker initialization and LiDAR tracking
• Integration with project platform (Autodesk ACC, Procore, or custom backend)
• Creation of a visibility control layer for BIM elements
• Field testing on a real site (2–3 days)
• Documentation, team training, 1 month post-launch support

Get a consultation: contact us — we'll discuss your project and select the optimal solution.

Project stages

1. Audit of client's BIM pipeline (1–2 weeks)
2. UX design for field conditions (gloves, sun, dirt on screen) (1–2 weeks)
3. Development of IFC to AR format converter (2–4 weeks)
4. AR module with marker initialization and LiDAR (3–5 weeks)
5. Integration with project system (2–4 weeks)
6. Field testing on a real site (1–2 weeks)
7. Support and refinement based on test results (2–4 weeks)

Timeline: pilot module with basic BIM overlay — 6–10 weeks. Full system with QC features, offline mode, and project platform sync — 4–7 months. Cost is calculated individually. We guarantee positioning accuracy up to 2 cm on sites with prepared markers.

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.