Skip to main content
🔧 Developer GuideUpdated June 2026 · JetPack 6.0

NVIDIA Jetson for Robotics 2026

Everything you need to pick a Jetson platform and get your robot running ROS 2 Humble + Isaac ROS in 2026. Platform comparison, 5-step setup guide, YOLOv8 inference, Visual SLAM, and 4 complete project tutorials.

4 platforms compared5-step ROS 2 + Isaac ROS setup4 project tutorialsJetPack 6.0 · ROS 2 Humble

Which Jetson Should You Choose?

Most Powerful

Jetson AGX Orin 64GB

$999 (module) / $2,999 (Dev Kit)

97
CPU
12-core Arm Cortex-A78AE v8.2
GPU
2048-core NVIDIA Ampere GPU
AI Perf
275 TOPS
RAM
64GB LPDDR5
Power
15–60W
Isaac ROS
Supported ✓

Best for: Full autonomy stacks, multi-sensor fusion, fleet leaders

✓275 TOPS — handles real-time multi-camera perception + planning simultaneously
✓64GB RAM for large transformer models and simultaneous sensor streams
✗$999 module / $2,999 dev kit — highest cost in Orin family
Best Value for Robotics

Jetson Orin NX 16GB

$399 (module) / $799 (Dev Kit)

93
CPU
8-core Arm Cortex-A78AE v8.2
GPU
1024-core NVIDIA Ampere GPU
AI Perf
100 TOPS
RAM
16GB LPDDR5
Power
10–25W
Isaac ROS
Supported ✓

Best for: Mobile robots, drones, research arms, most production robots

✓100 TOPS covers most robot perception tasks (detection + depth + SLAM)
✓Best performance-per-watt in Jetson Orin family
✗16GB RAM limits very large models (>7B parameters)
Best for Education

Jetson Orin Nano 8GB

$149 (module) / $499 (Dev Kit)

82
CPU
6-core Arm Cortex-A55
GPU
1024-core NVIDIA Ampere GPU
AI Perf
40 TOPS
RAM
8GB LPDDR5
Power
7–15W
Isaac ROS
Supported ✓

Best for: Student robots, hobbyist projects, low-cost inspection drones

✓40 TOPS still runs YOLOv8, depth estimation, and basic SLAM simultaneously
✓$149 module — most accessible Jetson Orin platform
✗40 TOPS insufficient for multi-camera + large model inference simultaneously
Legacy Reference

Jetson AGX Xavier (legacy)

$399 (refurbished) / $699 (Dev Kit)

68
CPU
8-core Carmel Arm v8.2
GPU
512-core Volta GPU
AI Perf
32 TOPS (DLA + GPU)
RAM
32GB LPDDR4x
Power
10–30W
Isaac ROS
Supported ✓

Best for: Existing deployments, budget AGX-class compute

✓32GB RAM for large model inference
✓Widely documented — 1000s of robotics tutorials
✗32 TOPS vs Orin's 100+ TOPS — 3× slower AI inference

Setup Guide: ROS 2 Humble + Isaac ROS on Jetson Orin

Tested on Jetson Orin NX 16GB + JetPack 6.0 (Ubuntu 22.04 base). Estimated total setup time: 90–120 minutes on a fresh flash.

1

Flash JetPack 6.0

Estimated time: 30–60 min

Download NVIDIA SDK Manager on an Ubuntu 22.04 host and flash JetPack 6.0 (L4T 36.x) to your Jetson. JetPack 6 includes CUDA 12.2, cuDNN 8.x, TensorRT 8.6, and VPI 3.0 — all required for Isaac ROS.

# On host Ubuntu 22.04 — download SDK Manager
wget https://developer.download.nvidia.com/compute/cuda/repos/ubuntu2204/x86_64/sdkmanager_*.deb
sudo dpkg -i sdkmanager_*.deb
# Launch SDK Manager and select your Jetson target
sdkmanager
2

Install ROS 2 Humble

Estimated time: 10–20 min

JetPack 6 (Ubuntu 22.04 base) supports ROS 2 Humble natively. Use the official ROS 2 apt repository. Isaac ROS packages require ROS 2 Humble.

# Set locale
sudo locale-gen en_US en_US.UTF-8
sudo update-locale LC_ALL=en_US.UTF-8 LANG=en_US.UTF-8
# Add ROS 2 apt repository
sudo apt install software-properties-common curl -y
sudo curl -sSL https://raw.githubusercontent.com/ros/rosdistro/master/ros.key -o /usr/share/keyrings/ros-archive-keyring.gpg
echo "deb [arch=$(dpkg --print-architecture) signed-by=/usr/share/keyrings/ros-archive-keyring.gpg] http://packages.ros.org/ros2/ubuntu $(. /etc/os-release && echo $UBUNTU_CODENAME) main" | sudo tee /etc/apt/sources.list.d/ros2.list
# Install ROS 2 Humble desktop
sudo apt update && sudo apt install ros-humble-desktop python3-colcon-common-extensions -y
# Source in .bashrc
echo "source /opt/ros/humble/setup.bash" >> ~/.bashrc
3

Install Isaac ROS Common

Estimated time: 20–40 min

Isaac ROS provides hardware-accelerated ROS 2 packages using NITROS (NVIDIA Isaac Transport for ROS) for zero-copy GPU-accelerated sensor processing. Start with isaac_ros_common for base infrastructure.

# Install Docker (Isaac ROS runs in containers)
sudo apt install docker.io -y
sudo systemctl enable --now docker
sudo usermod -aG docker $USER
# Clone Isaac ROS repository
cd ~/ros2_ws/src
git clone https://github.com/NVIDIA-ISAAC-ROS/isaac_ros_common.git
# Pull Isaac ROS Docker image (JetPack 6 compatible)
docker pull nvcr.io/nvidia/isaac/ros:aarch64-ros2_humble_jp60-3.1.0
# Run Isaac ROS container
docker run --rm --network host --runtime nvidia \
-v ~/ros2_ws:/workspaces/isaac_ros-dev \
nvcr.io/nvidia/isaac/ros:aarch64-ros2_humble_jp60-3.1.0
4

Run YOLOv8 Object Detection

Estimated time: 15 min

Deploy accelerated YOLOv8 object detection via Isaac ROS DNN Image Encoder + TensorRT inference. On Jetson Orin NX 16GB, this runs at 60+ FPS — fast enough for real-time robot perception.

# Inside Isaac ROS container
cd /workspaces/isaac_ros-dev
git clone https://github.com/NVIDIA-ISAAC-ROS/isaac_ros_object_detection.git src/
# Build with colcon
colcon build --symlink-install
source install/setup.bash
# Download YOLOv8 TensorRT engine (pre-converted)
python3 scripts/convert_yolov8_to_trt.py --model yolov8n.pt
# Launch detection node
ros2 launch isaac_ros_yolov8 isaac_ros_yolov8_visualize.launch.py
5

Run Visual SLAM with Isaac ROS VSLAM

Estimated time: 20 min

Isaac ROS Visual SLAM uses GPU-accelerated stereo/depth visual odometry for real-time robot localization. Works with Intel RealSense, ZED, and OAK-D cameras. Publishes /visual_slam/tracking/odometry for nav2.

# Install Isaac ROS Visual SLAM
git clone https://github.com/NVIDIA-ISAAC-ROS/isaac_ros_visual_slam.git src/
colcon build --packages-select isaac_ros_visual_slam
# Launch with RealSense D435i
ros2 launch isaac_ros_visual_slam isaac_ros_visual_slam_realsense.launch.py
# Visualize in RViz2
rviz2 -d src/isaac_ros_visual_slam/rviz/vslam.rviz

Robotics Projects Built on Jetson Orin

Autonomous Navigation Robot

Intermediate$600–$1,200

Jetson Orin NX 16GB + RealSense D435i + differential drive

Combines Isaac ROS Visual SLAM for localization with Nav2 for path planning. The Jetson handles depth processing, obstacle detection (YOLOv8), and motion planning in real time.

Drone Perception Stack

Advanced$900–$2,000

Jetson Orin Nano 8GB + ZED Mini + Pixhawk 6C

MAVROS bridge connects ROS 2 Humble to PX4 firmware. Jetson runs real-time object detection, obstacle avoidance, and ArUco marker landing precision using Isaac ROS.

Industrial Inspection Robot

Expert$3,000–$8,000

Jetson AGX Orin 64GB + FLIR Lepton + LiDAR

Multi-modal sensor fusion: thermal imaging (FLIR) + LiDAR + RGB in a synchronized pipeline. Isaac ROS Nvblox builds 3D occupancy maps for inspection path planning.

Robotic Arm with Vision

Advanced$1,500–$25,000 (arm cost varies)

Jetson Orin NX + RealSense D415 + UR5e arm

cuRobo GPU-accelerated motion planning generates collision-free trajectories at 100Hz. YOLOv8 detects pick-and-place targets. Runs the full pick-and-place cycle at 10 items/minute.

Frequently Asked Questions

Should I use Jetson Orin NX or AGX Orin for my robot?

For 95% of robotics applications, Jetson Orin NX 16GB (100 TOPS, $399) is the right choice. It runs full perception stacks (SLAM + detection + depth) simultaneously, costs 60% less than AGX Orin, and uses less power. Choose AGX Orin 64GB only if you need 64GB RAM for very large models or need to run multiple high-resolution cameras simultaneously.

Is Jetson better than Raspberry Pi for robotics?

Jetson is purpose-built for AI workloads — GPU-accelerated inference, CUDA, TensorRT, and Isaac ROS hardware acceleration. Raspberry Pi 5 (16GB) costs $90 but has no GPU and delivers ~1 TOPS. Jetson Orin Nano (40 TOPS, $149) runs YOLOv8 at 30fps on-device; Raspberry Pi 5 can barely manage 3fps with the same model. For anything beyond basic sensor reading, Jetson wins on performance.

What is Isaac ROS and do I need it?

Isaac ROS is NVIDIA's collection of GPU-accelerated ROS 2 packages — object detection, SLAM, depth processing, occupancy mapping, and motion planning — all optimized for Jetson via NITROS (NVIDIA Isaac Transport for ROS). It provides 5–10× faster sensor pipelines than CPU-only ROS 2. You don't need Isaac ROS for simple robots, but for real-time perception with high frame rates, it makes a large difference.

Which cameras work best with Jetson for robotics?

Intel RealSense D435i or D455 (depth + IMU, ~$300) for indoor navigation. ZED 2i (~$450) for outdoor with longer depth range. OAK-D Lite (~$149) for budget stereoscopic AI. FLIR Lepton or Boson for thermal inspection. CSI cameras (OV5693, IMX477) for compact drone builds. All have active Isaac ROS driver support.

Can Jetson run large language models for robot instructions?

Yes, with limitations. Jetson AGX Orin 64GB can run Llama 3 8B at 3–5 tokens/second via llama.cpp CUDA. Jetson Orin NX 16GB can run 7B models at ~1–2 tokens/second. For robot instruction following, models like Llama 3.1 8B quantized to 4-bit (Q4_K_M) run adequately for voice command interpretation. For real-time VLA models, larger GPU resources are needed.

How do I connect Jetson to ROS 2 on an Ubuntu desktop for development?

Set the same ROS_DOMAIN_ID on Jetson and desktop: `export ROS_DOMAIN_ID=42`. Both devices on the same network will automatically discover each other via DDS. Use `ros2 topic list` on desktop to see Jetson topics. For remote visualization in RViz2, set `ROS_LOCALHOST_ONLY=0`. Use Cyclone DDS for better multi-machine performance than default RMW.

Explore More Developer Guides

NVIDIA Isaac Lab, MuJoCo tutorial, ROS 2 beginners guide, and robot arm reviews.

Browse All Guides →