Where am I?
What's around me?
SLAM answers both questions at once: from a moving depth camera alone, it tracks where the camera is and builds a 3D map of what it sees. Watch a GPU do it live on a 22 m walk around an office, deployed on Chalk from one Python file.
Map an office
Press Start mapping. The camera feed plays on the right while the map and the camera's path build up on the left. When the run ends, the fused map becomes a solid 3D mesh of the office, and you can compare the tracked path with the motion-capture ground truth. If someone else is mapping, you see a replay of the last run.
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.
How it works
To place the camera you need a map, and to build a map you need to know where the camera was. SLAM breaks the circle by doing both a little at a time, every frame.
Localize
Each new depth image is aligned to a raycast of the map built so far with ICP. The transform that lines them up is the camera's new pose.
Map
The frame is fused into a TSDF voxel grid at that pose. Every voxel averages many noisy depth readings, so the surface gets cleaner as the camera keeps moving. At the end, marching cubes turns the grid into a coloured triangle mesh.
Check
When the run ends, the tracked path is compared with the dataset's motion-capture ground truth. Over the full 22 m loop the RMS error is under 7 cm.
Deploy your own in three commands
Clone the example, log in, and run the deploy script. Chalk builds an image with Open3D, the CUDA runtime and the recording inside it, provisions an L4, and prints a URL that serves this exact demo.
The SLAM loop is about twenty lines of Open3D. Point it at your own robot's or scanner's RGB-D recordings, or swap in a different tracker, and redeploy.
chalk-ai/rgbd-slamgit 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-l4What Chalk handles
The geometry is the interesting part. Everything around it is the part Chalk does for you.
GPUs on demand
Ask for gpu="nvidia-l4" and Chalk provisions the node, schedules the replica, and gives it an HTTPS URL that streams results as they happen.
67 frames a second
Tracking and fusing each 640×480 depth frame takes 15 ms on one L4, so the whole 22 m office loop is mapped in about 18 seconds of GPU time.
Data baked into the image
The 1.5 GB recording is downloaded once at build time, so a cold replica reads every frame from local disk instead of the network.
Streams, not batches
The server emits each pose and a slice of new points as one line of JSON, so the browser draws the map while the GPU is still building it.
Runs in your cloud
The replica runs in your Chalk environment. Sensor data from your robots, drones or scanners never passes through a third-party API.
Four files, open source
The SLAM loop, server, 3D viewer and deploy script are Apache-2.0 on GitHub. Swap in your own RGB-D recordings or another SLAM pipeline.
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.