> This page is for version Release 3.0 (default).
> For other versions, use one of these documentation indexes:
> - Release 3.0 (default): https://docs.nvidia.com/isaaclab/3.0/llms.txt
> - Release 2.3: https://docs.nvidia.com/isaaclab/2.3/llms.txt
> - Release 2.2: https://docs.nvidia.com/isaaclab/2.2/llms.txt
> - Release 2.1: https://docs.nvidia.com/isaaclab/2.1/llms.txt

> For clean Markdown of any page, append .md to the page URL.
> For a complete documentation index, see https://docs.nvidia.com/isaaclab/llms.txt.
> For AI client integration (Claude Code, Cursor, etc.), connect to the MCP server at https://docs.nvidia.com/isaaclab/_mcp/server.

# Installation

[![Isaac Sim 6.2.0](https://img.shields.io/badge/IsaacSim-6.2.0-silver.svg)](https://developer.nvidia.com/isaac-sim)

[![Python 3.12](https://img.shields.io/badge/python-3.12-blue.svg)](https://www.python.org/downloads/release/python-3120/)

[![Ubuntu 24.04](https://img.shields.io/badge/platform-linux--64-orange.svg)](https://releases.ubuntu.com/24.04/)

[![Windows 11](https://img.shields.io/badge/platform-windows--64-orange.svg)](https://www.microsoft.com/en-ca/windows/windows-11)

Choose the path that matches what you want to install and how you want to run it. Start with the
automatic `uv` setup unless you need to manage your own environment, use a downloaded Isaac Sim
package, or deploy to Docker or the cloud. Each card jumps to complete instructions on this page.

## Choose an installation path

## Contents

* [Automatic setup with uv](/source/setup/installation/index#automatic-setup-with-uv-recommended) — Run from the Isaac Lab checkout while `uv` creates and manages the environment. **Recommended for most users.**
* [isaaclab.sh installer (legacy)](/source/setup/installation/index#isaaclab-sh-installer-legacy) — Use the legacy installer script to select packages in a virtual environment.
* [Python environment with Isaac Sim](/source/setup/installation/index#python-environment-with-isaac-sim) — Manage a uv, venv, or conda environment and install Isaac Sim with pip.
* [Isaac Lab Python package](/source/setup/installation/index#isaac-lab-python-package) — Install the released Isaac Lab package as a dependency of your own project.
* [Downloaded Isaac Sim package](/source/setup/installation/index) — Download Isaac Sim and use the Python interpreter included with it.
* [Build Isaac Sim from source](/source/setup/installation/index) — Build or modify Isaac Sim itself. This is an advanced workflow.
* [Docker and HPC clusters](/source/setup/installation/index#docker-and-hpc-clusters) — Develop in a container or submit containerized jobs to an HPC cluster.
* [Cloud workstations](/source/setup/installation/index#cloud-workstations) — Provision a remote GPU workstation on a supported cloud provider.

## System requirements

Full Isaac Sim workflows require Python 3.12 on Ubuntu 22.04+ or Windows 11. Use a recent NVIDIA
production driver and a workstation with at least 32 GB RAM and 16 GB GPU VRAM. Rendering can
require additional VRAM. Confirm your machine against the [Isaac Sim system requirements](https://docs.isaacsim.omniverse.nvidia.com/latest/installation/requirements.html) and
[Omniverse technical requirements](https://docs.omniverse.nvidia.com/materials-and-rendering/latest/common/technical-requirements.html).

Isaac Sim 5.1 and older are not supported. Use Isaac Sim 6.2 with Python 3.12.
The Isaac Sim wheels require GLIBC 2.35 or newer on Linux.

The CUDA 13.0 PyTorch build requires NVIDIA driver `580.65.06` or newer on Linux and
`580.88` or newer on Windows, as documented in the [PyTorch CUDA 13.0 requirements](https://pytorch.org/blog/pytorch-2-12-release-blog/). CUDA 13.0 wheels support Blackwell GPUs.

Use the latest NVIDIA production branch driver. Version `580.95.05` or later is recommended on
Linux x86_64 and aarch64, `580.142` on DGX Spark, and `581.42.00` on Windows. If a new GPU or
driver issue requires a newer release, use the production driver from the [Unix Driver Archive](https://www.nvidia.com/en-us/drivers/unix/). On Linux, the [Isaac Sim Compatibility Checker](https://docs.isaacsim.omniverse.nvidia.com/latest/installation/install_workstation.html#isaac-sim-compatibility-checker)
and [Linux troubleshooting guide](https://docs.omniverse.nvidia.com/dev-guide/latest/linux-troubleshooting.html) can identify
unsupported host configurations.

DGX Spark requires CUDA 13 or newer and the corresponding PyTorch build. Install the build
prerequisites before installing Isaac Lab:

```bash
sudo apt install python3.12-dev libgl1-mesa-dev libx11-dev libxcursor-dev \
   libxi-dev libxinerama-dev libxrandr-dev
```

SkillGen, XR teleoperation, livestream, Hub Workstation Cache, Cosmos Transfer1, and RLinf are
not currently supported or validated on DGX Spark. SkillGen depends on native CUDA/C++
extensions whose toolchain has not been validated on DGX Spark, while XR remains limited by
unvalidated encoding performance.

## Automatic setup with uv (recommended)

Use this path for the fastest setup from an Isaac Lab checkout. `uv` resolves the
project environment on each invocation, so you do not need to create or activate an environment manually.

Install `uv`, clone Isaac Lab, and start a workflow:

#### Linux x86_64

```bash
curl -LsSf https://astral.sh/uv/install.sh | sh
```

#### SSH

```bash
git clone git@github.com:isaac-sim/IsaacLab.git --branch release/3.0.0
cd IsaacLab
```

#### HTTPS

```bash
git clone https://github.com/isaac-sim/IsaacLab.git --branch release/3.0.0
cd IsaacLab
```

```bash
# Newton backend without Isaac Sim
uv run isaaclab train --rl_library rsl_rl \
   --task Isaac-Cartpole-Direct physics=newton_mjwarp

# OV PhysX backend
uv run --extra ovphysx isaaclab train --rl_library rsl_rl \
   --task Isaac-Cartpole-Direct physics=ovphysx

# Full Isaac Sim support
uv run --extra isaacsim isaaclab train --rl_library rsl_rl \
   --task Isaac-Cartpole-Direct physics=isaacsim_physx

# Play a policy
uv run isaaclab play --rl_library rsl_rl --task Isaac-Cartpole-Direct --viz newton_gl
```

#### Linux aarch64 (DGX Spark)

```bash
curl -LsSf https://astral.sh/uv/install.sh | sh
```

#### SSH

```bash
git clone git@github.com:isaac-sim/IsaacLab.git --branch release/3.0.0
cd IsaacLab
```

#### HTTPS

```bash
git clone https://github.com/isaac-sim/IsaacLab.git --branch release/3.0.0
cd IsaacLab
```

```bash
# Newton backend
uv run isaaclab train --rl_library rsl_rl \
   --task Isaac-Cartpole-Direct physics=newton_mjwarp

# OV PhysX backend
uv run --extra ovphysx isaaclab train --rl_library rsl_rl \
   --task Isaac-Cartpole-Direct physics=ovphysx

# Full Isaac Sim support
uv run --extra isaacsim isaaclab train --rl_library rsl_rl \
   --task Isaac-Cartpole-Direct physics=isaacsim_physx

# Play a policy
uv run isaaclab play --rl_library rsl_rl --task Isaac-Cartpole-Direct --viz newton_gl
```

> **Note**
>
> For direct Python commands that import Isaac Sim on aarch64, prefix the
> command with `LD_PRELOAD=/lib/aarch64-linux-gnu/libgomp.so.1`.

#### Windows

Enable Windows long-path support before cloning. In an elevated PowerShell window, run:

```powershell
New-ItemProperty -Path "HKLM:\SYSTEM\CurrentControlSet\Control\FileSystem" -Name LongPathsEnabled -Value 1 -PropertyType DWORD -Force
```

Then open a new Command Prompt window and run:

```batch
powershell -ExecutionPolicy ByPass -c "irm https://astral.sh/uv/install.ps1 | iex"
```

#### SSH

```bash
git clone git@github.com:isaac-sim/IsaacLab.git --branch release/3.0.0
cd IsaacLab
```

#### HTTPS

```bash
git clone https://github.com/isaac-sim/IsaacLab.git --branch release/3.0.0
cd IsaacLab
```

```batch
:: Newton backend without Isaac Sim
uv run isaaclab train --rl_library rsl_rl ^
   --task Isaac-Cartpole-Direct physics=newton_mjwarp

:: OV PhysX backend
uv run --extra ovphysx isaaclab train --rl_library rsl_rl ^
   --task Isaac-Cartpole-Direct physics=ovphysx

:: Full Isaac Sim support
uv run --extra isaacsim isaaclab train --rl_library rsl_rl ^
   --task Isaac-Cartpole-Direct physics=isaacsim_physx

:: Play a policy
uv run isaaclab play --rl_library rsl_rl --task Isaac-Cartpole-Direct --viz newton_gl
```

`uv run` installs the core dependencies automatically. The `--extra <name>`
option includes the selected optional integration in the command's environment. Place it
before `isaaclab`; for example, `--extra ov` installs both ovphysx and ovrtx
backends. Pass a comma-separated list or repeat `--extra`. No extras conflict, so
any combination resolves into one environment. The `--extra all` shortcut installs the
curated `ov`, `rl-games`, `sb3`, `skrl`, `rsl-rl`, `rerun`, and `viser` extras.
It does not include Isaac Sim or the specialized `skrl-jax`, `rlinf`, `mimic`, `teleop`,
`tetrahedralization`, `video`, and `leapp` extras; request them by name:

```bash
uv run --extra all isaaclab train --rl_library rsl_rl \
   --task Isaac-Cartpole-Direct physics=ovphysx
```

See [Optional extras](/source/setup/installation/index#optional-extras) for the available extras.

`uv run --extra <name> <command>` syncs the selected extra into the project environment
and then runs the command.

The source checkout selects PyTorch's CUDA 13.0 build on Linux x86_64, Linux aarch64, and Windows.
No additional command flags are needed.
The aggregate wheel pins the PyTorch versions using registry-compatible metadata. Its published-wheel
commands select the CUDA 13.0 build at install time. The wheel supports Python 3.12, matching the source
checkout.

Head over to the [/source/setup/quickstart](/source/setup/quickstart), which starts with your first task and
introduces the available commands, RL libraries, backends, and visualizers.

`isaaclab.sh` installer (legacy)

## `isaaclab.sh` installer (legacy)

Kit-less installation uses a Python 3.12 environment and does not install Isaac Sim. Clone Isaac
Lab, create and activate an environment, then install the default source packages and dependencies.
Install [uv](https://docs.astral.sh/uv/getting-started/installation/) or
[conda](https://docs.conda.io/projects/conda/en/latest/user-guide/install/index.html) before starting:

#### SSH

```bash
git clone git@github.com:isaac-sim/IsaacLab.git --branch release/3.0.0
cd IsaacLab
```

#### HTTPS

```bash
git clone https://github.com/isaac-sim/IsaacLab.git --branch release/3.0.0
cd IsaacLab
```

#### uv environment (recommended)

#### \`fa-brands fa-linux\` Linux

```bash
uv venv --python 3.12 --seed env_isaaclab
source env_isaaclab/bin/activate
uv pip install --upgrade pip
./isaaclab.sh -i
```

#### \`fa-brands fa-windows\` Windows

```batch
uv venv --python 3.12 --seed env_isaaclab
env_isaaclab\Scripts\activate
uv pip install --upgrade pip
isaaclab.bat -i
```

#### conda environment

#### \`fa-brands fa-linux\` Linux

```bash
conda create -n env_isaaclab python=3.12
conda activate env_isaaclab
python -m pip install --upgrade pip
./isaaclab.sh -i
```

#### \`fa-brands fa-windows\` Windows

```batch
conda create -n env_isaaclab python=3.12
conda activate env_isaaclab
python -m pip install --upgrade pip
isaaclab.bat -i
```

`-i` always installs the core source packages. With no value, it also installs the optional
`mimic` and `teleop` submodules plus the default Newton, RL, and visualizer dependencies.
It does not install `tetrahedralization`, `contrib`, `ov`, or Isaac Sim;
request those explicitly when needed.

Use `-i core` for core packages only. Otherwise, pass a comma-separated list of selectors:

| Selector                | Installs                                                                  |
| ----------------------- | ------------------------------------------------------------------------- |
| `mimic`                 | Imitation-learning tools.                                                 |
| `teleop`                | Teleoperation tools (Linux x86_64).                                       |
| `newton`                | Newton interactive-viewer dependencies.                                   |
| `rl[<framework>]`       | RL framework dependencies. Select `rsl-rl`, `skrl`, `sb3`, or `rl-games`. |
| `visualizer[<backend>]` | Visualizer dependencies. Select `rerun`, `viser`, `newton`, or `kit`.     |
| `tetrahedralization`    | Dependencies for automatic tetrahedral mesh generation.                   |
| `contrib[rlinf]`        | Contrib runtime dependencies for RLinF.                                   |
| `ov[<runtime>]`         | OV runtime wheels. Select `ovrtx`, `ovphysx`, or `all`.                   |
| `isaacsim`              | The Isaac Sim pip package.                                                |

For example:

#### Linux

```bash
# Core packages only
./isaaclab.sh -i core

# Newton, RSL-RL, and the Newton visualizer
./isaaclab.sh -i 'newton,rl[rsl-rl],visualizer[newton]'

# OVRTX runtime dependencies
./isaaclab.sh -i 'ov[ovrtx]'
```

#### Windows

```batch
:: Core packages only
isaaclab.bat -i core

:: Newton, RSL-RL, and the Newton visualizer
isaaclab.bat -i "newton,rl[rsl-rl],visualizer[newton]"

:: OVRTX runtime dependencies
isaaclab.bat -i "ov[ovrtx]"
```

## Python environment with Isaac Sim

Use this path when you want an editable Isaac Lab checkout with full Isaac Sim support and a
Python environment you manage yourself. Create and activate the environment before installing
Isaac Sim or Isaac Lab. Isaac Sim's pip packages require GLIBC 2.35 or newer on Linux. Enable
[Windows long-path support](https://learn.microsoft.com/en-us/windows/win32/fileio/maximum-file-path-limitation?tabs=registry#enable-long-paths-in-windows-10-version-1607-and-later)
before installing on Windows.

> **Note**
>
> If you plan to [set up Visual Studio Code](/source/developer-tools/editor_setup), use the
> [downloaded Isaac Sim package](/source/setup/installation/index) instead.

Create and activate a Python 3.12 environment:

#### uv environment (recommended)

#### \`fa-brands fa-linux\` Linux

```bash
uv venv --python 3.12 --seed env_isaaclab
source env_isaaclab/bin/activate
```

#### \`fa-brands fa-windows\` Windows

```batch
uv venv --python 3.12 --seed env_isaaclab
env_isaaclab\Scripts\activate
```

#### conda environment

```bash
conda create -n env_isaaclab python=3.12
conda activate env_isaaclab
```

Install Isaac Sim and the CUDA 13.0 PyTorch build for your platform:

#### uv environment (recommended)

```bash
uv pip install "isaacsim[all,extscache]==6.2.0.0" --extra-index-url https://pypi.nvidia.com --index-strategy unsafe-best-match --prerelease=allow
```

#### conda environment

```bash
uv pip install "isaacsim[all,extscache]==6.2.0.0" --extra-index-url https://pypi.nvidia.com --index-strategy unsafe-best-match --prerelease=allow
```

#### Linux (x86_64)

#### uv environment (recommended)

```bash
uv pip install -U torch==2.11.0 torchvision==0.26.0 --index-url https://download.pytorch.org/whl/cu130
```

#### conda environment

```bash
pip install -U torch==2.11.0 torchvision==0.26.0 --index-url https://download.pytorch.org/whl/cu130
```

#### Windows (x86_64)

#### uv environment (recommended)

```bash
uv pip install -U torch==2.11.0 torchvision==0.26.0 --index-url https://download.pytorch.org/whl/cu130
```

#### conda environment

```bash
pip install -U torch==2.11.0 torchvision==0.26.0 --index-url https://download.pytorch.org/whl/cu130
```

#### Linux (aarch64)

> **Note**
>
> On aarch64 systems such as DGX Spark, install the required development packages before
> installing Isaac Sim:
>
> ```bash
> sudo apt install python3.12-dev libgl1-mesa-dev libx11-dev libxcursor-dev libxi-dev \
>    libxinerama-dev libxrandr-dev
> ```

#### uv environment (recommended)

```bash
uv pip install -U torch==2.11.0 torchvision==0.26.0 --index-url https://download.pytorch.org/whl/cu130
```

#### conda environment

```bash
pip install -U torch==2.11.0 torchvision==0.26.0 --index-url https://download.pytorch.org/whl/cu130
```

> **Note**
>
> If the system and PyTorch GNU OpenMP libraries are both preloaded, Isaac Sim can emit
> `libgomp` warnings. Use the system OpenMP library:
>
> ```bash
> unset LD_PRELOAD
> export LD_PRELOAD=/lib/aarch64-linux-gnu/libgomp.so.1
> ```

> **Note**
>
> If importing `omni.client` or `torch` fails because `libcarb.so` cannot allocate a
> static TLS block, preload `libcarb.so` before launching Python:
>
> ```bash
> export LD_PRELOAD=$(python -c "import sys,os;[print(os.path.join(p,'omni','client','libcarb.so')) for p in sys.path if os.path.isfile(os.path.join(p,'omni','client','libcarb.so'))]" 2>/dev/null | head -1)${LD_PRELOAD:+:$LD_PRELOAD}
> ```
>
> `./isaaclab.sh -p` configures this automatically, as does the conda activation hook.

The first launch asks you to accept the NVIDIA Omniverse EULA. For non-interactive environments,
set `OMNI_KIT_ACCEPT_EULA=yes`. Verify Isaac Sim with `isaacsim`.

With the environment still active, clone, install, and verify Isaac Lab:

#### SSH

```bash
git clone git@github.com:isaac-sim/IsaacLab.git --branch release/3.0.0
cd IsaacLab
```

#### HTTPS

```bash
git clone https://github.com/isaac-sim/IsaacLab.git --branch release/3.0.0
cd IsaacLab
```

#### Linux

```bash
sudo apt install cmake build-essential
./isaaclab.sh -i
./isaaclab.sh -p scripts/tutorials/00_sim/create_empty.py --viz kit
```

#### Windows

```batch
isaaclab.bat -i
isaaclab.bat -p scripts\tutorials\00_sim\create_empty.py --viz kit
```

The verification command should open a black simulator viewport. The initial launch can take over
ten minutes while Isaac Sim downloads extensions.

## Isaac Lab Python package

Use this path when Isaac Lab is a dependency of an external Python project. The released
`isaaclab` package includes the unified `train`, `play`, `zero_agent`, `random_agent`,
`benchmark`, `train_multigpu`, `demo`, and `example` commands.
Downstream projects can register their task package through the `isaaclab.tasks` Python package
entry-point group; projects created by the template generator configure this automatically.

To create a project built on Isaac Lab, see [Build your own project or task](/source/developer-tools/template_generator).

> **Note**
>
> Isaac Lab wheels are published for major releases, not every patch release.

### Installing an unreleased Git revision

The aggregate package can also be built directly from an Isaac Lab Git revision. Point uv at the
`tools/wheel_builder` subdirectory so it uses the same dependency metadata and packaged runtime
resources as a released wheel:

```toml
[project]
dependencies = ["isaaclab"]

[tool.uv.sources]
isaaclab = { git = "https://github.com/isaac-sim/IsaacLab.git", rev = "<git-revision>", subdirectory = "tools/wheel_builder" }
```

Use a commit hash or release tag for reproducible environments. A branch name is accepted, but
updating the lockfile can then select a newer Isaac Lab revision and dependency set.

### Installing the published wheel

Use NVIDIA's package index for the |isaaclab_wheel_version| prerelease. Do not point Isaac Lab at
the Git source from the previous workflow when installing the published wheel.

Run the published package directly or install it into a persistent environment. All workflows start
with the base `isaaclab` package; add optional capabilities only when your project needs them.

#### Direct uvx command

```bash
uvx --index https://pypi.nvidia.com \
   --torch-backend cu130 \
   --from "isaaclab==3.0.0rc1" \
   isaaclab demo zoo
```

This resolves the published wheel from the package index into an isolated environment. It does
not require a source checkout, wheel download, or project file.

#### uv project dependency

```bash
uv init --python 3.12 my_isaaclab_project
cd my_isaaclab_project
uv add \
   --index-strategy unsafe-best-match \
   --index pytorch-cu130=https://download.pytorch.org/whl/cu130 \
   torch==2.11.0 torchvision==0.26.0
uv add \
   --index-strategy unsafe-best-match \
   --index nvidia=https://pypi.nvidia.com \
   isaaclab==3.0.0rc1
```

#### Standalone uv environment

#### \`fa-brands fa-linux\` Linux (x86_64)

```bash
uv venv --python 3.12 env_isaaclab
source env_isaaclab/bin/activate
uv pip install isaaclab==3.0.0rc1 \
   --index https://pypi.nvidia.com \
   --torch-backend cu130
```

#### \`fa-brands fa-windows\` Windows (x86_64)

```batch
uv venv --python 3.12 env_isaaclab
env_isaaclab\Scripts\activate
uv pip install isaaclab==3.0.0rc1 ^
   --index https://pypi.nvidia.com ^
   --torch-backend cu130
```

#### \`fa-brands fa-linux\` Linux (aarch64)

```bash
uv venv --python 3.12 env_isaaclab
source env_isaaclab/bin/activate
uv pip install isaaclab==3.0.0rc1 \
   --index https://pypi.nvidia.com \
   --torch-backend cu130
```

The project workflow records the dependencies, package indexes, and lockfile for an application you
maintain; the commands make those project-file changes, so no manual editing is required. Use `uvx`
for one-off commands or a standalone environment for exploratory work that needs an activated Python
environment. Pass the same index strategy when adding or upgrading dependencies in the project.

### Optional extras

Add extras only when your project needs them. Most extras work with
`uv pip install "isaaclab[<extra>]"` in a standalone environment or
`uv add "isaaclab[<extra>]"` in a uv project. The `importers` and `isaacsim` extras
have dedicated commands below.

| Extra                                           | What it installs                                                                                       |
| ----------------------------------------------- | ------------------------------------------------------------------------------------------------------ |
| `isaacsim`                                      | Isaac Sim (`isaacsim[all,extscache]` version 6.2.0.0) from [pypi.nvidia.com](https://pypi.nvidia.com). |
| `ov`                                            | Both OV backends: OV PhysX and OV RTX.                                                                 |
| `ovphysx` / `ovrtx`                             | OV PhysX only / OV RTX only.                                                                           |
| `sb3` / `skrl` / `rsl-rl` / `rlinf` / `torchrl` | The corresponding RL framework.                                                                        |
| `skrl-jax`                                      | skrl with CUDA-enabled JAX.                                                                            |
| `rerun` / `viser`                               | The corresponding visualizer.                                                                          |
| `mimic` / `teleop`                              | Isaac Lab Mimic / XR teleoperation. The wheel's `mimic` extra does not include Robomimic.              |
| `tetrahedralization` / `video`                  | Mesh tetrahedralization / video recording.                                                             |
| `leapp`                                         | LEAP model export support.                                                                             |
| `importers`                                     | Standalone URDF and MJCF conversion without Isaac Sim.                                                 |
| `all`                                           | The curated `ov`, `sb3`, `skrl`, `rsl-rl`, `rerun`, and `viser` extras. Isaac Sim is not included.     |
| `test`                                          | Developer test and documentation tooling.                                                              |

Use `all` for the curated list above. Isaac Sim, standalone importers, specialized extras
(`skrl-jax`, `rlinf`, `mimic`, `teleop`, `tetrahedralization`, `video`, `leapp`), and
the developer `test` tooling remain opt-in.

> **Note**
>
> RL-Games and Robomimic are not included in the published wheel metadata because the versions
> used by Isaac Lab are installed from Git and do not provide package-index wheels. To use either
> integration, install Isaac Lab from a source checkout and select the `rl-games` or `mimic`
> extra there.

> **Note**
>
> On Linux, the `mimic` extra may build its `egl-probe` dependency from source. Install
> CMake and a C++ compiler first with `sudo apt install cmake build-essential`.

Installing the `importers` extra

### Installing the `importers` extra

Install this extra to convert URDF and MJCF files without Isaac Sim.

> **Warning**
>
> Use the full command below. Without the overrides, the importer extra can downgrade packages
> used by the base Isaac Lab install. The overrides keep Isaac Lab's tested versions.

```bash
uv pip install "isaaclab[importers]==3.0.0rc1" \
  --overrides "https://raw.githubusercontent.com/isaac-sim/IsaacLab/v3.0.0-EA/tools/wheel_builder/uv-overrides.txt" \
  --index https://pypi.nvidia.com \
  --torch-backend cu130 \
  --index-strategy unsafe-best-match
```

Installing the `isaacsim` extra

### Installing the `isaacsim` extra

Isaac Sim 6.2 pins dependencies that conflict with Isaac Lab. Install the `isaacsim` extra with
the tested overrides:

```bash
uv pip install "isaaclab[isaacsim]==3.0.0rc1" \
  --overrides "https://raw.githubusercontent.com/isaac-sim/IsaacLab/v3.0.0-EA/tools/wheel_builder/uv-overrides.txt" \
  --extra-index-url https://pypi.nvidia.com \
  --torch-backend cu130 \
  --index-strategy unsafe-best-match
```

Add other extras inside the brackets when needed; for example, use
`isaaclab[isaacsim,all]` to include the curated `all` list.

### Installing CUDA-enabled PyTorch

The published-wheel commands above select the CUDA 13.0 PyTorch build during dependency
resolution. To update an existing standalone environment that was installed without the CUDA
index, use the command for your platform:

#### Linux (x86_64)

```bash
uv pip install -U torch==2.11.0 torchvision==0.26.0 --index-url https://download.pytorch.org/whl/cu130
```

#### Windows (x86_64)

```bash
uv pip install -U torch==2.11.0 torchvision==0.26.0 --index-url https://download.pytorch.org/whl/cu130
```

#### Linux (aarch64)

> **Note**
>
> Install the required Python, OpenGL, and X11 development packages before installing
> Isaac Lab:
>
> ```bash
> sudo apt install python3.12-dev libgl1-mesa-dev libx11-dev libxcursor-dev libxi-dev \
>    libxinerama-dev libxrandr-dev
> ```

```bash
uv pip install -U torch==2.11.0 torchvision==0.26.0 --index-url https://download.pytorch.org/whl/cu130
```

> **Note**
>
> If Isaac Sim reports OpenMP preload warnings, use the system GNU OpenMP library:
>
> ```bash
> unset LD_PRELOAD
> export LD_PRELOAD=/lib/aarch64-linux-gnu/libgomp.so.1
> ```

> **Note**
>
> If importing `omni.client` or `torch` fails because `libcarb.so` cannot allocate a
> static TLS block, preload `libcarb.so` before launching Python:
>
> ```bash
> export LD_PRELOAD=$(python -c "import sys,os;[print(os.path.join(p,'omni','client','libcarb.so')) for p in sys.path if os.path.isfile(os.path.join(p,'omni','client','libcarb.so'))]" 2>/dev/null | head -1)${LD_PRELOAD:+:$LD_PRELOAD}
> ```

If you installed the `isaacsim` extra, verify it before running your project:

```bash
isaacsim
```

The first launch downloads Isaac Sim extensions and can take more than ten minutes. It also asks
you to accept the NVIDIA Omniverse EULA; set `OMNI_KIT_ACCEPT_EULA=yes` for a non-interactive
environment. Run a project script with `python my_script.py`.

Generate VS Code or Cursor settings for the current workspace with:

```bash
uv run isaaclab --editor
```

> **Warning**
>
> This command generates `.vscode/settings.json` and `pyrightconfig.json` in the workspace.
> The Pyright configuration inherits an existing `[tool.pyright]` table and adds paths discovered
> from the active Python environment.

## Downloaded Isaac Sim package

Use this path when you prefer a downloaded Isaac Sim package instead of pip. Download and extract
the [Isaac Sim pre-built package](https://docs.isaacsim.omniverse.nvidia.com/latest/installation/download.html). Binary installs
must use Isaac Sim's bundled Python; combining them with conda, `uv`, or `venv` is unsupported.
If you need a dedicated Python environment, use [Python environment with Isaac Sim](/source/setup/installation/index#python-environment-with-isaac-sim) instead.

The commands below assume the package was extracted to `${HOME}/isaacsim` on Linux or
`C:\isaacsim` on Windows. Set the installation paths and verify the simulator:

#### Linux

```bash
export ISAACSIM_PATH="${HOME}/isaacsim"
export ISAACSIM_PYTHON_EXE="${ISAACSIM_PATH}/python.sh"
${ISAACSIM_PATH}/isaac-sim.sh
${ISAACSIM_PYTHON_EXE} -c "print('Isaac Sim configuration is now complete.')"
${ISAACSIM_PYTHON_EXE} ${ISAACSIM_PATH}/standalone_examples/api/isaacsim.core.experimental.api/add_cubes.py
```

#### Windows

```batch
set ISAACSIM_PATH="C:\isaacsim"
set ISAACSIM_PYTHON_EXE="%ISAACSIM_PATH:"=%\python.bat"
%ISAACSIM_PATH%\isaac-sim.bat
%ISAACSIM_PYTHON_EXE% -c "print('Isaac Sim configuration is now complete.')"
%ISAACSIM_PYTHON_EXE% %ISAACSIM_PATH%\standalone_examples\api\isaacsim.core.experimental.api\add_cubes.py
```

> **Warning**
>
> If you used an earlier Isaac Sim version, reset its user data and cached variables before the
> first launch: `${ISAACSIM_PATH}/isaac-sim.sh --reset-user` on Linux or
> `%ISAACSIM_PATH%\isaac-sim.bat --reset-user` on Windows.

Clone Isaac Lab, create the `_isaac_sim` link, install, and verify:

#### SSH

```bash
git clone git@github.com:isaac-sim/IsaacLab.git --branch release/3.0.0
cd IsaacLab
```

#### HTTPS

```bash
git clone https://github.com/isaac-sim/IsaacLab.git --branch release/3.0.0
cd IsaacLab
```

#### Linux

```bash
cd IsaacLab
ln -s ${ISAACSIM_PATH} _isaac_sim
sudo apt install cmake build-essential
./isaaclab.sh -i
./isaaclab.sh -p scripts/tutorials/00_sim/create_empty.py --viz kit
```

#### Windows

```batch
cd IsaacLab
mklink /D _isaac_sim %ISAACSIM_PATH%
isaaclab.bat -i
isaaclab.bat -p scripts\tutorials\00_sim\create_empty.py --viz kit
```

The tutorial command should open a black simulator viewport. If either verification command fails,
consult the [Isaac Sim Linux troubleshooting guide](https://docs.omniverse.nvidia.com/dev-guide/latest/linux-troubleshooting.html) or the
[Isaac Sim forums](https://docs.isaacsim.omniverse.nvidia.com/latest/common/feedback.html).

## Build Isaac Sim from source

Build Isaac Sim from source only when you need to modify it or test a nightly revision. Building
requires Ubuntu 22.04 or newer on Linux. For driver requirements, see the [technical requirements](https://docs.omniverse.nvidia.com/materials-and-rendering/latest/common/technical-requirements.html).
On Windows, enable [long-path support](https://learn.microsoft.com/en-us/windows/win32/fileio/maximum-file-path-limitation?tabs=registry#enable-long-paths-in-windows-10-version-1607-and-later)
before building.

Choose how to connect the Isaac Sim source build to Isaac Lab:

#### uv (Recommended)

Clone Isaac Sim next to the Isaac Lab checkout. From the Isaac Lab root, run the source-build
command. It incrementally builds Isaac Sim and links the live release tree as `_isaac_sim`:

```text
git clone https://github.com/isaac-sim/IsaacSim.git ../IsaacSim
uv run isaaclab --isaacsim_source ../IsaacSim
```

Isaac Lab runs the active `uv` environment through Isaac Sim's generated Python launcher.
This loads Kit and extensions directly from the source build without creating wheels or
changing `pyproject.toml` and `uv.lock`. Run Isaac Lab against the source build with:

```text
uv run isaaclab train --rl_library rsl_rl --task Isaac-Cartpole-Direct physics=isaacsim_physx
```

After changing Isaac Sim source, run the same `--isaacsim_source` command again. The native
build is incremental, and the link continues to expose the updated build immediately; no
wheel packaging or dependency resolution step is required.

#### isaaclab.sh / isaaclab.bat

Build and verify Isaac Sim for your platform:

#### \`fa-brands fa-linux\` Linux (x86_64)

```bash
git clone https://github.com/isaac-sim/IsaacSim.git
cd IsaacSim
./build.sh
export ISAACSIM_PATH="${PWD}/_build/linux-x86_64/release"
export ISAACSIM_PYTHON_EXE="${ISAACSIM_PATH}/python.sh"
${ISAACSIM_PATH}/isaac-sim.sh
${ISAACSIM_PYTHON_EXE} -c "print('Isaac Sim configuration is now complete.')"
${ISAACSIM_PYTHON_EXE} ${ISAACSIM_PATH}/standalone_examples/api/isaacsim.core.experimental.api/add_cubes.py
```

#### \`fa-brands fa-linux\` Linux (aarch64)

```bash
git clone https://github.com/isaac-sim/IsaacSim.git
cd IsaacSim
./build.sh
export ISAACSIM_PATH="${PWD}/_build/linux-aarch64/release"
export ISAACSIM_PYTHON_EXE="${ISAACSIM_PATH}/python.sh"
${ISAACSIM_PATH}/isaac-sim.sh
${ISAACSIM_PYTHON_EXE} -c "print('Isaac Sim configuration is now complete.')"
${ISAACSIM_PYTHON_EXE} ${ISAACSIM_PATH}/standalone_examples/api/isaacsim.core.experimental.api/add_cubes.py
```

#### \`fa-brands fa-windows\` Windows (x86_64)

```batch
git clone https://github.com/isaac-sim/IsaacSim.git
cd IsaacSim
build.bat
set ISAACSIM_PATH="%cd%\_build\windows-x86_64\release"
set ISAACSIM_PYTHON_EXE="%ISAACSIM_PATH:"=%\python.bat"
%ISAACSIM_PATH%\isaac-sim.bat
%ISAACSIM_PYTHON_EXE% -c "print('Isaac Sim configuration is now complete.')"
%ISAACSIM_PYTHON_EXE% %ISAACSIM_PATH%\standalone_examples\api\isaacsim.core.experimental.api\add_cubes.py
```

Return to the workspace containing the `IsaacSim` checkout, then clone Isaac Lab:

```text
cd ..
```

#### SSH

```bash
git clone git@github.com:isaac-sim/IsaacLab.git --branch release/3.0.0
cd IsaacLab
```

#### HTTPS

```bash
git clone https://github.com/isaac-sim/IsaacLab.git --branch release/3.0.0
cd IsaacLab
```

Link Isaac Lab to the source build, install, and verify:

#### \`fa-brands fa-linux\` Linux (x86_64)

```bash
cd IsaacLab
ln -s ${ISAACSIM_PATH} _isaac_sim
sudo apt install cmake build-essential
./isaaclab.sh -i
./isaaclab.sh -p scripts/tutorials/00_sim/create_empty.py --viz kit
```

#### \`fa-brands fa-linux\` Linux (aarch64)

```bash
cd IsaacLab
ln -s ${ISAACSIM_PATH} _isaac_sim
sudo apt install cmake build-essential python3.12-dev libgl1-mesa-dev libx11-dev \
   libxcursor-dev libxi-dev libxinerama-dev libxrandr-dev
./isaaclab.sh -i
./isaaclab.sh -p scripts/tutorials/00_sim/create_empty.py --viz kit
```

#### \`fa-brands fa-windows\` Windows (x86_64)

```batch
cd IsaacLab
mklink /D _isaac_sim %ISAACSIM_PATH%
isaaclab.bat -i
isaaclab.bat -p scripts\tutorials\00_sim\create_empty.py --viz kit
```

The tutorial command should open a black simulator viewport. Use the binary-installation
troubleshooting links above if the source build does not launch.

## Docker and HPC clusters

Install [Docker Engine](https://docs.docker.com/engine/install/), [Docker Compose](https://docs.docker.com/compose/install/), and the [NVIDIA Container Toolkit](https://docs.nvidia.com/datacenter/cloud-native/container-toolkit/latest/install-guide.html).
Place the Isaac Lab checkout under `/home` when Docker was installed with Snap.

Clone Isaac Lab, then build, start, and enter the development container:

#### SSH

```bash
git clone git@github.com:isaac-sim/IsaacLab.git --branch release/3.0.0
cd IsaacLab
```

#### HTTPS

```bash
git clone https://github.com/isaac-sim/IsaacLab.git --branch release/3.0.0
cd IsaacLab
```

```bash
./docker/container.py start
./docker/container.py enter base
```

The container uses `/isaac-sim/python.sh` and mounts the repository's `source` and `docs`
directories for live editing. Use `./docker/container.py stop` to stop it and
`./docker/container.py copy` to retrieve logs, data, and documentation artifacts.

For HPC, build the image on a machine with Docker, convert it to an Apptainer/Singularity image,
and submit it with the cluster's SLURM or PBS workflow. Keep cluster-specific paths and scheduler
settings outside the base image.

See [Running Isaac Lab in Docker](/source/workflows/docker/index) for volume management, X11, image extensions, pre-built containers,
worked examples, and complete cluster instructions.

## Cloud workstations

Isaac Automator provisions GPU workstations on AWS, GCP, Azure, and Alibaba Cloud. Install Docker,
then clone and build Isaac Automator:

```bash
git clone https://github.com/isaac-sim/IsaacAutomator.git
cd IsaacAutomator
./build
./run ./deploy-aws
```

Replace `deploy-aws` with `deploy-gcp`, `deploy-azure`, or `deploy-alicloud`. Use
`--isaaclab` and `--isaacsim` to select Git revisions. Connection details for SSH, noVNC, and
NoMachine are stored in `state/<deployment-name>/info.txt`.

Manage the workstation from the Automator container:

```bash
./stop <deployment-name>
./start <deployment-name>
./upload <deployment-name>
./download <deployment-name>
./destroy <deployment-name>
```

Preserve the `state` directory because it contains the deployment metadata.

See [Cloud Deployment](/source/workflows/docker/cloud) for credentials, provider options, connection methods, data transfer,
and the complete workstation lifecycle.

## Next steps

Continue with the [quickstart ](/source/setup/quickstart) to run a task and train a policy.
For asset caching, Nucleus migration, and regional asset services, see
[/source/how-to/manage_asset_downloads](/source/how-to/manage_asset_downloads). For setup, launch, and performance problems, use the
[troubleshooting reference ](/source/refs/troubleshooting).