Installation#
Choose one installation method before running its setup commands:
Docker (recommended) runs AutoData in a development container. It does not modify the host Python installation.
Native uv installs the locked Python environment on a Linux x86_64 host. It does not require Docker, the NVIDIA Container Toolkit, or an NGC container login.
Complete the common prerequisites and cloning steps below, then follow only your chosen method’s section. The optional conda installation is described separately.
This checkout uses Isaac Sim 6.1.0, Isaac Lab 3.0.0, and Arena 0.3.0.
Before installing, review the Support Matrix for the complete supported software stack, hardware requirements, optional cuRobo and XR dependencies, and resource guidance.
Common Prerequisites#
On the host you need:
An NVIDIA GPU and driver. Verify that the GPU is visible with
nvidia-smi.Git LFS installed (
sudo apt-get install git-lfs) — the example datasets are stored with LFS.
Cloning the Repository#
Isaac Lab and Isaac Lab-Arena are nested git submodules, so clone recursively:
git clone --recurse-submodules git@github.com:isaac-sim/AutoData.git
If you already cloned without --recurse-submodules, run:
git submodule update --init --recursive
Then pull the LFS-stored datasets:
git lfs install
git lfs pull
If a dataset remains a small text pointer or cannot be opened as HDF5, see Git LFS Pointer Files.
Recommended Docker Installation#
Docker Prerequisites#
In addition to the common prerequisites, install Docker and the
NVIDIA Container Toolkit
(provides --runtime=nvidia / --gpus all).
The Isaac Sim base image lives on nvcr.io, so log in to NGC before pulling it:
docker login nvcr.io # username: $oauthtoken password: <your NGC API key>
Starting the Container#
From the repo root, build (first run) and enter the base dev container:
./docker/run_docker.sh
The first run builds the default development image, then drops you into a shell inside the container in the mounted repo. This build process may take up to 30 minutes. Subsequent runs reuse the versioned image and are fast.
Docker uses the base image’s Isaac Sim and bundled Python. Other dependencies come from the repository’s
uv.lock, with the same sim and dev groups as the native installation. Docker excludes the Sim
wheels and extension-cache packages to avoid installing a second simulator. Its Python environment lives at
/opt/autodata/.venv, outside the repository bind mount. A host .venv does not replace it.
Inside Docker, uv run does not sync dependencies. Rebuild the image to update them rather than running
uv sync, which would install the native Sim wheels.
For SkillGen workflows, use the cuRobo image instead. cuRobo compiles CUDA kernels for
your GPU architecture (auto-detected via nvidia-smi), so this build is slower and kept in
a separate versioned image tag that coexists with the default one:
./docker/run_docker.sh -c
Note
Inside the container the repo is mounted at /workspaces/autodata. python and
pytest use the locked environment at /opt/autodata/.venv with Sim from /isaac-sim.
The image configures Sim’s module and library paths for both shell commands and docker exec.
Run simulation commands in these docs from that directory inside the container, or through the launcher.
Host commands are marked explicitly.
Useful flags of ./docker/run_docker.sh:
Flag |
Description |
|---|---|
|
Include cuRobo (required for SkillGen). Auto-detects the GPU arch; override with the
|
|
Host datasets directory to mount at |
|
Force rebuild of the image ( |
|
Verbose. |
|
Show all options. |
For a missing Kit window or an X11 error, see Display and X11.
Updating a Docker Installation#
After updating AutoData, synchronize the nested submodules and rebuild the image from the repository root on the host, outside the development container:
git submodule update --init --recursive
./docker/run_docker.sh -r
For SkillGen, use ./docker/run_docker.sh -c -r instead. The current image tags are
autodata:sim-6.1.0 and autodata:sim-6.1.0-curobo. A rebuild does not replace an already
running container. Finish its work, stop the matching container with
docker stop autodata-sim-6.1.0 or docker stop autodata-sim-6.1.0-curobo, and rerun the
launcher. The launcher reports an error if a running container still uses the previous image.
If startup reports that _isaac_sim selects a binary Isaac Sim installation, inspect it from
the repository root on the host:
ls -ld submodules/IsaacLab-Arena/submodules/IsaacLab/_isaac_sim
readlink submodules/IsaacLab-Arena/submodules/IsaacLab/_isaac_sim
After confirming it is an unwanted symlink, remove only that link and rerun the launcher:
test -L submodules/IsaacLab-Arena/submodules/IsaacLab/_isaac_sim && \
unlink submodules/IsaacLab-Arena/submodules/IsaacLab/_isaac_sim
This leaves the target installation intact and does not remove a real directory.
Source edits are live through the repository bind mount. Dependency changes require rebuilding.
The checked-in example datasets are under ./datasets/ relative to the repository. The separate
/datasets mount comes from the host directory selected by -d; it is not the repository’s
dataset directory.
Optional Native uv Installation#
AutoData is a uv project. uv sync installs Isaac Sim 6.1.0.0 (the pip
version of Sim 6.1.0), PyTorch 2.11.0+cu128, Isaac Lab, Arena, and AutoData with its test tools into .venv
at the repository root. Docker uses the same lockfile in its container environment. The repository’s
uv.lock keeps Arena’s locked version of every package they share. Lab, Arena, and AutoData are editable
installations from the checkout, and uv provides Python 3.12.
The uv installation supports Linux x86_64. On the host, install uv 0.12.21 or newer, Git, CMake, and a C++ compiler. The environment needs about 35 GB of disk space. On Ubuntu:
sudo apt-get install build-essential cmake git git-lfs
After cloning the repository and pulling the LFS datasets, run this command at the repository root:
uv sync --locked
Run workflow commands from the repository root, starting each one with uv run --locked. For example:
export OMNI_KIT_ACCEPT_EULA=YES ACCEPT_EULA=Y
uv run --locked python scripts/generate_dataset.py --help
--locked stops with an error instead of changing uv.lock. Substitute the repository root for the
Docker-only /workspaces/autodata path. After updating the checkout and its submodules, run
uv sync --locked again.
Review and accept the Isaac Sim EULA on first launch. For unattended launches after accepting it, set the two variables shown above.
For both Docker and native uv, uv pip check reports the discrepancies listed for the conda installation
below, except openpi-client, which these environments do not install. Arena’s packaging override also
leaves virtualenv (used by pre-commit) and vcs-versioning (used to build cuRobo) below the
packaging version they declare. Both work with the locked version.
Optional cuRobo for uv#
SkillGen additionally needs cuRobo and a CUDA Toolkit 12.8 installation containing nvcc. cuRobo
compiles CUDA kernels for the GPU’s compute capability against the environment’s PyTorch. Install the toolkit
using NVIDIA’s CUDA installation guide, then run
the following at the repository root. Adjust CUDA_HOME if your toolkit is installed elsewhere:
export CUDA_HOME=/usr/local/cuda-12.8
export PATH="$CUDA_HOME/bin:$PATH"
export TORCH_CUDA_ARCH_LIST="$(nvidia-smi --query-gpu=compute_cap --format=csv,noheader | head -n1)+PTX"
export MAX_JOBS=4
uv cache clean nvidia-curobo
uv sync --locked --group curobo --reinstall-package nvidia-curobo
uv reuses a cached or installed cuRobo build regardless of the GPU or PyTorch version. Cleaning the cache and
reinstalling the package makes the sync rebuild it, so run these commands again after changing the GPU or the
PyTorch version in uv.lock. To keep cuRobo, pass --group curobo to later uv sync commands.
uv run keeps it either way.
Optional Conda Installation#
The conda_installer.sh installer supports Linux x86_64 and Python 3.12.
It installs Isaac Sim 6.1.0.0 (the pip version of Sim 6.1.0), PyTorch 2.11.0+cu128,
Isaac Lab, and Arena from the pinned Arena uv.lock, then installs AutoData with its test tools.
Lab and Arena are editable installations from the nested submodules.
On the host, install conda and uv 0.12.21 or newer. Git, CMake, and a C++ compiler must also be available. On Ubuntu:
sudo apt-get install build-essential cmake git git-lfs
From a terminal outside any Python virtual environment, run these commands at the repository root:
git submodule update --init --recursive
./conda_installer.sh -c -i
conda activate autodata
The environment defaults to autodata. Use -n to choose a different name, including when
installing into your existing isaac_autodata environment:
./conda_installer.sh -i -n isaac_autodata
conda activate isaac_autodata
-c creates an environment and refuses to replace one that already exists. -i installs or
updates packages in the selected environment, which must use Python 3.12. To keep an older setup
available, create a separate environment with ./conda_installer.sh -c -i -n autodata_lab3.
After updating the checkout and its submodules, rerun -i with the same environment name.
Use a fresh shell if the old environment has Isaac Sim binary-install activation hooks; this
installer uses pip-distributed Sim and does not configure a downloaded Sim binary.
The installer exports Arena’s lockfile to .cache/conda-installer/pylock.toml. This preserves
the pinned wheel URLs and hashes, including CUDA-enabled PyTorch, without rewriting the submodules.
It retains unrelated installed packages and checks the locked stack again after installing AutoData.
The generated .cache/conda-installer/runtime-constraints.txt pins the locked dependencies for
later optional installations, including cuRobo. Rerun the installer to refresh both exports after
an Arena update.
Arena’s lock includes upstream dependency overrides. The installed stack matches that lock, but
pip check still reports these five discrepancies with wheel metadata:
Package |
Declared requirement |
Locked installation |
|---|---|---|
|
NumPy < 2 |
NumPy 2.3.1 |
|
Newton 1.5.0 |
Newton 1.5.2 |
|
websockets < 15 |
websockets 16.1.1 |
|
packaging < 24 |
packaging 26.0 |
|
onnxruntime-gpu 1.26.0 |
CPU onnxruntime 1.26.0 |
Keep the locked versions and use the runtime checks below. GPU ONNX inference is not provided by this installation; AutoData’s tested GPU generation workflows use PyTorch and CUDA.
Review and accept the Isaac Sim EULA on first launch. For unattended launches after accepting it,
set export OMNI_KIT_ACCEPT_EULA=YES ACCEPT_EULA=Y. See the official
Isaac Sim pip installation guide.
Run workflow commands with python from the repository root while the selected conda environment
is active. Substitute your checkout path for the Docker-only /workspaces/autodata path.
Optional cuRobo for Conda#
SkillGen additionally needs cuRobo and a CUDA Toolkit 12.8 installation containing nvcc.
Install the toolkit using NVIDIA’s
CUDA installation guide, then
run the following in the activated AutoData environment. Adjust CUDA_HOME if your toolkit
is installed elsewhere:
export CUDA_HOME=/usr/local/cuda-12.8
export PATH="$CUDA_HOME/bin:$PATH"
export LD_LIBRARY_PATH="$CUDA_HOME/lib64${LD_LIBRARY_PATH:+:$LD_LIBRARY_PATH}"
export TORCH_CUDA_ARCH_LIST="$(python -c \
'import torch; major, minor = torch.cuda.get_device_capability(); print(f"{major}.{minor}+PTX")')"
export MAX_JOBS=4
uv pip install --python "$CONDA_PREFIX/bin/python" \
--constraint .cache/conda-installer/runtime-constraints.txt ninja wheel
uv pip install --python "$CONDA_PREFIX/bin/python" \
--constraint .cache/conda-installer/runtime-constraints.txt \
--no-build-isolation \
'nvidia-curobo @ git+https://github.com/NVlabs/curobo.git@ebb71702f3f70e767f40fd8e050674af0288abe8'
uv pip install --python "$CONDA_PREFIX/bin/python" --check \
--requirements .cache/conda-installer/pylock.toml
The GPU must be visible when detecting its compute capability. If building for another machine,
set TORCH_CUDA_ARCH_LIST explicitly to that GPU’s compute capability instead. Rebuild cuRobo
when changing PyTorch or the target GPU architecture. The base conda installer does not install cuRobo.
Documentation Environment#
Building the documentation only needs a separate Python virtual environment and
docs/requirements.txt. It does not require Isaac Sim, Arena, cuRobo, or a conda environment.
See README.md for local build instructions.
Verifying the Installation#
Select the installation method you used. Run its commands from the repository root: inside the container for Docker, or on the host for native uv. The full suite includes SkillGen tests and requires cuRobo.
For the optional conda installation, activate its environment and run the commands shown on the Docker tab from the repository root on the host.
Run the fast unit tests (a few seconds, no Isaac Sim launch):
python -m pytest autodata_tests -m "not with_subprocess"
uv run --locked python -m pytest autodata_tests -m "not with_subprocess"
Then, to verify the full stack end-to-end, run one data-generation test (launches Isaac Sim as a subprocess; several minutes):
python -m pytest -s autodata_tests/e2e/test_mimicgen_data_generation.py::test_franka_cube_stack_mimicgen_data_generation_single_env_cuda
uv run --locked python -m pytest -s autodata_tests/e2e/test_mimicgen_data_generation.py::test_franka_cube_stack_mimicgen_data_generation_single_env_cuda
See Testing and CI for the full test-suite layout.