Installing cuRoboV2 on Jetson AGX Orin 64GB: environment, CUDA, and smoke tests

Goal

This guide builds the Jetson AGX Orin 64GB runtime environment. The current cuRobo documentation recommends Ubuntu Linux, an NVIDIA GPU newer than Turing, Python 3.10 or newer while avoiding unvalidated versions above 3.13, a driver that supports CUDA 12+, and installation through uv. On Jetson, the driver and CUDA stack come from JetPack, so the real task is pinning JetPack before installing PyTorch and cuRobo.

Version matrix to write down first

Before installing packages, create deploy-matrix.md or deploy-matrix.yaml. This is what lets you debug two weeks later when planning gets slower or CUDA import starts failing.

target: jetson-agx-orin-64gb
l4t: "R36.x"
jetpack: "6.x"
cuda_runtime: "12.x"
python: "3.11"
torch: "aarch64 wheel matching JetPack"
curobo: "git sha or release tag"
install_mode: "uv pip install .[cu12] if torch already exists"
storage: "NVMe for repo, venv, torch cache, uv cache"
power_mode: "MAXN for benchmarking, production mode documented separately"

Do not mix three PyTorch sources: NVIDIA Jetson wheels, x86_64 PyPI wheels, and an NGC base image for a different JetPack release. If you use an l4t-pytorch base image, let the image define PyTorch and install cuRobo without pulling torch (.[cu12]). If you install bare-metal, validate the aarch64 PyTorch wheel first, then run cuRobo tests.

1. Inspect the Jetson

sudo nvpmodel -q
tegrastats
nvcc --version
python3 --version
df -h /

If your root filesystem is on eMMC, move the workspace and caches to NVMe. cuRobo pulls PyTorch, Warp, and CUDA build caches; small eMMC storage makes builds slow and fragile.

mkdir -p /mnt/nvme/robotics/{src,venvs,cache}
export UV_CACHE_DIR=/mnt/nvme/robotics/cache/uv
export TORCH_HOME=/mnt/nvme/robotics/cache/torch

2. Clone and create a venv

cd /mnt/nvme/robotics/src
git clone https://github.com/NVlabs/curobo
cd curobo

uv venv --python 3.11
source .venv/bin/activate
python -V

The official CUDA 12 fresh-install command is:

uv pip install .[cu12-torch]

If your Jetson already has a PyTorch wheel that matches its JetPack/CUDA version, prefer:

uv pip install .[cu12]

On Jetson this is often safer because aarch64 PyTorch wheels must match the L4T stack. Do not force x86_64 wheels from PyPI onto Jetson.

3. Minimal smoke test

python - <<'PY'
import torch
import curobo
print("torch", torch.__version__)
print("cuda", torch.version.cuda)
print("cuda available", torch.cuda.is_available())
print("device", torch.cuda.get_device_name(0))
print("curobo", curobo.__version__)
PY

Then run package tests if time allows:

pytest --pyargs curobo.tests

If the full test suite is too expensive, at least run the getting-started examples that do not require real robot hardware.

4. Containerize the environment

A minimal shape:

FROM nvcr.io/nvidia/l4t-pytorch:r36.4.0-pth2.4-py3

RUN apt-get update && apt-get install -y git curl build-essential && rm -rf /var/lib/apt/lists/*
RUN curl -LsSf https://astral.sh/uv/install.sh | sh
ENV PATH="/root/.local/bin:${PATH}"

WORKDIR /opt/curobo
COPY . /opt/curobo
RUN uv venv --python 3.11 /opt/curobo/.venv
RUN . /opt/curobo/.venv/bin/activate && uv pip install .[cu12]

Do not treat this Dockerfile as universal. Match the base image to the actual JetPack release, keep PyTorch compatible, then install cuRobo.

5. Common failures

6. Smoke tests better than import curobo

After import succeeds, run three small checks:

# 1) GPU tensor path
python - <<'PY'
import torch
x = torch.randn(1024, 1024, device="cuda")
print((x @ x).mean().item())
PY

# 2) cuRobo package tests, if time allows
pytest --pyargs curobo.tests -q

# 3) one example that does not need real hardware
python -m curobo.examples.getting_started.forward_kinematics --help

If the full package suite is too slow on Jetson, still run at least one FK/IK example after building the robot model in part 3. The goal is not exhaustive library certification; it is proving that CUDA/PyTorch/Warp work on the actual target runtime.

7. Checklist

• python -c "import curobo" succeeds.
• torch.cuda.is_available() is True.
• nvidia-smi is not expected on Jetson; use tegrastats.
• Repo and venv are on NVMe.
• You logged JetPack, Python, PyTorch, CUDA, and cuRobo commit versions.

Conclusion

The hard part is not the install command; it is pinning the version matrix. Once the environment is reproducible, move to robot model generation: URDF, meshes, collision spheres, and the self-collision matrix.