# Isaac Lab Basics

This module puts the concepts from [Robot Learning
Fundamentals](https://docs.nvidia.com/learning/physical-ai/getting-started-with-isaac-lab/2026-10.0/robot-learning-fundamentals/index.md) into practice. You’ll
explore Isaac Lab and its related frameworks, physics engines, and libraries,
generate a new project, and train and inspect a cartpole policy. The generated
example gives you a small task to follow from configuration through manager
execution and policy playback before you build the SO-101 task in [Train a Robot
Arm](https://docs.nvidia.com/learning/physical-ai/getting-started-with-isaac-lab/2026-10.0/train-a-robot-arm/index.md).

If you’re ready for a more complex task, you can skip ahead to [Train a Robot Arm](https://docs.nvidia.com/learning/physical-ai/getting-started-with-isaac-lab/2026-10.0/train-a-robot-arm/index.md) and return to this module
later.

The cartpole example introduces how Isaac Lab organizes a learning task. You
describe the actions the policy can take, the observations it receives, and how
to score or end an episode. Isaac Lab uses helper objects called *managers* to
carry out those parts of the task while the simulation runs.

![An env_cfg.py map pairs the generated cartpole configuration classes with their runtime task managers for actions, observations, events, rewards, and episode endings.](images/isaac-lab-manager-system.svg)

Use this diagram as a map as you work through the module. You’ll find these
configuration classes in the generated project, then trace how the managers
use them in [Manager-Based Workflows](https://docs.nvidia.com/learning/physical-ai/getting-started-with-isaac-lab/2026-10.0/isaac-lab-basics/05-manager-based-workflows.md). You don’t
need to learn the class names before you begin.

#### Learning Objectives
- Explain how Isaac Lab connects robot learning tasks, physics backends, and learning libraries.
- Generate a cartpole project and find its task registration, environment configuration, and Proximal Policy Optimization (PPO) configuration.
- Set up a local or remote development workflow and keep a record of experiment settings and outputs.
- Describe how managers handle actions, observations, resets, rewards, and episode endings.
- Use the Isaac Lab CLI to run zero-action and random-action baselines, train a PPO policy, and play saved checkpoints.
- Compare training metrics and policy playback with baselines to assess learning progress and identify further reliability checks.

## How to Use Code Blocks

Read the instructions above each block. They tell you where to run a command or
paste code and which values you need to change first. The labels below show how
to use each type of block; these examples illustrate the conventions used in
each lesson.

- **Paste:** Copy the code into the file named in the instructions. For example,
  an instruction to replace `episode_length_s` in `env_cfg.py` might show:
  ```python
  episode_length_s = 20.0
  ```
- **Run:** Copy the command and run it in the specified terminal or directory.
  For example, this command lists task IDs and presets from a generated project:
  ```bash
  uv run python scripts/list_envs.py --show_presets
  ```
- **Reference:** Read the example to understand the code or command syntax.
  Reference blocks have a gray background and no copy button. You do not need to
  run or paste them. For example, angle-bracket values below are placeholders:
  ```bash
  uv run isaaclab <command> --task <task-id>
  ```
- **Output:** Compare the block with what your command produces. Output blocks
  have a gray background and no copy button. This expected output is illustrative;
  paths, timings, and checkpoint names may differ in your run:
  ```text
  Training complete.
  Checkpoint saved: logs/example-run/model_100.pt
  ```
- **Optional: Run** or **Optional: Paste:** A dashed border marks a step you can
  skip and continue the lesson. The copy button remains available. For example,
  you can optionally explore the CLI from your project directory:
  ```bash
  uv run isaaclab --help
  ```

You can still select text in reference examples and output blocks.

Use the *activities* to check your understanding as you go.
Here are some tips for completing them:

- Make a prediction about the outcome of a command before running it.
- After running a command, change one thing and describe what you observe.
- Answer the understanding question before opening its answer or hint.
- Use an agent to quiz yourself on the learning objectives.