Watch: Context for Reliable Agents
Live demo · RGB-D SLAM

Build 3D maps on Chalk GPUs

This demo shows how to run Open3D on a Chalk GPU to track a depth camera and reconstruct an office from recorded RGB-D frames. Start mapping to try it, then explore the code to see how it works.

See the DemoTry Chalk

Compare the camera recording with the reconstructed office

The pipeline builds a map from RGB and depth frames while estimating the camera’s path.

Try this experiment · expected results

  1. 1Start the recorded sequence

    Select Start mapping and compare the source camera feed with the growing map.

    Expected: The reconstructed geometry follows the surfaces visible in the recording; a busy service may replay the last run.

  2. 2Inspect the finished reconstruction

    At completion, orbit the mesh and compare the tracked path with motion-capture ground truth.

    Expected: The path comparison exposes tracking error; this pipeline does not perform loop closure.

open3d dense slamOpen in new tab

Start mapping and watch depth frames become a 3D scene. Chalk runs Open3D on a GPU; compare the reconstructed map and tracked camera path.

The recording is fr3/long_office_household from the TUM RGB-D benchmark (Sturm et al., CC BY 4.0): a handheld Kinect, with ground truth from a motion-capture system.

Open3D tracks each frame against the existing map and fuses it into a TSDF voxel grid. This pipeline has no loop closure, so tracking error can accumulate over a longer path.

Built on Chalk

Open3D aligns each frame to the map, fuses depth into a voxel grid, and extracts a mesh. Chalk runs the CUDA container and serves the application that streams those results.

  • Run Open3D on an L4

    Chalk schedules the Open3D service on the requested NVIDIA L4 with four CPUs and 16 GiB of memory.

  • Recording ready at startup

    Chalk builds the 1.5 GB RGB-D recording into the image. New replicas read the frames locally without downloading the sequence again.

  • Deploy from Python

    Define the Open3D dependencies, CUDA runtime, server and viewer in Python. Later builds can reuse cached image layers.

  • Watch the map take shape

    Chalk exposes the service through an HTTPS endpoint. The example server streams poses and points as JSON lines while Open3D builds the map.

Deploy your own

Run it on your own

You need uv, Chalk credentials, and an environment that can schedule an L4. Clone the example, log in, and run the deploy script to build the image and print the demo URL. The first build downloads the RGB-D recording.

Point the loader at your own RGB-D recordings and camera calibration, or replace the tracker, then redeploy. Open3D owns localization and mapping; the example computes trajectory error against the recording's motion-capture data.

chalk-ai/rgbd-slam
git clone https://github.com/chalk-ai/rgbd-slam
cd rgbd-slam

# Or export CHALK_CLIENT_ID and CHALK_CLIENT_SECRET.
chalk login

# Bakes the RGB-D sequence into the image, provisions a GPU, prints your demo's URL.
./deploy.py --gpu nvidia-l4

Run your perception stack on Chalk

Mapping, localization, reconstruction, or the models that sit on top of them. Talk to an engineer about running them on GPUs in your cloud.

Talk to an engineerExplore model serving