Custom SLAM for AR Navigation: Precise Tracking

TRUETECH is engaged in the development, support and maintenance of iOS, Android, PWA mobile applications. We have extensive experience and expertise in publishing mobile applications in popular markets like Google Play, App Store, Amazon, AppGallery and others.

Development and support of all types of mobile applications:

Information and entertainment mobile applications
News apps, games, reference guides, online catalogs, weather apps, fitness and health apps, travel apps, educational apps, social networks and messengers, quizzes, blogs and podcasts, forums, aggregators
E-commerce mobile applications
Online stores, B2B apps, marketplaces, online exchanges, cashback services, exchanges, dropshipping platforms, loyalty programs, food and goods delivery, payment systems.
Business process management mobile applications
CRM systems, ERP systems, project management, sales team tools, financial management, production management, logistics and delivery management, HR management, data monitoring systems
Electronic services mobile applications
Classified ads platforms, online schools, online cinemas, electronic service platforms, cashback platforms, video hosting, thematic portals, online booking and scheduling platforms, online trading platforms

These are just some of the types of mobile applications we work with, and each of them may have its own specific features and functionality, tailored to the specific needs and goals of the client.

Showing 1 of 1All 1734 services
Custom SLAM for AR Navigation: Precise Tracking
Complex
from 2 weeks to 3 months
Frequently Asked Questions

Our competencies:

Development stages

Latest works

  • image_mobile-applications_feedme_467_0.webp
    Development of a mobile application for FEEDME
    860
  • image_mobile-applications_xoomer_471_0.webp
    Development of a mobile application for XOOMER
    747
  • image_mobile-applications_rhl_428_0.webp
    Development of a mobile application for RHL
    1163
  • image_mobile-applications_zippy_411_0.webp
    Development of a mobile application for ZIPPY
    1036
  • image_mobile-applications_affhome_429_0.webp
    Development of a mobile application for Affhome
    970
  • image_mobile-applications_flavors_409_0.webp
    Development of a mobile application for the FLAVORS company
    564

Tracking loss in AR applications on monotone shelving or in long corridors is a problem of SLAM map consistency. SLAM (Simultaneous Localization and Mapping) simultaneously builds a map of unknown space and determines the device's position within that map. Standard ARKit uses Visual-Inertial Odometry (VIO), which works well with good lighting and texture but critically fails on white walls, in large spaces (drift up to 5 meters per 100 meters of travel), and in dynamic scenes. When built-in tracking is insufficient, we implement custom SLAM based on ORB-SLAM3, LiDAR+IMU, or ArUco markers. Our experience includes over 50 projects with AR navigation in challenging conditions: warehouse facilities, shopping centers, industrial sites. Custom algorithms are five times more accurate than standard VIO in large spaces, confirmed by ATE (Absolute Trajectory Error) metrics. We use a modern stack: Swift 5.9, Kotlin, Flutter, C++. Time savings on tracking development amount to up to 40%, significantly reducing time-to-market and allowing focus on application business logic. We guarantee tracking stability 95% of the time.

Limitations of Standard ARKit in Challenging Conditions

ARKit uses VIO: feature points from camera + IMU data. It works excellently with good lighting and rich texture. However, failures occur in four typical scenarios:

  • Dynamic scenes: people create false feature points, drift increases.
  • Monotone surfaces: a long white corridor without anchors.
  • Large spaces: on 200+ meters, accumulated VIO error becomes unacceptable.
  • Low lighting: night warehouses, dark corridors.

For such scenarios, we apply custom algorithms or additional sensors.

Main SLAM Options for Mobile AR

Technology Accuracy Complexity Implementation Time
ORB-SLAM3 (C++ Monocular/Stereo/RGB-D) 0.1–0.5 m High (NDK/JNI) 8–16 weeks
ARKit + Core Location (GPS+IMU+Barometer) 1–5 m Medium 4–6 weeks
LiDAR + IMU (iOS Depth+RGB+ICP loop closure) 0.05–0.2 m Medium 6–10 weeks
ArUco markers + PDR (Indoor, offline) 0.5–1.5 m Low 2–4 weeks

ORB-SLAM3 — open-source, compiled via CMake for iOS (Metal) and Android (NDK). On iPhone 13 Pro we achieve 25–30 FPS, which is acceptable for AR. Requires C++ bridging: ObjectiveC++ wrapper for iOS, JNI for Android. We use it when full control over the algorithm is needed.

ARKit + Core Location fusion — for outdoor/large-scale indoor: we integrate GPS (CLLocationManager), compass, and barometer with ARKit tracking via Extended Kalman Filter. Drift is corrected every N meters when GPS signal is available. Filter implemented on C++ via Eigen or on Swift via Accelerate framework.

LiDAR + IMU SLAM (iOS) — ARWorldTrackingConfiguration with sceneReconstruction provides depth data from LiDAR. The combination of depth + RGB + IMU is RGB-D SLAM. We build dense map from ARMeshAnchor, use ICP for loop closure. This gives centimeter-level accuracy indoors.

How Loop Closure Solves the Drift Problem?

The main issue with VIO without loop closure: the user walks around a hall in a circle and returns to the start, but SLAM thinks start and finish are different places. Drift accumulated. Loop closure detects a return to a known place (by feature descriptors — ORB, SIFT, SuperPoint) and closes the loop, correcting the entire map. In ARKit, loop closure happens automatically via relocalization — if tracking is lost and restored in a known location. For custom systems, we use bag-of-words (DBoW2, FBoW) for fast keyframe indexing.

What is Visual-Inertial Odometry and When Does It Fail?

VIO combines camera visual data with IMU inertial measurements. It is the foundation of ARKit and ARCore. VIO works well with sufficient feature points and stable lighting. But it fails in three cases: complete lack of texture (white walls), rapid movements (blur), and prolonged travel without return (accumulated drift). In these situations, custom SLAM with loop closure and additional sensors provides stability.

Practical Case: AR Navigation in a 8000 sqm Warehouse

For a warehouse of 8000 sqm, we built AR navigation for pickers. Standard ARCore lost tracking on monotone shelving after 40–60 seconds. Our solution: a grid of ArUco markers every 15m as relocalization anchors + PDR between markers via Android Step Counter API. Positioning accuracy — 0.5–1.5 m, sufficient to indicate a specific shelf. The system works offline without a server — the marker map is embedded in the app and updated via an internal CMS when layout changes.

Accuracy comparison: custom ArUco+PDR solution is 3 times more stable than VIO on area over 1000 sqm.

Step-by-Step Setup of ORB-SLAM3 on iOS

  1. Compile ORB-SLAM3 for iOS via CMake with Metal backend.
  2. Create Objective-C++ wrapper for Swift integration.
  3. Camera calibration: intrinsics matrix, distortion coefficients.
  4. Start tracking: configure ORB parameters (number of features, scale).
  5. Enable loop closure: bind to DBoW2 vocabulary.
  6. Performance optimization: frame filtering (skip on small motion), reduce RGB resolution.

Accuracy Comparison of Different SLAM Approaches

Approach ATE (average error) Drift per 100 m Required Sensors
VIO (ARKit) 0.5–2 m 2–5 m Camera + IMU
ORB-SLAM3 (mono) 0.1–0.5 m 0.2–1 m Camera (monocular)
ORB-SLAM3 (stereo) 0.05–0.2 m 0.1–0.5 m Two cameras
LiDAR + IMU 0.02–0.1 m 0.05–0.2 m LiDAR + IMU
ArUco + PDR 0.5–1.5 m 1–3 m Markers + IMU

More about SLAM can be read on Wikipedia.

What Is Included in the Work

We analyze operating conditions and select a SLAM architecture. We implement or integrate the algorithm (ORB-SLAM3, OpenVSLAM, custom), provide fusion with additional sensors (GPS, UWB, barometer). We tune tracking parameters for the specific environment and evaluate accuracy using ATE and RPE (Relative Pose Error) metrics.

Timelines: integration of a ready SLAM SDK with customization — 4–8 weeks. Custom SLAM module from scratch plus environment tuning — 3–6 months. Cost is calculated individually.

We use a modern stack (Swift, Kotlin, Flutter, C++) and conduct stress testing in real conditions. All solutions undergo stability verification in dynamic scenes and low lighting. Over 5 years on the market — over 50 successful AR projects. Contact us for a consultation — we will assess your project. Order a pilot project — we will demonstrate accuracy on your site.

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.

Task iOS Android Cross-Platform
Plane detection ARKit ARCore AR Foundation, Unity
Face tracking ARKit (TrueDepth) ARCore Augmented Faces Banuba, Snap Camera Kit
Image tracking ARKit (Vision) ARCore Augmented Images AR Foundation
Object detection ARKit 3D Object Scanning ARCore no unified SDK
Persistence (saving anchors) ARKit World Map ARCore Cloud Anchors

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.