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.

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:

Upstream package metadata versus the Arena lock#

Package

Declared requirement

Locked installation

openpi-client

NumPy < 2

NumPy 2.3.1

isaacsim-core

Newton 1.5.0

Newton 1.5.2

isaacsim-kernel

websockets < 15

websockets 16.1.1

ovphysx

packaging < 24

packaging 26.0

isaacsim-robot

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.