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

# Quickstart

This page takes you from a fresh checkout to training, replaying, and inspecting
your first task. For prerequisites, see [System requirements](/source/setup/installation/index#system-requirements).
Run all commands from the Isaac Lab repository root with `uv run`. `uv`
creates and manages the project environment for you.

## Install and run your first task

Install [uv](https://docs.astral.sh/uv/getting-started/installation/), clone
Isaac Lab, and enter the repository:

```bash
curl -LsSf https://astral.sh/uv/install.sh | sh
git clone https://github.com/isaac-sim/IsaacLab.git
cd IsaacLab
```

Train Cartpole with the Newton MJWarp physics backend (its default, selected
explicitly here to show the syntax) and open the Newton visualizer:

```bash
uv run isaaclab train --task Isaac-Cartpole --num_envs 16 --viz newton_gl physics=newton_mjwarp
```

Training outputs, including checkpoints, are saved under `logs/`. Add
`--help` to any command to see its available arguments:

```bash
uv run isaaclab train --help
```

## Configure an editor (optional)

To enable import completion and debugging in VS Code or Cursor, generate the
machine-local editor configuration from the repository root:

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

If you use the `isaacsim` extra, include it so the command can discover the
Isaac Sim extensions:

```bash
uv run --extra isaacsim isaaclab --editor
```

VS Code uses Pylance. Cursor users should install basedpyright instead. See
[Editor setup](/source/developer-tools/editor_setup) for complete editor and troubleshooting instructions.

[The same train and play workflow applies across classic control, locomotion, and manipulation tasks.](https://download.isaacsim.omniverse.nvidia.com/isaaclab/videos/task-sampler.mp4)

> **Tip**
>
> `uv run` installs the core dependencies automatically. To use an optional
> integration, add `--extra <name>` before `isaaclab`. You can enable multiple
> extras with a comma-separated list. For example:
>
> ```bash
> uv run --extra ovphysx isaaclab train --task Isaac-Cartpole physics=ovphysx
> ```
>
> Extras make optional capabilities available; task selectors choose which capabilities the task uses
> For example, `--extra ovphysx` makes the OV PhysX integration available, while
> `physics=ovphysx` selects it for the task. You can combine extras as needed. The `--extra all`
> shortcut installs the curated `ov`, `rl-games`, `sb3`, `skrl`, `rsl-rl`, `rerun`,
> and `viser` extras. Isaac Sim, standalone importers, and specialized extras such as `skrl-jax`,
> `rlinf`, `mimic`, `teleop`, `tetrahedralization`, `video`, `leapp`, and `torchrl`
> are not included; add them explicitly. See
> [Optional extras](/source/setup/installation/index#optional-extras) for the complete list.

## Choose an RL library

Pass `--rl_library` to `train` or `play` to choose the RL framework. If
you omit it, Isaac Lab uses the default registered for the task. Most core tasks
default to `rsl_rl`, which is included in the standard `uv run` environment
and is a good starting point for GPU-based training.

| `rsl_rl`   | Fast GPU training and policy distillation      | `uv run isaaclab train --rl_library rsl_rl ...`                    |
| ---------- | ---------------------------------------------- | ------------------------------------------------------------------ |
| `rl_games` | PPO, SAC, and A2C workflows                    | `uv run --extra rl-games isaaclab train --rl_library rl_games ...` |
| `skrl`     | Broad algorithm support with PyTorch and JAX   | `--extra skrl` for PyTorch; `--extra skrl-jax` for JAX             |
| `sb3`      | Stable-Baselines3 and CPU-oriented experiments | `uv run --extra sb3 isaaclab train --rl_library sb3 ...`           |
| `rlinf`    | VLA model fine-tuning                          | `uv run --extra rlinf isaaclab train --rl_library rlinf ...`       |
| `torchrl`  | PPO with PyTorch-native RL components          | `uv run --extra torchrl isaaclab train --rl_library torchrl ...`   |

RL libraries differ in their supported algorithms, tasks, and workflows. See
[Choose an RL library](/source/concepts/reinforcement_learning#choose-an-rl-library) for a detailed comparison.

## The five commands to know

All task commands accept `--task <task_name>`. Start by listing the registered tasks. The list shows
which RL libraries and `physics=` / `renderer=` / `presets=` selectors each task supports, and
runs without Isaac Sim:

```bash
uv run isaaclab list_envs --show_presets
```

| Command        | Use it to                                                          | Example                                                              |
| -------------- | ------------------------------------------------------------------ | -------------------------------------------------------------------- |
| `train`        | Train a policy with an RL library.                                 | `uv run isaaclab train --task Isaac-Cartpole`                        |
| `play`         | Run a trained policy from a checkpoint.                            | `uv run isaaclab play --task Isaac-Cartpole --checkpoint latest`     |
| `zero_agent`   | Run a task with zero actions to verify that it launches correctly. | `uv run isaaclab zero_agent --task Isaac-Cartpole --viz newton_gl`   |
| `random_agent` | Run a task with random actions for a quick interaction smoke test. | `uv run isaaclab random_agent --task Isaac-Cartpole --viz newton_gl` |
| `benchmark`    | Measure environment, training, play, or startup performance.       | `uv run isaaclab benchmark runtime --task Isaac-Cartpole`            |

All supported RL libraries use `--checkpoint` to choose a checkpoint for
playback. See [/source/concepts/reinforcement_learning](/source/concepts/reinforcement_learning) for the
complete training and playback reference.

[On the same Franka drawer-opening task, zero_agent applies no control, random_agent samples actions, and play runs a trained policy from a checkpoint.](https://download.isaacsim.omniverse.nvidia.com/isaaclab/videos/agent-comparison.mp4)

## Choose a backend

Isaac Lab supports multiple physics and rendering backends. Use
`physics=<backend>` to choose the physics implementation. For camera tasks,
use `renderer=<backend>` to choose the renderer.
Available backends depend on the task configuration. Use the task's help output
to see its supported selectors:

```bash
uv run isaaclab train --task Isaac-Cartpole --help
```

| Selector                   | Backend                                                                                  | Required extra        |
| -------------------------- | ---------------------------------------------------------------------------------------- | --------------------- |
| `physics=newton_mjwarp`    | Newton with the MuJoCo-Warp solver.                                                      | None                  |
| `physics=newton_kamino`    | Newton with the Kamino solver. This backend is beta and supports a limited set of tasks. | None                  |
| `physics=ovphysx`          | OV PhysX.                                                                                | `ov` or `ovphysx`     |
| `physics=isaacsim_physx`   | Isaac Sim PhysX.                                                                         | `isaacsim`            |
| `renderer=newton_renderer` | Newton Warp renderer.                                                                    | None                  |
| `renderer=ovrtx`           | OV RTX renderer.                                                                         | `ov` or `ovrtx`       |
| `renderer=isaacsim_rtx`    | Isaac Sim RTX renderer.                                                                  | `isaacsim`            |
| `renderer=rtx`             | Automatic RTX renderer selection.                                                        | `isaacsim` or `ovrtx` |

Use `presets=<name>` to apply a task-specific configuration preset. For
example:

```bash
uv run isaaclab train --task Isaac-Cartpole-Camera physics=newton_mjwarp renderer=newton_renderer presets=rgb
```

Many tasks default to Isaac Sim PhysX, which needs Isaac Sim, while others, such as Cartpole,
already default to Newton. Pick the setup path that matches your install and set its `physics=`
selector whenever a task's default backend doesn't match it. Add `renderer=` only for tasks
with cameras or renderer presets, such as `Isaac-Cartpole-Camera`; other tasks reject it. Run
`uv run isaaclab list_envs --show_presets` to see which combinations a task can launch:

| Setup path                      | Selectors                                                                                  | Install                                                    |
| ------------------------------- | ------------------------------------------------------------------------------------------ | ---------------------------------------------------------- |
| Kit-less (Newton, no Isaac Sim) | `physics=newton_mjwarp`; camera tasks add `renderer=newton_renderer` (or `renderer=ovrtx`) | Default `uv run`; add `--extra ovrtx` for `renderer=ovrtx` |
| With Isaac Sim (PhysX)          | `physics=isaacsim_physx`; camera tasks add `renderer=isaacsim_rtx`                         | `uv run --extra isaacsim`                                  |

See [/source/concepts/backends_and_presets](/source/concepts/backends_and_presets) for backend and preset selection,
and [/source/features/hydra](/source/features/hydra) for arbitrary configuration overrides.

## Visualize a task

Use `--viz` (or `--visualizer`) to choose one or more visualizers during
training or playback. To use multiple visualizers, pass a comma-separated list
without spaces, such as `--viz newton_gl,rerun`.

| Option                           | Use it to                                                           | Required extra |
| -------------------------------- | ------------------------------------------------------------------- | -------------- |
| `--viz newton_gl`                | Open the Newton visualizer.                                         | None           |
| `--viz rerun`                    | Stream the task to the Rerun visualizer.                            | `rerun`        |
| `--viz viser`                    | Open the web-based Viser visualizer, useful for remote connections. | `viser`        |
| `--viz kit`                      | Open the Kit visualizer when it is available in your environment.   | `isaacsim`     |
| Omit `--viz` or use `--viz none` | Run without a visualizer.                                           | None           |

For example, open the same task in both Newton and Rerun:

```bash
uv run --extra rerun isaaclab random_agent --task Isaac-Cartpole \
   physics=newton_mjwarp --viz newton_gl,rerun
```

See [https://isaac-sim.github.io/IsaacLab/release/3.0.0/source/concepts/visualization.html](https://isaac-sim.github.io/IsaacLab/release/3.0.0/source/concepts/visualization.html) for visualizer setup and
configuration.

## Play a trained policy

First, train Cartpole to create a checkpoint:

```bash
uv run isaaclab train --task Isaac-Cartpole
```

Then play the latest checkpoint in the Newton visualizer:

```bash
uv run isaaclab play --task Isaac-Cartpole --checkpoint latest --viz newton_gl
```

Choose a checkpoint with one of the following options:

| Option                    | Loads                                                                                                                    |
| ------------------------- | ------------------------------------------------------------------------------------------------------------------------ |
| `--checkpoint <path>`     | A checkpoint file at the specified local path. Some libraries also accept a run directory.                               |
| `--checkpoint best`       | The library-specific best or final checkpoint. Falls back to `latest` if no separate best or final checkpoint was saved. |
| `--checkpoint latest`     | The highest-step checkpoint from the newest compatible run.                                                              |
| `--checkpoint pretrained` | A pretrained checkpoint hosted by Isaac Lab. Available only for supported tasks.                                         |

## Benchmark a task

`isaaclab benchmark` takes a workflow name as its first argument. Start with
`runtime` to measure environment-step capacity without a policy:

```bash
uv run isaaclab benchmark runtime --task Isaac-Cartpole
```

| Workflow    | Measures                                                                                                                        |
| ----------- | ------------------------------------------------------------------------------------------------------------------------------- |
| `runtime`   | Environment-step capacity with random actions (no policy).                                                                      |
| `startup`   | Launch, import, configuration, scene creation, and first-step latency.                                                          |
| `training`  | End-to-end learning throughput. Requires `--rl_library`.                                                                        |
| `play`      | Trained-policy rollout throughput. Requires `--rl_library` and `--checkpoint`.                                                  |
| `_multigpu` | Run `startup`, `runtime`, or `training` across multiple GPUs by adding the suffix `_multigpu`. For example, `runtime_multigpu`. |

See [Benchmarking](/source/developer-tools/benchmarking/index) for benchmark fundamentals and
[Multi-GPU and Multi-Node Training](/source/features/multi_gpu) for multi-GPU training and benchmarks.

## Next steps

* Browse registered environments and build a command: [https://isaac-sim.github.io/IsaacLab/release/3.0.0/source/setup/environments.html](https://isaac-sim.github.io/IsaacLab/release/3.0.0/source/setup/environments.html)
* Learn how backends and presets fit together: [/source/concepts/backends_and_presets](/source/concepts/backends_and_presets)
* Learn how to override task configuration: [/source/features/hydra](/source/features/hydra)
* Find tutorials and task-focused documentation: [/source/how-to/index](/source/how-to/index)
* Read the installation options and troubleshooting guide: [Installation](/source/setup/installation/index)