ARCore Depth Lab: geometry-aware AR samples that stopped being maintained

A paper project that became a sample repository

ARCore Depth Lab is a set of ARCore Depth API samples providing assets that use depth for advanced geometry-aware features in AR interaction and rendering. It carries a copyright line for 2020 Google LLC, and the repository description notes it as a UIST 2020 work. Some of the features were shown in a Depth API overview video. The project exists because the ARCore Depth API was enabled only on a subset of ARCore-certified Android devices, and a device-limited feature needs worked examples before it becomes a technique. The homepage is a GitHub Pages site at augmentedperception.github.io/depthlab, and there was a pre-built app on Google Play, so the samples were reachable as an install before you built anything.

It is not maintained any more, and the README says so

The README is direct about the current state. The public Android app and this repository are no longer under active maintenance, and contributors are encouraged to look at XR Blocks, where the real-time depth-based interaction like Ballpit and Rain was migrated, to laptops and Android XR devices. That is a specific pointer rather than a vague one, because it names the two samples that carried the interesting interaction work and where they went. The practical reading is that the repository is now an archive: the code is still there, the scenes still build if you have the toolchain, and the ideas are still worth reading, but the bug fixes and the device support work are happening somewhere else. The last push to the repository was on 2026-05-14, and the tagged releases all date from 2021.

Two branches and two different SDK generations

Depth Lab has two branches and the difference is not cosmetic. The master branch contains a subset of the Depth Lab features in version 1.1.0 and is built on AR Foundation 4.2.0 preview 7 or newer, and it supports oriented 3D reticles, depth map visualization, a collider with a depth mesh, avatar locomotion, raw point cloud visualization, and recording and playback. The arcore_unity_sdk branch contains the full set of features and is built on ARCore SDK for Unity version 1.24.0 or newer. The recommendation is to use master for new projects with the AR Foundation SDK and refer to the other branch when necessary. So the modern branch is deliberately smaller, and the features that were dropped are the ones that needed the older plugin: scene-wide geometry, material wrapping and the GPU-side effects.

Three ways to consume depth

The samples are organised around three granularities of depth access, and that organisation is the clearest idea in the repository. Localized depth samples single depth values at certain texture coordinates, on the CPU, and it powers the oriented 3D reticle and character locomotion on uneven terrain, with collision checking for AR object placement, laser beam reflections and rain and snow particle collision available on the other branch. Surface depth creates a connected mesh representation of the depth data, on the CPU or the GPU, which gives point cloud fusion, an AR shadow receiver, paint splat, physics simulation and surface retexturing. Dense depth processes the data at every screen pixel, on the GPU, which is what makes false-color depth map visualisation, AR fog, occlusions, depth-of-field blur, environment relighting and the 3D photo possible.

What each granularity buys you in practice

The three levels are a cost ladder, and the choice is about how much of the screen you need to reason about. Localized depth asks the question once, at a point you care about, so it is cheap enough to do on the CPU and to use every frame for something like a reticle or a character foot placement. Surface depth is the middle ground: you get a mesh, which is enough to collide against and to catch light, without paying for every pixel. Dense depth is what an occlusion or a depth-of-field effect needs, because the effect is defined over the whole frame, which is why it is a GPU path. The samples that fall on the master branch are the localized and surface ones plus a false-colour depth map, which is a rough measure of what fits inside the modern AR Foundation stack.

Building the scenes one at a time

The build story is specific and slightly awkward. The samples target Unity 2020.3.6f1 and require AR Foundation 4.2.0-pre.7 or newer plus ARCore Extensions version 1.24 or newer, with the extensions sources pulled in automatically through the Unity package manager. The project only builds with the Build Platform set to Android, so you build to a device rather than using the Play button in the editor, which is the detail that trips people up. Individual scenes are built and run by enabling a particular scene, such as OrientedReticle, and the ARFDepthComponents object in that scene, and the README reminds you to disable that object in individual scenes when you build all the demos together with the DemoCarousel scene.

The demo carousel and the scene list

There is a demo user interface that lets you switch between examples seamlessly, and it comes with a set of build requirements. The Build Platform has to be Android, the main DemoCarousel scene has to be the first enabled scene in the Scenes In Build list under Build Settings, and you enable all the scenes that are part of the interface. The scene list itself is a set of Unity asset paths, and the first group belongs to the master branch.

Assets/ARRealismDemos/DemoCarousel/Scenes/DemoCarousel.unity
Assets/ARRealismDemos/OrientedReticle/Scenes/OrientedReticle.unity
Assets/ARRealismDemos/DepthEffects/Scenes/DepthEffects.unity
Assets/ARRealismDemos/Collider/Scenes/Collider.unity
Assets/ARRealismDemos/AvatarLocomotion/Scenes/AvatarLocomotion.unity
Assets/ARRealismDemos/PointCloud/Scenes/RawPointClouds.unity

A second group of scenes is in the arcore_unity_sdk branch and is not yet available with the AR Foundation SDK, covering material wrapping, splat, laser beams, relighting, fog, snow and rain particles, depth of field, water, collision aware object placement and the screen-space depth mesh with the stereo photo.

How the two named samples work

The AvatarLocomotion scene puts an AR character on uneven ground. The character follows waypoints the user sets while staying close to the surface, and the scene uses raycasting and depth lookups on the CPU to calculate a three-dimensional point on the terrain surface, which is the localized depth path applied continuously rather than once. The Collider scene is a physics playground that uses screen-space depth meshes so that Unity's rigid-body objects collide with the physical environment. After an on-screen button is pressed, a Mesh object is procedurally generated from the latest depth map, and that mesh is used to update the sharedMesh parameter of the MeshCollider, and then a randomly selected primitive rigid body is thrown into the environment. That is the surface depth path, and the procedural regeneration is what makes it work when the environment changes.

Editorial conclusion

Use ARCore Depth Lab as a reference for how depth-aware AR is built in Unity, since the samples separate localized, surface and dense depth cleanly and show what each buys you, occlusion, collision, relighting and depth of field. Do not start a new project on it, because the README states the app and repository are no longer under active maintenance and points contributors to XR Blocks instead. Verify first that your target device supports the Depth API, since it is enabled only on a subset of ARCore-certified Android devices and iPhone and iPad are not supported at all, that you pick the branch matching your SDK, because master carries a subset of the features and arcore_unity_sdk carries the rest, and that you build to an Android device rather than using the Play button.

Frequently asked questions

Official sources

1. googlesamples/arcore-depth-lab on GitHub
2. License: Apache-2.0
3. Project website
4. README
5. Releases