AR Visualization for Architectural Projects in Real Space

Showing a client a building that doesn't yet exist is traditionally the task of render farms and video presentations. AR changes the format: the architect arrives at the site, points a tablet at the ground, and the 3D model of the building appears precisely in its place at 1:1 or 1:100 scale. We implement such projects turnkey — from converting BIM models to publishing in app stores. The client walks around the building, looks inside, changes facade materials. This is not a replacement for renders — it's another tool for a different conversation: live, interactive, convincing.

Two Modes: Site-Scale and Table-Scale

Site-scale (plot scale, 1:1). The building is placed on the real site using ARKit Geo Tracking or GPS+compass. The user physically walks around the virtual structure. Requires a device with A12+ and a supported city for Geo Tracking. For suburban plots — only GPS with 3-8 meter accuracy.

Table-scale (model scale, 1:100 and smaller). The model of a block or building is placed on a table or floor like a maquette. Plane detection + placement. Suitable for office presentations, exhibition stands. Simpler to implement, works on all ARKit/ARCore devices.

Often both modes are used with a switch: "view as maquette" / "enter the building".

What to Choose: Site-Scale or Table-Scale?

The choice depends on the scenario. If you plan to show the building on the actual plot with landscape reference — definitely site-scale. For demonstration in a meeting room or at a booth, table-scale is more convenient. We help clients determine the optimal mode and, if needed, implement both with a single gesture switch.

Working with Architectural BIM Models

Architects work in Revit, ArchiCAD, Rhino. Direct import of these formats into ARKit/ARCore is impossible — conversion is needed:

• Revit → FBX/OBJ via export or Autodesk Forge API → GLTF via gltf-pipeline or Blender
• ArchiCAD → IFC → conversion via IfcOpenShell → GLTF
• Rhino → OBJ/FBX → GLTF

The main problem with BIM models: Level of Detail (LOD) is too high for real time. A residential complex model in Revit LOD 300 — 10-50 million polygons. For AR, you need 200k-2M maximum. Retopology and LOD are mandatory steps, often taking more time than the AR development itself. AR visualization reduces approval time by 3-5 times compared to traditional renders.

Optimization tools: Simplygon (automatic retopology, cloud service), Blender Decimate Modifier (free, manual control), Reality Composer Pro (Xcode 15+) for final packaging into .reality with baked textures.

How to Convert a BIM Model to AR?

The process includes three steps: export from the CAD system to an intermediate format (FBX/OBJ/IFC), conversion to GLTF, and polygon optimization to an AR-acceptable count. At this stage, textures are also baked and LOD levels are set. Without optimization, even powerful devices cannot smoothly display a complex model.

Interactivity: Floors, Apartments, Materials

For presenting a residential complex to a client, more than a static model is needed:

• Floor selection. We split the model into separate ModelEntity objects by floor. Tap gesture on a floor — highlight selected, others reduce opacity to 0.3. In RealityKit — ModelComponent.materials with SimpleMaterial(color: .yellow.withAlphaComponent(0.5)).
• Apartment interior view. Separate scene with the apartment interior, switching via ARView.scene.anchors.removeAll() + load new scene. Or — transition to VR mode (SceneKit + AVPlayer + 360° panorama).
• Facade material switching. Brick / plaster / glass — swap texture on entity.model?.materials. Textures in .ktx2 format for fast loading.

Streaming 3D Content

A full residential complex model in GLB — 50-200 MB. Cannot be embedded in the app. Options:

• Progressive loading via Reality Composer Pro: .reality files support streaming — RealityKit loads LOD as the camera approaches.
• Babylon.js + WebXR in WKWebView: for web-based approach with streaming via GLTF extensions (MSFT_lod, KHR_materials_variants).
• Cesium for Mobile: if the model is geo-referenced and needs 3D Tiles streaming.

Collaborative Viewing (Multiplayer AR)

Several people see the same model in the same space — via MultipeerConnectivity + ARKit collaborative session. ARSession.getCurrentWorldMap() → send via Multipeer → ARWorldTrackingConfiguration.initialWorldMap on other devices. All participants see the same scene with shared anchors.

Works up to ~30 meters via Wi-Fi/Bluetooth. For large sites — server-side position synchronization via WebSocket.

What's Included in the Work

• Conversion of BIM model to optimized GLTF with baked textures
• Development of AR app for iOS and Android (Swift/Kotlin, RealityKit/ARCore)
• Configuration of interactivity: floor selection, apartment views, material switching
• Implementation of site-scale and/or table-scale modes
• Setup of collaborative viewing (optional)
• Testing on target devices, publication in App Store and Google Play
• Training of client staff on using the app
• Technical support for one month after launch

Experience and Expertise

We have been developing AR solutions for over 5 years. Our portfolio includes more than 10 projects for architectural firms and developers. We guarantee quality and adherence to deadlines. Assess your project for free — write to us.

Timeframes

Table-scale visualization with one model without interactivity — 2-3 weeks (including model conversion). With interactive floors, material switching, site-scale via Geo Tracking — 6-10 weeks. Multiplayer AR — plus 2-3 weeks. The cost is calculated individually.

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.