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
| Symptom | Likely cause | Fix |
|---|---|---|
torch.cuda.is_available() == False |
Wrong PyTorch wheel for JetPack/CUDA | Reinstall the correct aarch64 PyTorch wheel |
| Build runs out of disk | Cache on eMMC | Move UV_CACHE_DIR, TORCH_HOME, and workspace to NVMe |
| Import works but examples crash | CUDA/Warp/PyTorch ABI mismatch | Rebuild in a clean pinned environment |
| First planning call is slow | CUDA graph/kernel warmup | Call warmup() during startup |
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()isTrue.nvidia-smiis not expected on Jetson; usetegrastats.- 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.
