The ZED ROS2 Wrapper on NVIDIA Jetson: Setting Up a ZED X Robotics Stack

The ZED ROS2 wrapper is the open-source package from Stereolabs that runs a ZED camera as a ROS 2 node, publishing its color images, depth maps, point clouds, odometry, pose and IMU data as standard ROS 2 topics. It sits on top of the ZED SDK, so the depth and positional tracking the SDK computes on the GPU arrive in your robot software without custom driver code.

For a robot built on a Stereolabs ZED X and an NVIDIA Jetson, the wrapper is the bridge between the camera and the rest of the navigation stack. Getting there means lining up four layers in the right order: JetPack, the ZED X driver, the ZED SDK and ROS 2 with the wrapper. Most of the time on a first build goes into matching their versions, so that is where this guide starts.

It covers which JetPack goes with which ROS 2 release, building and launching the wrapper, the topics and camera models, multi-camera rigs and Isaac ROS, how much GPU each camera costs on a Jetson, and how to turn a working development setup into an image you can ship.

The wrapper turns the ZED SDK into a ROS 2 node. The SDK does the heavy work on the GPU: stereo matching for depth, visual-inertial tracking, spatial mapping and optional object and body detection. The wrapper exposes the results as topics, services and parameters, so navigation, mapping and perception packages can subscribe to them like any other sensor.

It works with every current ZED camera. GMSL2 models such as the ZED X, ZED X Mini and ZED X One reach the Jetson through a deserialiser, while USB models such as the ZED 2i plug straight in. Our answer on what a stereo camera is explains how two lenses become a depth map.

Our white paper on connecting a ZED X to a Jetson over GMSL covers the hardware side in depth, including the deserialiser, the device tree and the board support package. This guide picks up once the camera is seen by the operating system.

ROS 2 releases are tied to Ubuntu versions, and on a Jetson the Ubuntu version is fixed by JetPack. That makes the JetPack line the first decision, and it settles the ROS 2 release for you.

Stereolabs lists Humble, Jazzy and the newer Lyrical release on Ubuntu 26.04 as officially supported, with Rolling for developers and Foxy kept only for backward compatibility. Non-LTS releases may work but are not tested. For a product that will be in the field for years, pick an LTS release and plan for its end-of-support date as you would for the Jetson software itself.

If you are deciding between the two current Jetson lines, our guide to the NVIDIA JetPack software stack sets out what changes from JetPack 6 to 7, and our answer on ROS covers the middleware itself.

Start from the JetPack release on the Jetson, because everything else is chosen to match it. Stereolabs ship the ZED X driver as a Debian package named for the driver version, the ZED Link capture card model and the L4T release, for example stereolabs-zedx_X.X.X-ZED-LINK-DUO-L4T36.X_arm64.deb. Install it with sudo dpkg -i, reboot, and confirm the driver loaded with sudo dmesg | grep zedx. ZED Box computers and partner carrier boards with their own deserialiser use the driver package built for that hardware.

Next, install the ZED SDK for Jetson from its .run installer, choosing the build for the same L4T release. The current wrapper expects ZED SDK 5.2 at the time of writing; older SDKs work with older wrapper releases. The SDK includes ZED Explorer and ZED Depth Viewer, which are worth opening before ROS 2 comes into it. If the camera streams and shows depth there, any later problem is in the ROS layer, not the hardware.

With ROS 2 installed, the wrapper is cloned into a workspace and built with colcon, following the Stereolabs instructions.

mkdir -p ~/ros2_ws/src/
cd ~/ros2_ws/src/
git clone https://github.com/stereolabs/zed-ros2-wrapper.git
cd ..
sudo apt update
rosdep update
rosdep install --from-paths src --ignore-src -r -y
colcon build --symlink-install --cmake-args=-DCMAKE_BUILD_TYPE=Release
source install/local_setup.bash

The --symlink-install option lets you edit configuration files in the workspace without rebuilding. On JetPack 6, Stereolabs note that a first build can stop with a CUDA error unless the nvidia-jetpack and nvidia-jetpack-dev packages are installed first. The zed_msgs interface package now comes from apt on Humble rather than as a submodule. If a build fails, check that the wrapper release matches the installed ZED SDK version before anything else.

One launch file starts every ZED model, with the camera named by the camera_model argument.

ros2 launch zed_wrapper zed_camera.launch.py camera_model:=zedx

Stereolabs adds values as new cameras arrive, including HDR models, so check the launch file’s own list with the -s option. Once it runs, the node publishes topics such as rgb/color/rect/image, depth/depth_registered, point_cloud/cloud_registered, odom and pose, which navigation, mapping and perception packages can subscribe to directly. The zed_display_rviz2 package in the examples repository opens a ready-made RViz2 view to confirm the images, depth and point cloud look right; close it in production, because RViz subscribes to many topics and costs performance.

Parameters in the YAML files under zed_wrapper/config switch on the heavier SDK features, such as spatial mapping, object detection and body tracking, so you only spend GPU time on what the robot uses. A simulation mode, started with sim_mode:=true, feeds the same pipeline from a simulator instead of a camera, which lets software teams test before hardware arrives.

For GMSL2 cameras it also helps to keep the camera, the deserialiser and the module on a single power-up order and to check that the ZED X daemon is running before the node starts, since the wrapper can only open a camera the driver has already enumerated. Logging the ZED SDK diagnostics on first boot gives a reference to compare against if a camera later drops out in the field.

Two of these matter more than they look. SVO recording lets you capture a difficult site once and replay it through the wrapper as often as you need while tuning, without the robot. And the 2D mode limits tracking to a flat plane for wheeled robots indoors, which keeps odometry from drifting in height.

The wrapper runs several cameras on one Jetson, each as its own node with a unique name and serial number, and ZED X cameras can be hardware-synchronised so their frames line up; Stereolabs quote alignment within 100 µs. The limit is usually the host. A ZED Box Mini takes two GMSL2 cameras, a GMSL2 capture card such as the ZED Link Quad takes up to eight on a Jetson AGX Orin, and every stream adds to the GPU load.

For teams building on NVIDIA Isaac ROS, the wrapper supports NITROS, NVIDIA’s accelerated transport for ROS 2, so image and depth data can move between GPU-accelerated nodes without extra copies. That keeps a multi-camera perception pipeline efficient on the same Jetson that runs the cameras, and lets Isaac packages such as visual SLAM or nvblox consume ZED data directly.

GMSL2 cable runs of up to 15 m carry video and power on one coax, which is why it suits robots and vehicles better than USB for cameras away from the computer. Our explainer on GMSL2 covers the link itself, and our article on how GMSL carries camera data compares GMSL2 with GMSL3.

Stereo depth runs on the GPU, so the module decides how many cameras and features you can run at full frame rate. Stereolabs publish GPU load figures for the ZED Box Mini builds, measured with the ZED SDK 5.0 NEURAL LIGHT depth model at 1920 × 1200 and 30 fps, outside the MAXN SUPER mode.

Worked example. A warehouse robot with two ZED X cameras, positional tracking and a person detector fits on an Orin NX 16GB: the two depth streams take roughly half the GPU, leaving room for tracking and one model. Add spatial mapping and a second detector and the same robot needs an AGX Orin. Treat these figures as a starting point and measure your own pipeline with tegrastats, because resolution, depth mode and model size move them a long way.

Power modes matter too. The ZED Box Mini builds reach their top 40 W MAXN SUPER mode on Orin NX only with the fan kit fitted, so the cooling has to be chosen with the camera count. Our comparison of Jetson Orin NX and AGX Orin covers where the extra memory and I/O of the larger module start to pay.

A wrapper that runs on a developer kit is not yet a product. Fielded robots need the same software on every robot in the fleet, a camera that comes back after a power cut, and a way to update without breaking the version chain.

The same discipline applies to the whole robot computer. Our robot computer guide covers sizing onboard compute for mobile robots, humanoids and cobots, and our answer on autonomous mobile robots sets out where stereo depth fits alongside lidar.

We supply each camera with the computer it runs on, set up with JetPack, the ZED X driver, the ZED SDK and the wrapper, and tested before it ships.