Isaac ROS

Practical

Isaac ROS is NVIDIA’s collection of GPU-accelerated ROS 2 packages that bring high-performance AI and perception capabilities to robots running on Jetson and discrete GPUs.

Why Isaac ROS?

Standard ROS 2 perception runs on CPU. Isaac ROS moves the heavy lifting to GPU:

Capability	CPU (Standard ROS)	GPU (Isaac ROS)
Image processing	~30 FPS	~300+ FPS
Stereo depth	~10 FPS	~90 FPS
Visual SLAM	~15 FPS	~60 FPS
Object detection	~5 FPS	~100+ FPS
3D reconstruction	Seconds	Real-time

Architecture

┌──────────────────────────────────────────────────────────────────┐
│                      Your ROS 2 Application                      │
├──────────────────────────────────────────────────────────────────┤
│  Isaac ROS Packages                                              │
│  ┌─────────────┐ ┌─────────────┐ ┌─────────────┐ ┌────────────┐ │
│  │ Visual SLAM │ │  AprilTag   │ │ Freespace   │ │  DNN       │ │
│  │             │ │  Detection  │ │ Segmentation│ │  Inference │ │
│  └─────────────┘ └─────────────┘ └─────────────┘ └────────────┘ │
├──────────────────────────────────────────────────────────────────┤
│  NITROS (Zero-Copy Transport)          ┌─────────────────────┐  │
│  ┌─────────────────────────────────┐   │ Type Adaptation     │  │
│  │ GPU Memory → GPU Memory         │   │ (sensor_msgs ↔      │  │
│  │ No CPU copy between nodes       │   │  nitros types)      │  │
│  └─────────────────────────────────┘   └─────────────────────┘  │
├──────────────────────────────────────────────────────────────────┤
│  NVIDIA Libraries                                                │
│  ┌─────────┐ ┌─────────┐ ┌─────────┐ ┌─────────┐ ┌───────────┐  │
│  │   VPI   │ │TensorRT │ │ cuDNN   │ │  CUDA   │ │  Triton   │  │
│  └─────────┘ └─────────┘ └─────────┘ └─────────┘ └───────────┘  │
└──────────────────────────────────────────────────────────────────┘

Key Packages

Visual Perception

Package	Function
`isaac_ros_visual_slam`	GPU-accelerated Visual SLAM (cuVSLAM)
`isaac_ros_apriltag`	Fiducial marker detection
`isaac_ros_centerpose`	6-DOF object pose estimation
`isaac_ros_foundationpose`	Zero-shot pose estimation
`isaac_ros_depth_image_proc`	Depth processing and pointcloud
`isaac_ros_image_proc`	Image rectification, resize, format conversion

Deep Learning Inference

Package	Function
`isaac_ros_dnn_inference`	TensorRT inference wrapper
`isaac_ros_triton`	Triton Inference Server integration
`isaac_ros_detectnet`	Object detection
`isaac_ros_segmentation`	Semantic/instance segmentation
`isaac_ros_yolov8`	YOLOv8 object detection

Package	Function
`isaac_ros_nvblox`	Real-time 3D reconstruction and mapping
`isaac_ros_freespace_segmentation`	Drivable area detection
`isaac_ros_occupancy_grid_localizer`	Grid-based localization
`isaac_ros_mapping_and_localization`	Map-based localization with learning-based descriptors

Robot Manipulation

Package	Function
`isaac_ros_cumotion`	GPU-accelerated motion planning
`isaac_manipulator`	Pick-and-place pipelines
`isaac_ros_pose_estimation`	Object pose for grasping

NITROS: Zero-Copy Transport

The secret sauce of Isaac ROS performance:

// Standard ROS 2: CPU memory copy at every node
Node A (GPU) → Copy to CPU → Publish → Subscribe → Copy to GPU → Node B (GPU)

// NITROS: GPU memory stays on GPU
Node A (GPU) → NITROS Publish → NITROS Subscribe → Node B (GPU)
                    ↓                    ↑
              [Same GPU memory pointer]

Using NITROS Types

# Standard ROS image subscriber (CPU)
from sensor_msgs.msg import Image

# NITROS-accelerated subscriber (GPU)
from isaac_ros_nitros_image_type.msg import NitrosImage

NITROS types are automatically adapted to/from standard ROS types at graph boundaries.

Installation

Requires Docker Engine 27.2.0+. The Isaac ROS CLI manages dev container setup.

Set up Docker (recommended approach)

# Clone Isaac ROS Common
git clone https://github.com/NVIDIA-ISAAC-ROS/isaac_ros_common.git
cd isaac_ros_common

Launch development container

# On Jetson
./scripts/run_dev.sh

# On x86 with GPU
./scripts/run_dev.sh --gpus all

Clone desired packages

cd /workspaces/isaac_ros-dev/src
git clone https://github.com/NVIDIA-ISAAC-ROS/isaac_ros_visual_slam.git

Build and source

cd /workspaces/isaac_ros-dev
colcon build --symlink-install
source install/setup.bash

Example: Visual SLAM

# Launch Isaac ROS Visual SLAM with a RealSense camera
ros2 launch isaac_ros_visual_slam isaac_ros_visual_slam_realsense.launch.py

# Subscribe to SLAM output
import rclpy
from nav_msgs.msg import Odometry

def odom_callback(msg):
    pos = msg.pose.pose.position
    print(f"Position: ({pos.x:.2f}, {pos.y:.2f}, {pos.z:.2f})")

# ... standard ROS 2 subscriber setup

Performance Tips

Comparison with Standard ROS

Aspect	Standard ROS 2	Isaac ROS
Compute	CPU	GPU (CUDA, TensorRT)
Memory	System RAM	GPU VRAM + zero-copy
Latency	Higher (CPU bound)	Lower (parallel GPU)
Power	Less efficient	Optimized for Jetson
Compatibility	Universal	NVIDIA hardware

Prerequisites

Supported platforms:

Jetson AGX Thor with JetPack 7.x
Jetson Orin (AGX, NX) with JetPack 6.x
x86_64 with NVIDIA discrete GPU

Jetson Orin Recommended hardware platform

ROS 2 Robot Operating System 2 (Jazzy)

TensorRT For optimized DNN inference

Isaac Sim Simulation environment for testing Isaac ROS

cuMotion GPU-accelerated motion planning

nvblox Real-time 3D reconstruction

SLAM Simultaneous Localization and Mapping

Learn More

Sources

Isaac ROS Release Notes — Version history, platform support, deprecated features
Isaac ROS Getting Started — Installation requirements, Docker version, ROS 2 Jazzy support
NITROS Documentation — Zero-copy transport architecture
NVIDIA Isaac ROS GitHub — Source code, package repositories
JetPack SDK — Platform support matrix