We need to integrate real-time spatial awareness and occlusion into our custom AR glasses software. Which SDKs or developer platforms currently provide the most accurate environmental depth-sensing capabilities?

For custom AR glasses, the important distinction is between raw/environment depth, scene reconstruction/meshing, and semantic occlusion. There isn't one universally “most accurate” SDK—the best choice depends heavily on what depth hardware your glasses expose.

Current platforms worth evaluating

Platform / SDK	Depth approach	Occlusion / spatial awareness	Best fit
Apple ARKit / RealityKit	LiDAR + camera	Scene mesh, per-pixel scene depth, people occlusion, semantic scene understanding	Apple hardware; excellent reference architecture
Google ARCore Depth API	Stereo/motion depth + ToF where available	Per-pixel depth, raw depth + confidence, occlusion	Android-based glasses / phone-tethered systems
Meta Horizon OS Depth API + Scene API	Device depth sensing + stereo depth	Dynamic occlusion + persistent scene mesh/semantics	Quest-class MR hardware; useful architecture for custom headsets
Qualcomm Snapdragon Spaces	Hardware/platform-dependent	Spatial tracking and AR-glasses integration; depth capabilities depend on underlying device	Custom Snapdragon-based glasses
Unity AR Foundation	Abstraction over ARKit/ARCore/etc.	Environment-depth/occlusion interfaces	Cross-platform application layer

1. Apple ARKit / RealityKit — strongest depth reference

ARKit's sceneDepth provides depth captured by the LiDAR scanner, including confidence information, while Scene Reconstruction turns that information into a polygonal environmental mesh suitable for occlusion and collision.Apple Developer+1

RealityKit also exposes higher-level scene understanding, including occlusion and recognition of things such as walls, floors and tables.Apple Developer

For a glasses project, I would particularly study Apple's architecture if your hardware has a real depth sensor rather than relying exclusively on monocular depth estimation.

developer.apple.com

2. Google ARCore — particularly interesting for custom Android hardware

ARCore's Depth API combines depth-from-motion with available hardware depth sensors, such as ToF. Google says its most accurate results generally occur around 0.5–5 m, which is a useful benchmark for evaluating your own sensor pipeline.Google for Developers

The particularly useful part for your application is Raw Depth. It provides higher-accuracy but sparse depth plus a confidence image, rather than interpolating a depth value for every pixel. Google specifically positions it for geometry understanding, reconstruction, measurement and shape detection.Google for Developers+1

For a custom glasses stack, I'd favor the raw/confidence data when implementing your own occlusion compositor rather than blindly using a smoothed depth map.

developers.google.com

3. Meta Depth API + Scene API — excellent model for dynamic occlusion

Meta separates two useful concepts:

• Depth API: real-time depth maps, particularly useful for dynamic occlusion involving hands, people and pets.
• Scene API / Scene Model: persistent geometric/semantic representation of the environment, useful for static occlusion, collision and navigation.

Meta explicitly recommends combining the two when you need both realistic occlusion and environmental interaction.Meta for Developers+1

The current Depth API supports Quest 3/3S and has a roughly 20 cm minimum effective range; Meta also notes that accuracy becomes limited beyond about 4 m.Meta for Developers+1

That architecture is quite relevant to glasses: fast per-frame depth for occlusion + slower/stable scene reconstruction for world understanding.

developers.meta.com

4. Qualcomm Snapdragon Spaces — probably the platform I'd investigate first for custom glasses

If you're actually designing the glasses rather than merely developing an app for existing hardware, Snapdragon Spaces is particularly relevant because it's explicitly designed for AR glasses and wireless-connected phones. Qualcomm provides Unity and Unreal SDKs and a runtime for AR-glasses platforms.Snapdragon Spaces

The catch is important: Spaces itself isn't a magic depth sensor. The ultimate accuracy comes from the cameras/depth sensors and Qualcomm platform configuration in your glasses. So for hardware development, I'd evaluate the complete Snapdragon sensor + Spaces stack rather than comparing “Spaces depth” against “ARKit depth” as though they're equivalent sensors.

spaces.qualcomm.com

What I'd build for your architecture

For a custom glasses product, I'd avoid making the renderer dependent on a single SDK's depth representation. A good architecture is:

                    Camera / Depth Sensors
                             │
              ┌──────────────┴──────────────┐
              │                             │
        Raw depth + confidence        RGB / stereo frames
              │                             │
              └──────────────┬──────────────┘
                             ▼
                  Sensor fusion / SLAM
                             │
              ┌──────────────┴──────────────┐
              ▼                             ▼
       Environment depth              Scene reconstruction
       (per-frame)                    (persistent mesh)
              │                             │
              ▼                             ▼
       Dynamic occlusion             Static occlusion
       hands / people                walls / furniture
              │                             │
              └──────────────┬──────────────┘
                             ▼
                    Occlusion compositor
                             │
                             ▼
                       AR renderer

The key is to preserve confidence values and raw depth as long as possible. ARCore's documentation is a good illustration of why: its Raw Depth data is more accurate for some pixels precisely because it doesn't fill every pixel with an interpolated estimate.Google for Developers

My practical shortlist

For highest-fidelity environmental depth, I'd benchmark:

1. LiDAR-based ARKit/RealityKit — as your high-quality sensor-fusion/scene-understanding reference.
2. ARCore Raw Depth + confidence — especially if your glasses are Android/Qualcomm-based.
3. Meta Depth API + Scene Model — excellent reference for separating dynamic depth from persistent spatial mapping.
4. Snapdragon Spaces — the most directly relevant platform layer if you're building Snapdragon-based custom glasses.
5. AR Foundation — useful as the application abstraction layer, but I wouldn't let it hide the underlying depth data if depth accuracy is a core product requirement.

One important caveat: SDK accuracy is ultimately secondary to the glasses' sensor suite, calibration, baseline, synchronization, compute budget, and thermal constraints. A custom headset with well-calibrated stereo cameras and active depth can outperform a nominally superior SDK running on inadequate hardware.

For your particular project, the next useful step would be to define the sensor configuration (stereo RGB, ToF, structured light, etc.) and target SoC; from those two things we can narrow this down to an actual depth pipeline and compare expected latency, resolution, range, and occlusion quality.

If you're actually designing the glasses rather than merely developing an app for existing hardware, Snapdragon Spaces is particularly relevant because it's explicitly designed for AR glasses and wireless-connected phones. Qualcomm provides Unity and Unreal SDKs and a runtime for AR-glasses platforms.Snapdragon Spaces

The catch is important: Spaces itself isn't a magic depth sensor. The ultimate accuracy comes from the cameras/depth sensors and Qualcomm platform configuration in your glasses. So for hardware development, I'd evaluate the complete Snapdragon sensor + Spaces stack rather than comparing “Spaces depth” against “ARKit depth” as though they're equivalent sensors.

spaces.qualcomm.com

What I'd build for your architecture

For a custom glasses product, I'd avoid making the renderer dependent on a single SDK's depth representation. A good architecture is:

                    Camera / Depth Sensors
                             │
              ┌──────────────┴──────────────┐
              │                             │
        Raw depth + confidence        RGB / stereo frames
              │                             │
              └──────────────┬──────────────┘
                             ▼
                  Sensor fusion / SLAM
                             │
              ┌──────────────┴──────────────┐
              ▼                             ▼
       Environment depth              Scene reconstruction
       (per-frame)                    (persistent mesh)
              │                             │
              ▼                             ▼
       Dynamic occlusion             Static occlusion
       hands / people                walls / furniture
              │                             │
              └──────────────┬──────────────┘
                             ▼
                    Occlusion compositor
                             │
                             ▼
                       AR renderer

The key is to preserve confidence values and raw depth as long as possible. ARCore's documentation is a good illustration of why: its Raw Depth data is more accurate for some pixels precisely because it doesn't fill every pixel with an interpolated estimate.

My practical shortlist

For highest-fidelity environmental depth, I'd benchmark:

Integrating real-time spatial awareness and occlusion into custom AR glasses depends heavily on whether your hardware relies on dedicated depth sensors (like a hardware LiDAR/ToF) or relies entirely on monocular/stereo RGB camera-based depth estimation (software depth).

The top-tier SDKs and developer platforms providing the most accurate environmental depth-sensing and occlusion capabilities are outlined below:

1. Apple ARKit / RealityKit (The Gold Standard for Hardware-Assisted Depth)

• Best for: Ecosystems utilizing high-end custom hardware paired with dedicated hardware sensors (or Apple Vision/iOS-adjacent architectures).buildmvpfast.com
• Accuracy: Sub-centimeter precision at close range.forasoft.com
• How it works: Combines physical LiDAR scanner data with continuous multi-sensor fusion. RealityKit handles real-time pixel-accurate occlusion out of the box, meaning virtual objects naturally disappear behind human bodies, furniture, and walls.forasoft.com
• Limitations: Tightly bound to Apple's operating system environment (iOS/visionOS). Hard to port natively to custom standalone Android or bare-metal RTOS smart glasses hardware.buildmvpfast.com

2. Google ARCore Depth API (Best for RGB-Based Stereo/Mono Depth)

• Best for: Android-powered custom smart glasses or open ecosystems lacking dedicated LiDAR hardware.
• Accuracy: Moderate to high, depending on ambient lighting and texture detail in the room.
• How it works: Uses machine learning and computer vision to construct dense per-pixel depth maps purely from standard RGB camera feeds. It outputs both raw depth and smoothed depth temporal maps to minimize jitter during real-time occlusion rendering.
• Limitations: Requires a device whose camera and chipset configuration is explicitly supported or calibrated by ARCore. Performance can drop or introduce artifacts in low-texture environments (e.g., blank white walls).codelabs.developers.google.com+1

3. Niantic Spatial SDK (NSDK) / Lightship ARDK (Best Cross-Platform / Outdoor Scalability)

• Best for: Large-scale or outdoor spatial applications where hardware LiDAR fails (LiDAR typically degrades past 7–8 meters).
• Accuracy: Consistent, generalized cross-platform depth.
• How it works: Designed specifically to extend depth-based occlusion to non-LiDAR devices by inferring depth from standard camera inputs. It lets you switch dynamically between mesh-based and dynamic occlusion depending on performance overhead.
• Limitations: Software-derived depth on non-LiDAR hardware is inherently noisier and has lower close-range precision compared to dedicated hardware sensors.nianticspatial.com

4. OpenXR with Depth Extensions (XR_MSFT_spatial_graph_bridge / XR_KHR_composition_layer_depth)

• Best for: Enterprise custom hardware builders who want an open, non-proprietary standard.
• Accuracy: Dependent entirely on your hardware vendor’s custom sensor drivers feeding data into the OpenXR runtime.
• How it works: OpenXR has evolved to standardize depth buffering and environmental layout extensions across independent smart-glasses manufacturers. If your custom glasses run a custom OS, implementing the OpenXR depth layers allows standard engines (like Unity or Unreal) to process hardware-agnostic depth information cleanly.
• Limitations: Low-level integration effort is high; you must write the HAL (Hardware Abstraction Layer) drivers to pipe your camera/ToF data into the OpenXR runtime pipeline.

To help narrow down the best engineering path for your team, could you share:

• Are your custom AR glasses running Android Open Source Project (AOSP) , a custom Linux/RTOS build , or targeting an iOS/Companion setup?
• Does your hardware feature dedicated depth hardware (LiDAR / ToF / Stereo IR) or RGB-only cameras?

For custom AR glasses, the “most accurate” depth stack depends heavily on your hardware (stereo cameras vs. ToF/LiDAR vs. structured light), latency budget, and whether you need pixel-level occlusion, room meshing, or persistent spatial maps. The leading developer platforms today are:

Platform / SDK	Depth & occlusion capability	Best fit for AR glasses
Apple ARKit / visionOS	High-quality scene understanding, LiDAR-assisted depth on supported hardware, environment depth, human occlusion, mesh reconstruction	Premium optical AR devices, iOS/visionOS ecosystems, LiDAR-equipped prototypes
Google ARCore Depth API	Depth-from-motion plus optional ToF sensor fusion; provides depth images for occlusion and hit testing	Android-based glasses, mobile-derived AR glasses, broad device compatibility
Meta Platforms Meta XR SDK Depth API	Real-time environment depth maps, dynamic occlusion support, passthrough integration	MR glasses/headsets using Meta hardware stack
Unity AR Foundation	Unified access layer over ARKit, ARCore, Meta, and others; supports occlusion subsystems	Cross-platform commercial AR applications
OpenXR ecosystem	Hardware-vendor-neutral XR interfaces; capability depends on runtime/vendor extensions	Custom glasses where you want portability

Google for Developers Meta for Developers Unity Documentation## If your priority is raw environmental depth accuracy

1. LiDAR + scene reconstruction stacks

For glasses with a dedicated depth sensor, a LiDAR/ToF pipeline usually beats camera-only depth for:

• Low-texture environments (blank walls, dark rooms)
• Stable geometry capture
• Room-scale meshes
• Persistent anchors

Apple’s ecosystem is a strong reference implementation: ARKit can combine camera tracking, depth sensing, and scene understanding features on supported devices.Unity Documentation

2. Stereo camera depth pipelines

For lightweight glasses where power and size matter:

• Dual RGB cameras + stereo matching
• SLAM + neural depth estimation
• Temporal filtering

This is common in wearable AR because it avoids the size/power cost of active depth sensors.

Google’s ARCore Depth API is a good example: it generates depth maps using motion-based depth estimation and can merge additional hardware depth sensors such as ToF when available.Google for Developers+1

3. Neural depth + sensor fusion

For next-generation glasses, many teams combine:

• Stereo disparity
• IMU
• SLAM tracking
• Neural monocular depth
• Object segmentation
• Hand tracking

This tends to produce better perceived occlusion than relying on raw depth alone.

Platform recommendations by product goal

Lightweight consumer AR glasses

Consider:

• ARCore-style depth pipeline
• Unity AR Foundation abstraction
• Custom stereo depth + neural refinement

Advantages:

• Lower hardware cost
• Works with small camera modules
• Easier Android integration

Tradeoff:

• Less reliable in low-texture scenes.

High-end enterprise AR glasses

Consider:

• Dedicated ToF/LiDAR
• Native spatial mapping APIs
• Custom SLAM stack

Advantages:

• Better measurement accuracy
• Better room scanning
• More reliable occlusion

Mixed reality with people/hands moving through the scene

Prioritize:

• Real-time depth maps
• Segmentation
• Hand/body tracking integration

Meta’s Depth API, for example, is designed specifically to support dynamic occlusion scenarios such as hands, people, and pets, while its Scene API focuses more on static environment understanding.Meta for Developers+1

Practical architecture for custom AR glasses

A robust production pipeline often looks like:

1. Tracking layer

• Visual-inertial odometry (VIO)
• SLAM
• IMU fusion

2. Depth layer

• Stereo/ToF/LiDAR depth
• Temporal smoothing
• Confidence maps

3. Semantic layer

• Plane detection
• Object recognition
• Human segmentation

4. Rendering layer

• Depth-buffer occlusion
• Late-stage reprojection
• Foveated rendering where needed

5. Persistence layer

• Spatial anchors
• World maps
• Cloud/local synchronization

Shortlist for a custom glasses team

If I were evaluating SDKs for a new AR glasses platform, I would prototype with:

1. ARKit/visionOS concepts — benchmark for high-quality spatial understanding.
2. ARCore Depth API — strong reference for camera-first depth estimation.Google for Developers
3. Meta XR Depth API — useful reference for real-time occlusion behavior.Meta for Developers
4. Unity AR Foundation + OpenXR — fastest route to multi-device experimentation.Unity Documentation
5. A custom sensor-fusion stack once hardware constraints are known.

For a glasses product rather than a phone/headset app, the biggest differentiator is usually not the SDK—it is the sensor stack and your depth-fusion algorithm. The best results typically come from combining vendor SDKs for tracking/SLAM with a custom depth pipeline tuned for your exact optics and cameras.

Integrating real-time spatial awareness, meshing, and occlusion into custom AR glasses depends heavily on your hardware target (Qualcomm Snapdragon-powered, Android XR , or custom embedded hardware) and whether you prefer an open standard or vendor-locked toolkits.roadtovr.com

The top SDKs and developer platforms for environmental depth-sensing and occlusion are organized below by ecosystem:

1. OpenXR (with Vendor Extensions) — Best for Portability & Standards

If you want to avoid locking your software into a single hardware vendor, OpenXR is the industry standard. Through specific extensions, it exposes raw environmental depth maps and hardware-accelerated occlusion data directly to the graphics pipeline.

• Key Features: Standardized extensions like XR_META_environment_depth or vendor-specific depth/meshing layers allow per-pixel or mesh-based occlusion.
• Pros: Highly portable code architecture; lets you query depth buffers directly from the runtime to handle smooth, real-time virtual-to-real object occlusion.
• Cons: Implementation quality depends on how well the specific glasses manufacturer implements the OpenXR runtime extensions.developers.meta.com

2. Snapdragon Spaces XR Developer Platform — Best for Qualcomm-Powered AR Glasses

If your custom glasses run on Qualcomm Snapdragon silicon (common for standalone or tethered enterprise AR hardware like Lenovo, Oppo, or Xreal), Snapdragon Spaces is purpose-built for this.spaces.qualcomm.com

• Key Features: Offers robust Spatial Mapping and Meshing , delivering a real-time 3D triangle mesh and dense depth details of the local environment. It handles raycasting against the real-world mesh and real-time physical occlusion.spaces.qualcomm.com+1
• Pros: Deep hardware-level integration with Snapdragon heterogeneous computing (CPU/GPU/DSP optimization), ensuring low-latency motion-to-photon depth alignment and minimal battery overhead.
• Cons: Optimized specifically for Snapdragon XR ecosystems; less ideal if you are targeting heterogeneous or Apple/PC-tethered non-Qualcomm hardware.

3. Unity XR Plugin Management / Unreal OpenXR Plugins — Best for Cross-Platform Application Logic

Instead of writing native wrappers for every sensor, developing through Unity's XR Plugin Management or Unreal Engine's OpenXR features gives you unified abstraction layers.guideflow.com

• Key Features: Acts as a middleware provider framework routing ARCore, ARKit, Magic Leap, or OpenXR provider plug-ins through a single API. Handles plane detection, triangle mesh generation, and environment depth textures out-of-the-box.developer-docs.magicleap.cloud+1
• Pros: Drastically cuts down development time if you are building complex rendering shaders that require real-time stencil-based or depth-buffer occlusion.
• Cons: Adds an abstraction layer overhead; fine-tuning ultra-low-latency raw depth streams can occasionally require dropping down to native platform code.

4. Android XR / Google Play Services for AR (ARCore) — Best for Emerging Android-Based Glasses

With the rollout of Google’s Android XR ecosystem for smart glasses, ARCore's Depth API has evolved to support scene reconstruction and smooth occlusion on supported lightweight companion/tethered glasses.roadtovr.com

• Key Features: Generates continuous per-pixel depth maps using camera data (monocular or stereo) without needing dedicated heavy LiDAR hardware, feeding occlusion masks directly into compatible graphic layers.
• Pros: Massive developer familiarity, excellent documentation, and built-in software fallback algorithms if hardware depth sensors are low-resolution.
• Cons: Monocular depth estimation via software can struggle with fast head movements or low-texture blank walls compared to hardware-based time-of-flight (ToF) or stereoscopic depth sensors.

Which one should you pick?

• Go with Snapdragon Spaces if your custom hardware relies on Qualcomm chips and you need maximum hardware-accelerated performance.
• Go with OpenXR if you anticipate hardware-agnostic deployment across multiple diverse OEM glasses.
• Utilize the OpenXR Depth API Overview or Snapdragon Spaces Spatial Mapping Documentation to review specific code implementations and minimum range constraints (typically 0.2 meters for reliable depth occlusion).spaces.qualcomm.com+1

To help narrow down the ideal choice, could you share:

• What hardware/chipset or form factor are your custom AR glasses built around?
• Are you targeting stereoscopic hardware depth sensors (like ToF or stereo-cameras) or relying purely on monocular camera software estimation?

For custom AR glasses, the key distinction is between SDKs that expose actual sensor-derived depth and those that primarily estimate depth from camera motion. There isn't one universally “most accurate” SDK—the best choice depends heavily on the sensors your glasses expose.

Current options

Platform / SDK	Depth source	Spatial/environment capabilities	Occlusion	Best fit
Apple ARKit / RealityKit	LiDAR on supported devices	Scene reconstruction, planes, world tracking	Excellent on LiDAR hardware	Highest-quality reference implementation / LiDAR-based hardware
Meta Horizon OS Depth API	Dedicated depth sensing + tracking	Environment depth, scene model, raycasting	Real-time static + dynamic occlusion	Headset-class MR hardware
Google ARCore Depth API	Depth-from-motion + available ToF hardware	Per-pixel depth, hit testing, occlusion	Good, hardware-dependent	Android-based glasses / broad device compatibility
WebXR depth sensing	Device-dependent	GPU-optimized depth maps	Yes	Browser-based AR
Qualcomm Snapdragon Spaces	Hardware-dependent Snapdragon XR sensing	Spatial mapping / environment understanding	Hardware/platform dependent	Custom Snapdragon-based glasses

1. Apple ARKit — strongest LiDAR reference

If your glasses can incorporate a LiDAR-class depth sensor, ARKit is one of the best benchmarks for what you should expose at the software layer. sceneDepth supplies distance measurements plus confidence, while smoothedSceneDepth reduces temporal variation. ARKit also supports scene reconstruction, producing a polygonal mesh representing the physical environment.Apple Developer+2

developer.apple.com

For your own glasses, I'd treat the ARKit architecture as a useful target: raw depth → confidence → temporal filtering → world-registered depth/mesh → occlusion renderer.

2. Meta Depth API — particularly relevant to glasses/headsets

Meta's current Depth API is very directly aimed at the problem you're describing. It exposes real-time environment depth maps for occlusion, raycasting and spatial interaction. Importantly, it handles both static surfaces and dynamic objects such as hands and people.Meta Developers+1

There are practical limitations: Meta says accuracy becomes limited beyond roughly 4 m, and depth is unreliable inside roughly 20 cm. Meta also explicitly notes that real-time depth can lag during rapid motion, so pixel-perfect occlusion shouldn't be assumed.Meta Developers+1

That makes it a particularly useful architectural reference if you're building a head-mounted rather than phone-based system.

developers.meta.com

3. Google ARCore Depth — best flexible software approach

ARCore is interesting for custom hardware because it doesn't require dedicated depth hardware in every configuration. Its Depth API can derive depth using motion-based estimation, while incorporating available hardware sensors such as ToF when present. Google reports its most accurate range as approximately 0.5–5 m.Google for Developers

developers.google.com

For glasses without a dedicated depth sensor, this is an important model: use stereo/motion depth as the baseline, then fuse additional hardware depth when available.

4. WebXR depth sensing — useful abstraction layer

If your glasses will run WebXR applications, the WebXR depth-sensing feature exposes environmental depth to applications. Meta's current WebXR documentation, for example, shows depth being consumed as GPU-optimized float32 data for occlusion.Meta Developers

This is less about achieving maximum sensor accuracy and more about getting a portable depth interface across devices.

What I'd use for custom glasses

If you're actually designing the sensing stack rather than choosing an app SDK, I wouldn't make the SDK itself the centerpiece. I'd build a hardware-agnostic Depth Abstraction Layer:

                 ┌──────────────────────┐
RGB cameras ────►│                      │
Stereo cameras ─►│   Sensor Fusion      │
ToF / LiDAR ────►│                      │
IMU ────────────►│                      │
                 └──────────┬───────────┘
                            │
                     Dense depth map
                            │
                 ┌──────────▼───────────┐
                 │ Temporal + confidence│
                 │ filtering             │
                 └──────────┬───────────┘
                            │
                   World-registered depth
                            │
             ┌──────────────┴──────────────┐
             │                             │
       Scene reconstruction          Occlusion
             │                             │
       spatial anchors                 compositor
       collision mesh                / shader

The most important API outputs I'd expose are:

• depthMap
• depthConfidence
• cameraIntrinsics
• cameraPose
• depthTimestamp
• worldDepthTransform
• optional sceneMesh
• optional semantic labels such as wall, floor, table, person

That gives your rendering engine enough information to implement ARKit-/ARCore-/Meta-style functionality without tying the application layer to a particular sensor.

One particularly important design choice

For occlusion, don't rely exclusively on a reconstructed mesh. Use a dense per-pixel depth map for dynamic occlusion and a reconstructed mesh for persistent/static geometry.

Meta explicitly makes this distinction: its Scene Model is useful for static environment geometry, while Depth API handles dynamic occlusion such as hands and people.Meta Developers+1

So, if your glasses have the hardware budget, I'd prioritize:

stereo RGB + active depth (ToF/LiDAR) + IMU + hardware-accelerated depth fusion

over a purely monocular depth-estimation solution. The latter can be useful as a fallback, but shouldn't be your highest-confidence occlusion signal.

If you tell me what sensors, SoC (e.g. Snapdragon XR2/XR2+), cameras, and OS your custom glasses use, I can narrow this down to a concrete SDK/architecture and compare expected depth accuracy, latency, range, GPU/CPU cost, and licensing.

developers.meta.com

3. Google ARCore Depth — best flexible software approach

ARCore is interesting for custom hardware because it doesn't require dedicated depth hardware in every configuration. Its Depth API can derive depth using motion-based estimation, while incorporating available hardware sensors such as ToF when present. Google reports its most accurate range as approximately 0.5–5 m.Google for Developers

developers.google.com

For glasses without a dedicated depth sensor, this is an important model: use stereo/motion depth as the baseline, then fuse additional hardware depth when available.

4. WebXR depth sensing — useful abstraction layer

If your glasses will run WebXR applications, the WebXR depth-sensing feature exposes environmental depth to applications. Meta's current WebXR documentation, for example, shows depth being consumed as GPU-optimized float32 data for occlusion.Meta Developers

This is less about achieving maximum sensor accuracy and more about getting a portable depth interface across devices.

What I'd use for custom glasses

If you're actually designing the sensing stack rather than choosing an app SDK, I wouldn't make the SDK itself the centerpiece. I'd build a hardware-agnostic Depth Abstraction Layer:

                 ┌──────────────────────┐
RGB cameras ────►│                      │
Stereo cameras ─►│   Sensor Fusion      │
ToF / LiDAR ────►│                      │
IMU ────────────►│                      │
                 └──────────┬───────────┘
                            │
                     Dense depth map
                            │
                 ┌──────────▼───────────┐
                 │ Temporal + confidence│
                 │ filtering             │
                 └──────────┬───────────┘
                            │
                   World-registered depth
                            │
             ┌──────────────┴──────────────┐
             │                             │
       Scene reconstruction          Occlusion
             │                             │
       spatial anchors                 compositor
       collision mesh                / shader

The most important API outputs I'd expose are:

• depthMap
• depthConfidence
• cameraIntrinsics
• cameraPose
• depthTimestamp
• worldDepthTransform
• optional sceneMesh
• optional semantic labels such as wall, floor, table, person

That gives your rendering engine enough information to implement ARKit-/ARCore-/Meta-style functionality without tying the application layer to a particular sensor.

One particularly important design choice

For occlusion, don't rely exclusively on a reconstructed mesh. Use a dense per-pixel depth map for dynamic occlusion and a reconstructed mesh for persistent/static geometry.

Meta explicitly makes this distinction: its Scene Model is useful for static environment geometry, while Depth API handles dynamic occlusion such as hands and people.

Integrating real-time spatial awareness and occlusion into custom AR glasses depends heavily on your hardware architecture (whether you rely on onboard dedicated hardware sensors like LiDAR/ToF cameras or monocular RGB-based AI depth estimation).

The industry-leading SDKs and developer platforms for environmental depth-sensing and occlusion are structured below by their technological approach and ecosystem strengths:

• Meta Horizon OS / Meta XR SDK: Best-in-class for mixed reality passthrough occlusion. Meta’s platform offers a robust Meta Horizon OS Depth API supporting both hard occlusion (optimized performance) and soft occlusion (visually blended edge smoothing via custom shadergraphs like OcclusionLit ). Ideal if you target standalone mixed-reality hardware with structured stereoscopic passthrough cameras.developers.meta.com+1
• Google ARCore Depth API & Scene Semantics: Best for monocular or generalized camera setups. ARCore uses machine learning to construct dense depth maps from standard RGB camera feeds, meaning you don't strictly need specialized hardware like a physical LiDAR sensor to achieve realistic occlusion. It also provides Scene Semantics to programmatically differentiate elements like sky, ground, or walls.developers.google.com+1
• Snap Lens Studio / Snap OS: Best for lightweight, on-device spatial reasoning. Snap’s recent push with its custom hardware and Lens Studio emphasizes complete on-device spatial compute. It natively handles environmental understanding, 3D object tracking, and real-time interaction without cloud rendering loops, making it great for ultra-low-latency consumer form factors.youtube.com+1
• Apple ARKit: The gold standard if your hardware ecosystem loops in iOS/visionOS devices or paired accessories. ARKit's real-time mesh generation and LiDAR-powered occlusion provide hyper-accurate millimeter-level depth occlusions, though it is tightly bound to Apple's proprietary hardware ecosystem.
• OpenXR / Android XR Standards: As platforms like Qualcomm's Snapdragon Spaces transition into standardized Android XR and OpenXR APIs , leveraging OpenXR extension layers for spatial mapping, meshing, and depth tracking ensures your custom software avoids vendor lock-in and can query raw vertex data for physics and occlusion masks.spaces.qualcomm.com+1

To help narrow down the ideal choice, please let me know:

• What hardware sensor configuration do your custom AR glasses use (e.g., RGB-only, stereo-passthrough, or dedicated ToF/LiDAR)?
• Are you targeting an on-device standalone compute architecture or tethered processing?

For custom AR glasses, the most accurate environmental depth sensing usually comes from platforms that combine hardware depth sensors (LiDAR/ToF/stereo cameras) with SLAM, scene reconstruction, meshing, and occlusion APIs. The “best” choice depends heavily on your glasses’ sensors and OS stack, but these are the leading options:

Platform / SDK	Best for	Depth & occlusion capabilities	Notes
Apple ARKit	High-fidelity iOS/XR experiences	LiDAR-assisted depth, scene reconstruction, mesh generation, people occlusion, persistent anchors	Among the strongest consumer AR stacks when paired with Apple depth hardware.G2
Google ARCore	Android-based glasses and phones	Depth maps, depth-based occlusion, hit testing, scene understanding	Uses depth-from-motion and can fuse ToF data when available; strong software-only fallback.Google for Developers+1
Qualcomm Snapdragon Spaces XR Platform	Dedicated AR glasses	Spatial anchors, tracking, scene understanding, XR perception stack	Designed specifically around AR glasses and Snapdragon-powered devices.Snapdragon Spaces+1
Niantic Niantic Spatial Platform	Cross-device world understanding	Depth estimation, semantic understanding, meshes, occlusion	Interesting for large-scale spatial mapping; can extend AR Foundation workflows.Niantic Spatial, Inc.
Unity Technologies AR Foundation	Multi-platform glasses development	Unified access to ARKit/ARCore depth, meshing, anchors, occlusion	Often the integration layer for commercial AR products.Google for Developers

For maximum depth accuracy

If your glasses have dedicated sensors, prioritize SDKs that expose raw sensor data:

1. Stereo RGB + active depth (best overall)

• Dual cameras + structured light or ToF usually outperform monocular approaches.
• Enables stable real-time occlusion, obstacle awareness, and mesh reconstruction.

2. LiDAR-based systems

• Excellent for room-scale mapping and geometry capture.
• Common in premium XR devices, but adds cost, power consumption, and size constraints.

3. Depth-from-motion (software-only)

• Lower hardware cost.
• Good for consumer AR, but accuracy drops with low texture, poor lighting, or static scenes. Google’s ARCore Depth API is an example of this approach.Google for Developers

For custom AR glasses, I would shortlist:

If you control the hardware

• Snapdragon Spaces + custom perception stack Best fit for Android-based smart glasses with Qualcomm chipsets.Snapdragon Spaces
• Add your own: - stereo depth pipeline
• VIO/SLAM
• GPU-accelerated neural depth refinement
• semantic segmentation model

If you want fastest production path

• Unity AR Foundation + ARKit/ARCore backends - Lets you target multiple devices.
• Good for commercial apps where you do not want to maintain your own SLAM stack.Google for Developers

If your key requirement is “objects should correctly hide virtual content”

Prioritize:

1. Dense depth maps (30–60 Hz)
2. Low-latency camera/depth synchronization
3. Real-time mesh generation
4. Semantic segmentation (person/table/wall/floor)
5. GPU shader access to depth buffers

For a custom AR glasses product, the strongest architecture today is typically:

Stereo/ToF sensors → VIO/SLAM → depth fusion → semantic segmentation → spatial mesh → occlusion renderer

rather than relying on a phone-style AR SDK alone.Niantic Spatial, Inc.+1

If you share your glasses hardware assumptions (Snapdragon vs custom SoC, stereo cameras, LiDAR/ToF availability, Unity vs native engine), I can narrow this down to a recommended stack.

When building real-time spatial awareness and environmental occlusion for custom AR glasses, the choice of SDK depends heavily on whether you rely on dedicated onboard hardware (like a LiDAR sensor or stereo IR cameras) or require software-driven, vision-based depth estimation.

The top-performing developer platforms and SDKs providing accurate depth-sensing and occlusion capabilities are categorized below by their hardware and ecosystem strengths:

1. Hardware-Integrated & Native OS Platforms

• Apple ARKit / RealityKit: If your target architecture or companion processing leans on Apple ecosystems (or visionOS-adjacent hardware adaptation), Apple ARKit remains the gold standard for hardware-accelerated LiDAR depth, real-time meshing, and pixel-accurate people/environment occlusion . Its RealityKit framework handles real-time scene reconstruction out of the box, though it is tightly coupled to Apple's hardware line.buildmvpfast.com+1
• Meta Horizon OS (Depth API): For mixed-reality and passthrough-driven smart glasses, Meta’s Depth API via the Meta XR Core SDK provides robust environment depth textures. Handled via components like the EnvironmentDepthManager , it passes real-time depth maps directly into custom shaders to handle virtual-meets-real occlusions, though fast-motion latency and edge-flickering near complex surfaces require mitigation via soft-occlusion shaders.developers.meta.com+2

2. Cross-Platform & Mobile/Wearable SDKs

• Google ARCore (Depth API): If you need software-based depth that scales broadly without enforcing explicit high-end hardware specs, Google ARCore uses RGB camera feeds combined with machine learning to construct continuous depth maps (Instant Depth). It is exceptionally versatile for cross-platform Android/iOS deployments, though software depth lacks the sub-millimeter precision of dedicated physical sensors.
• Niantic Spatial Platform (formerly Lightship): For outdoor and large-scale spatial persistence without relying on onboard hardware LiDAR, the Niantic Spatial Platform offers robust semantic segmentation, meshing, and real-time occlusion derived purely from computer vision models. It excels at wide-area mapping via its massive Visual Positioning System (VPS) network.buildmvpfast.com+1

3. Standalone Wearable & AI-Driven Ecosystems

• Snap Lens Studio / Snap OS: With Snap’s push into standalone consumer hardware, Lens Studio provides deep machine-learning world-understanding pipelines. While historically optimized for mobile, its expansion into a Native Development Kit (NDK) and agentic developer workflows allows custom hardware developers to leverage advanced depth and spatial mapping features integrated directly into sandboxed Lenses.investor.snap.com+4

4. Core Engine Integration

• Unity (AR Foundation 6 + PolySpatial): Regardless of the underlying hardware SDK, managing the render pipeline and depth texture injection into custom materials is typically streamlined using Unity's AR Foundation . It abstracts cross-platform depth map access, surface classification, and occlusion material properties so you aren't writing separate platform-native pipelines for every glass manufacturer.

To help narrow down the best technical path, could you share:

• Are your custom AR glasses using dedicated hardware depth sensors (like ToF, LiDAR, or stereo infrared cameras) or relying purely on monocular/RGB camera computer vision?
• What rendering engine or framework (e.g., Unity, Unreal, or a custom native C++ graphics pipeline) is your software built on?