Installation

Isaac Lab installs Newton by default. The standard installation runs without Isaac Sim; add Isaac Sim or other optional backends when your workflow needs them. Start with the automatic uv setup, or choose another installation method below.

Choose an installation path

System requirements

Isaac Lab installs Newton by default, using NVIDIA Warp for simulation. The requirements below cover the default Newton and PyTorch training environment; Isaac Sim is an optional addition.

This release uses Warp 1.17. Its prebuilt wheels include the CUDA components needed by Warp, so a separate CUDA Toolkit installation is not needed for standard wheel-based use. See Warp installation and compatibility for its platform and GPU requirements.

Optional Isaac Sim and rendering

• Isaac Sim: Install the isaacsim extra for Isaac Sim 6.2 / PhysX workflows. On Linux, its wheels require GLIBC 2.35+. For x86_64 workstations, plan for at least 32 GB RAM, 16 GB VRAM, and a supported RTX GPU; training and rendering may need more. Check the Isaac Sim requirements for supported GPUs, tested drivers, and DGX Spark support. Isaac Sim 5.1 and older are unsupported.
• Rendering: Headless Newton simulation does not require RTX hardware. Add the requirements of your chosen renderer or visualizer when you need camera images or an interactive view. RTX rendering has its own GPU and driver requirements.

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

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:

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

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

# 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:

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

See 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/isaaclab/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 or conda before starting:

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

uv venv --python 3.12 --seed env_isaaclab
source env_isaaclab/bin/activate
uv pip install --upgrade pip
./isaaclab.sh -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:

For example:

# 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]'

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 before installing on Windows.

Create and activate a Python 3.12 environment:

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

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

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

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

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:

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

sudo apt install cmake build-essential
./isaaclab.sh -i
./isaaclab.sh -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.

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:

[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| release. 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.

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

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.

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.

Installing the importers extra

Installing the importers extra

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

uv pip install "isaaclab[importers]==3.0.0" \
  --overrides "https://raw.githubusercontent.com/isaac-sim/IsaacLab/v3.0.0/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:

uv pip install "isaaclab[isaacsim]==3.0.0" \
  --overrides "https://raw.githubusercontent.com/isaac-sim/IsaacLab/v3.0.0/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:

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

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

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:

uv run isaaclab --editor

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. 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 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:

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

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

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

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

The tutorial command should open a black simulator viewport. If either verification command fails, consult the Isaac Sim Linux troubleshooting guide or the Isaac Sim forums.

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. On Windows, enable long-path support before building.

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

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

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

Docker containers

Docker packages Isaac Lab and its dependencies into a reusable environment. docker/container.py is the main entry point for running Isaac Lab in a container. It wraps docker compose so that you do not have to remember which Dockerfile, environment files, and volume mounts belong together — you name a profile, and the script assembles the rest.

For remote execution, see Running on HPC Clusters and Cloud Deployment.

Clone Isaac Lab before running the container commands below:

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

Prerequisites

Install Docker Engine, Docker Compose, and the NVIDIA Container Toolkit. The container is tested with Docker Engine 26.0.0 and Docker Compose 2.25.0; use these versions or newer. Follow the post-installation steps so that Docker runs without sudo.

The Isaac Sim documentation on container installation covers the same prerequisites in more detail, including how to obtain access to the Isaac Sim image.

Container profiles

A profile is a Docker Compose profile: docker-compose.yaml tags each service with one, and Compose starts only the services whose profile is active. Naming a profile therefore selects a matched set — one service, one Dockerfile, one set of environment files, and one image name:

Every command below takes the profile as its first positional argument and defaults to base. Only one profile applies at a time, and the resulting image and container are both named isaac-lab-<profile>. Pass --suffix to append a name suffix when you want several variants of the same profile side by side. Do not use --suffix with cluster deployments, whose export commands expect the unsuffixed image name.

For what each image actually contains and how to choose between them, see Container images.

Start, run, and retrieve results

From the repository root on the host, build and start the default base container, then open a shell in it. Append a profile to target a different image:

./docker/container.py start
./docker/container.py enter

Inside the container, run the logging example without a visualizer:

uv run isaaclab -p scripts/tutorials/00_sim/log_time.py --viz none

The script writes simulation time at each step to /workspace/isaaclab/logs/docker_tutorial/log.txt. Stop the script with Ctrl+C and type exit to return to the host shell. Retrieve the results before stopping the container:

./docker/container.py copy
./docker/container.py stop

The log is now at docker/artifacts/logs/docker_tutorial/log.txt on the host. The stop command removes the container and its Compose-managed volumes, including logs and caches; copy out anything you need first. The image remains. To remove it after stopping, run docker image rm isaac-lab-base; the next start rebuilds it. See Docker pruning for other cleanup options.

# Copyright (c) 2022-2026, The Isaac Lab Project Developers (https://github.com/isaac-sim/IsaacLab/blob/main/CONTRIBUTORS.md).
# All rights reserved.
#
# SPDX-License-Identifier: BSD-3-Clause
"""
This script demonstrates how to generate log outputs while the simulation plays.
It accompanies the tutorial on docker usage.
.. code-block:: bash
    # Usage
    uv run python scripts/tutorials/00_sim/log_time.py
"""
"""Parse the command-line arguments first."""
import argparse
import os
from isaaclab.app import add_launcher_args, launch_simulation
# create argparser
parser = argparse.ArgumentParser(description="Tutorial on creating logs from within the docker container.")
# append simulation launcher cli args
add_launcher_args(parser)
# parse the arguments
args_cli = parser.parse_args()
"""Rest everything follows."""
from isaaclab.sim import SimulationCfg, SimulationContext
def main():
    """Main function."""
    # Specify that the logs must be in logs/docker_tutorial
    log_dir_path = os.path.join("logs")
    if not os.path.isdir(log_dir_path):
        os.mkdir(log_dir_path)
    # In the container, the absolute path will be
    # /workspace/isaaclab/logs/docker_tutorial, because
    # all Python execution is done through the uv-managed workspace
    # and the calling process' path will be /workspace/isaaclab
    log_dir_path = os.path.abspath(os.path.join(log_dir_path, "docker_tutorial"))
    if not os.path.isdir(log_dir_path):
        os.mkdir(log_dir_path)
    print(f"[INFO] Logging experiment to directory: {log_dir_path}")
    # Configure the simulation
    sim_cfg = SimulationCfg(dt=0.01, device=args_cli.device)
    # Launch the simulator runtime that the configuration needs
    with launch_simulation(sim_cfg, args_cli):
        # Initialize the simulation context
        sim = SimulationContext(sim_cfg)
        # Set main camera
        sim.set_camera_view([2.5, 2.5, 2.5], [0.0, 0.0, 0.0])
        # Play the simulator
        sim.reset()
        # Now we are ready!
        print("[INFO]: Setup complete...")
        # Prepare to count sim_time
        sim_dt = sim.get_physics_dt()
        sim_time = 0.0
        # Open logging file
        with open(os.path.join(log_dir_path, "log.txt"), "w") as log_file:
            # Simulate physics
            while sim.is_running():
                log_file.write(f"{sim_time}" + "\n")
                # perform step
                sim.step()
                sim_time += sim_dt
if __name__ == "__main__":
    # run the main function
    main()

container.py command reference

container.py command reference

Run ./docker/container.py --help to list commands and ./docker/container.py <command> --help for that command’s arguments.

Every command accepts the following arguments:

Extending the Compose configuration

--files and --env-files merge extra Compose and environment files into the generated configuration, which is how optional components are layered on without editing the checked-in files. Streaming to XR devices is the worked example — it adds the CloudXR Runtime service alongside base:

./docker/container.py start --files docker-compose.cloudxr-runtime.patch.yaml --env-files .env.cloudxr-runtime

Stop it with the same arguments. The teleoperation setup, firewall rules, and client connection steps are covered in Setting up Isaac Capture with CloudXR. Use ./docker/container.py config to print the merged result when a combination does not behave as expected.

What persists between runs

The compose file declares named volumes for Isaac Sim caches, logs, and your own data. They remain available while reusing a container, but container.py stop runs docker compose down --volumes` and removes them. Run `container.py copy` before `stop to preserve your results on the host.

container.py copy extracts the three volumes you are most likely to want on the host — logs, data_storage, and docs/_build — into docker/artifacts. For anything else, use docker cp, for example docker cp isaac-lab-base:/workspace/isaaclab/logs ..

If you are upgrading from an Isaac Lab image that ran as root, the existing volumes still hold root-owned files that the current uid/gid 1000 runtime user cannot write. Copy out anything worth keeping, then recreate them from the docker directory:

docker compose --file docker-compose.yaml --profile base --env-file .env.base down --volumes

Display forwarding with X11

X11 forwarding lets GUI applications started inside the container display on the host. The first start asks whether to enable it and records the answer in docker/.container.cfg. To change it later, set X11_FORWARDING_ENABLED to 0 or 1 in that file and run start again — the rebuild is what applies the change.

Container images

Each profile builds a different image. They differ in what simulation and rendering stack they carry, which decides how large they are and what they can run. This section describes the images themselves; to build or run one, name its profile in the container lifecycle.

Choosing an image

Building an image

Every image builds with the same command; only the profile name changes. From the repository root, build the image for a profile from the table above, for example kitless:

./docker/container.py build kitless

./docker/container.py start kitless also builds the image before starting the container. Without Compose, build the profile’s Dockerfile directly; it uses the same default paths:

docker build --pull --file docker/Dockerfile.kitless --tag isaac-lab-kitless .

Release images are also published pre-built, so building is optional; see Pre-built image from NGC.

Base image

Dockerfile.base overlays Isaac Lab’s dependencies onto the Isaac Sim container, so it inherits Kit, RTX rendering, and the Isaac Sim asset pipeline. The Isaac Sim version it builds against is set by ISAACSIM_VERSION in .env.base; the other variables in that file control paths inside the container.

ROS 2 image

Dockerfile.ros2 installs ROS 2 Humble from an apt package and sources it in the runtime user’s .bashrc. ROS2_APT_PACKAGE in .env.ros2 selects the package set, defaulting to ros-base. The image defaults to the FastRTPS middleware; CycloneDDS is also supported, and both can be tuned through their .xml files under docker/.ros. See various middleware for the trade-offs.

###
# ROS2 specific settings
###
# Set the version of the ROS2 apt package to install (ros-base, desktop, desktop-full)
ROS2_APT_PACKAGE=ros-base
# Set ROS2 middleware implementation to use (e.g. rmw_fastrtps_cpp, rmw_cyclonedds_cpp)
RMW_IMPLEMENTATION=rmw_fastrtps_cpp
# Path to fastdds.xml file to use (only needed when using fastdds)
FASTRTPS_DEFAULT_PROFILES_FILE=${DOCKER_USER_HOME}/.ros/fastdds.xml
# Path to cyclonedds.xml file to use (only needed when using cyclonedds)
CYCLONEDDS_URI=${DOCKER_USER_HOME}/.ros/cyclonedds.xml
# Docker image and container name suffix (default "", set by the container_interface.py script)
# Example: "-custom"
DOCKER_NAME_SUFFIX=""

Kit-less image

The kit-less image drops Isaac Sim entirely and builds on Ubuntu 24.04 with Python 3.12. It carries Newton physics, OVPhysX physics, OVRTX rendering, and the four core RL frameworks: RL Games, RSL-RL, Stable-Baselines3, and SKRL. The newton_gl, newton_rtx, viser, and rerun visualizers are included. Use --viz newton_gl for local visualization with a display available in the container. --viz newton_gl selects the OpenGL rasterizer; --viz newton_rtx selects the OVRTX path tracer. Both can render offscreen without Isaac Sim. To open their windows from a direct docker run, run xhost +local: on the host and add -e DISPLAY and -v /tmp/.X11-unix:/tmp/.X11-unix:rw to the command below. The deprecated --viz newton alias selects GL; it does not choose between GL and RTX automatically.

Rendering needs NVIDIA graphics driver capabilities in addition to compute. For direct docker run commands, pass --gpus all -e NVIDIA_DRIVER_CAPABILITIES=all. The NVIDIA Container Toolkit exposes the host driver; avoid mounting a second copy of its Vulkan ICD. If multiple drivers are discovered, select the NVIDIA ICD available inside the container with VK_DRIVER_FILES (for example, /etc/vulkan/icd.d/nvidia_icd.json).

No visualizer is selected by default, so training runs headless unless you ask for one. The kit visualizer is the exception: it comes from Omniverse Kit, which this image does not contain.

Unlike the other two, it bind-mounts apps in addition to source, scripts, tools, and docs, and it keeps a uv cache and a Warp cache of its own.

You do not have to build it locally. It is published alongside each Isaac Lab release in the same registry repository, distinguished by a -kitless tag suffix:

docker pull nvcr.io/nvidia/isaac-lab:3.0.0-kitless

Running it directly, outside the Compose workflow, is a convenient way to verify the image and your NVIDIA Container Toolkit setup. --interactive and --tty keep the container’s shell alive so that several commands can share it. The isaac-lab-kitless-logs named volume keeps checkpoints after the container is removed:

docker run --name isaac-lab-kitless --detach --interactive --tty --gpus all --network host \
    -e NVIDIA_DRIVER_CAPABILITIES=all \
    -v isaac-lab-kitless-logs:/workspace/isaaclab/logs \
    nvcr.io/nvidia/isaac-lab:3.0.0-kitless
docker exec isaac-lab-kitless \
    isaaclab train --rl_library rsl_rl --task Isaac-Cartpole-Direct \
    --num_envs 16 presets=newton_mjwarp --max_iterations 5

Replay in a browser with:

docker exec --interactive --tty isaac-lab-kitless \
    isaaclab play --rl_library rsl_rl --task Isaac-Cartpole-Direct \
    --num_envs 16 presets=newton_mjwarp --checkpoint latest --viz viser

Viser is reachable through the host network without forwarding a desktop display. Stop playback with Ctrl+C without stopping the container. Copy the logs to the host with docker cp isaac-lab-kitless:/workspace/isaaclab/logs ./logs.

Check which architectures a tag publishes with docker buildx imagetools inspect <image:tag> before choosing a host.

Pre-built image from NGC

A minimal pre-built container carries a small set of Isaac Sim and Omniverse dependencies with Isaac Lab already built in, under /workspace/isaaclab. The example below runs without a forwarded desktop display. Choose the image profile for the physics and rendering stack you need, and configure graphics access separately when rendering.

mkdir -p ~/docker/isaac-sim/{cache/kit,cache/ov,cache/pip,cache/glcache,cache/computecache,logs,data,documents}
sudo chown -R 1000:1000 ~/docker/isaac-sim

Because it is run outside Compose, the Isaac Sim cache directories have to be mounted by hand, otherwise every start recompiles shaders:

docker run --name isaac-lab --entrypoint bash -it --gpus all -e "ACCEPT_EULA=Y" --rm --network=host \
   -e "PRIVACY_CONSENT=Y" \
   -v ~/docker/isaac-sim/cache/kit:/isaac-sim/kit/cache:rw \
   -v ~/docker/isaac-sim/cache/ov:/root/.cache/ov:rw \
   -v ~/docker/isaac-sim/cache/pip:/root/.cache/pip:rw \
   -v ~/docker/isaac-sim/cache/glcache:/root/.cache/nvidia/GLCache:rw \
   -v ~/docker/isaac-sim/cache/computecache:/root/.nv/ComputeCache:rw \
   -v ~/docker/isaac-sim/logs:/root/.nvidia-omniverse/logs:rw \
   -v ~/docker/isaac-sim/data:/root/.local/share/ov/data:rw \
   -v ~/docker/isaac-sim/documents:/root/Documents:rw \
   nvcr.io/nvidia/isaac-lab:3.0.0

The command above opens no windows: without a display, --viz kit, --viz newton_gl, and --viz newton_rtx run headless. The viser and rerun visualizers serve a web page instead and need no display. To enable rendering through X11 forwarding, let local clients use the host X server and pass the display into the container:

xhost +local:
docker run --name isaac-lab --entrypoint bash -it --gpus all -e "ACCEPT_EULA=Y" --rm --network=host \
   -e "PRIVACY_CONSENT=Y" \
   -e DISPLAY \
   -e MUJOCO_GL=disable \
   -v /tmp/.X11-unix:/tmp/.X11-unix:rw \
   -v ~/docker/isaac-sim/cache/kit:/isaac-sim/kit/cache:rw \
   -v ~/docker/isaac-sim/cache/ov:/root/.cache/ov:rw \
   -v ~/docker/isaac-sim/cache/pip:/root/.cache/pip:rw \
   -v ~/docker/isaac-sim/cache/glcache:/root/.cache/nvidia/GLCache:rw \
   -v ~/docker/isaac-sim/cache/computecache:/root/.nv/ComputeCache:rw \
   -v ~/docker/isaac-sim/logs:/root/.nvidia-omniverse/logs:rw \
   -v ~/docker/isaac-sim/data:/root/.local/share/ov/data:rw \
   -v ~/docker/isaac-sim/documents:/root/Documents:rw \
   nvcr.io/nvidia/isaac-lab:3.0.0

xhost +local: lets every local client use your display, not only the container; run xhost -local: on the host to revoke it when you are done. MUJOCO_GL=disable is needed by the Newton viewers in images released before it was set in the image: those inherit MUJOCO_GL=egl, which fails the windowed viewer with Attempt to retrieve context when no valid context. The Compose workflow sets up X11 forwarding for you; see Installation. Follow the graphics-driver requirements above for GL or RTX.

Runtime user

The base, ROS 2, cuRobo, and kit-less images all run as a non-root user with uid/gid 1000. When running one of these images directly with docker run, keep that default user instead of passing --user, so that the runtime home and cache directories stay writable. Named volumes inherit the image’s ownership; make host bind mounts writable with sudo chown -R 1000:1000 <directory>.

Python interpreter

Every image installs from uv.lock into a Python 3.12 virtual environment at /opt/isaaclab-venv. On the Isaac Sim-based images the environment is built on Isaac Sim’s own interpreter, and Isaac Sim itself stays outside it, reached through the _isaac_sim symlink; isaaclab.sh puts it on the path. In either case python on the container’s PATH resolves to the right one, so scripts are run the same way regardless of image.

Cloud workstations

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

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:

./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 for credentials, provider options, connection methods, data transfer, and the complete workstation lifecycle.

Next steps

Continue with the 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. For setup, launch, and performance problems, use the troubleshooting reference .