isaaclab-arena

Isaac Lab-Arena

Composable Environment Creation and Policy Evaluation for Robotics Simulation

Documentation · NVIDIA Blog Post · Report a Bug · Discussions

[!WARNING] Alpha Software — Not an Early Access or General Availability Release. Isaac Lab-Arena v0.3 is an early code release intended to give the community a practical starting point to experiment, provide feedback, and influence future design direction. APIs are unstable and will change. Features are incomplete. Documentation is evolving. Do not use this in production. See Project Status for details.

[!NOTE] Changes on main contain an in-development version based on v0.3.1 and Isaac Lab 3.0.

Overview

Isaac Lab-Arena is an open-source framework for scalable benchmark authoring and robot policy evaluation in simulation. It extends NVIDIA Isaac Lab with reusable APIs to author benchmarks, execute evaluations at scale, and analyze results for actionable feedback.

Instead of hand-writing and maintaining a separate configuration for every combination of robot, object, and scenario, Arena composes environments from three independent primitives: a scene, which defines the physical layout and its objects, furniture, and fixtures; an embodiment, which defines the robot, observations, actions, sensors, and controllers; and a task, which defines what the robot must accomplish. ArenaEnvBuilder combines them into a standard ManagerBasedRLEnvCfg that runs natively in Isaac Lab.

Building on that foundation, Arena provides three connected capabilities across the benchmark and policy-evaluation workflow:

Why Isaac Lab-Arena?

See the documentation overview for the motivation behind Arena and how it addresses evaluation scale, reproducibility, and failure diagnosis.

Key Features

Author Scalable Benchmarks

• Composable environments — Configure scenes, embodiments, and tasks independently, with reusable objects composed into each scene. ArenaEnvBuilder assembles them into an Isaac Lab environment without duplicating task logic.
• Relational object placement — Define layouts with spatial relationships such as "on" and "next to" instead of hard-coded coordinates.
• Sequential task chaining — Chain atomic skills (pick, walk, place, …) into long-horizon composite tasks.
• Agentic environment generation (experimental) — Describe a task in natural language; an agent infers constraints, creates a reviewable specification, finds SimReady USD assets, and builds a family of Arena environments. Initial examples cover composite pick-and-place.
• Controlled environment variations — Turn one environment into a perturbation sweep over lighting, backgrounds, camera parameters, object mass, and other configurable ranges and distributions.
• Isaac Lab interoperability — Register Arena-authored environments with Isaac Lab workflows for reinforcement learning and data generation.

Execute Evaluations at Scale

• GPU-accelerated parallel evaluation — Evaluate one policy across thousands of heterogeneous environments concurrently instead of running sequential rollouts.
• Large-scale multi-node evaluation — Define experiments with multiple tasks and policies, run locally or distribute them with an orchestrator such as OSMO, and collect aggregate metrics plus per-episode results.
• Policy client-server architecture — Evaluate GR00T, π0.5, or a custom policy behind a server through a common observation-and-action contract.
• Streamlined setup and agent skills — Use the native uv installation path and reusable agent skills for key workflows.

Analyze Policy Robustness

• Subtask predicates — Track milestones such as grasp, lift, transport, and place to pinpoint where a policy fails.
• Sensitivity analysis — Perturb environment factors to reveal robustness gaps and generate actionable feedback for targeted policy learning.

Quick Start

Prerequisites

• Linux (Ubuntu 22.04+)
• NVIDIA GPU (see Isaac Sim hardware requirements)
• uv (for the native install), or Docker and the NVIDIA Container Toolkit (for the container install)
• Git

Installation

Native developer setup with uv:

# 1. Clone the repository
git clone --recurse-submodules git@github.com:isaac-sim/IsaacLab-Arena.git
cd IsaacLab-Arena

# 2. Create the locked environment (Isaac Lab from source, plus the Isaac Sim, PyTorch, and Newton wheels)
uv sync

# 3. Activate the environment and accept the Isaac Sim EULA
source .venv/bin/activate
export OMNI_KIT_ACCEPT_EULA=YES ACCEPT_EULA=Y

# 4. Verify the installation with a short zero-action rollout
python isaaclab_arena/evaluation/policy_runner.py \
  --policy_type zero_action --num_steps 20 cube_goal_pose

# 4b. (Optional) Watch the rollout in the GUI visualizer
python isaaclab_arena/evaluation/policy_runner.py \
  --viz kit --policy_type zero_action --num_steps 200 cube_goal_pose

Note: See our installation docs for more details and installation flavors.

Source install inside Docker:

# 1. Clone the repository
git clone git@github.com:isaac-sim/IsaacLab-Arena.git
cd IsaacLab-Arena
git submodule update --init --recursive

# 2. Launch the Docker container
#    Base container (recommended for development):
./docker/run_docker.sh

#    Or with GR00T dependencies (for policy training/evaluation):
./docker/run_docker.sh -g

# 3. Verify the installation with a short zero-action rollout
/isaac-sim/python.sh isaaclab_arena/evaluation/policy_runner.py \
  --policy_type zero_action --num_steps 20 cube_goal_pose

# 3b. (Optional) Watch the rollout in the GUI visualizer
/isaac-sim/python.sh isaaclab_arena/evaluation/policy_runner.py \
  --viz kit --policy_type zero_action --num_steps 200 cube_goal_pose

Note: The Docker script automatically mounts $HOME/datasets, $HOME/models, and $HOME/eval from your host into the container.

For detailed setup instructions (including server-client mode for GR00T), see the Installation Guide.

Usage Example

Compose a Franka arm in a kitchen scene with a couple of objects:

from isaaclab_arena.assets.asset_registry import AssetRegistry
from isaaclab_arena.environments.arena_env_builder import ArenaEnvBuilder, ArenaEnvBuilderCfg
from isaaclab_arena.environments.isaaclab_arena_environment import IsaacLabArenaEnvironment
from isaaclab_arena.scene.scene import Scene

asset_registry = AssetRegistry()

# Select building blocks
background = asset_registry.get_asset_by_name("kitchen")()
embodiment = asset_registry.get_asset_by_name("franka_ik")()
cracker_box = asset_registry.get_asset_by_name("cracker_box")()
tomato_soup_can = asset_registry.get_asset_by_name("tomato_soup_can")()

# Compose the environment
scene = Scene(assets=[background, cracker_box, tomato_soup_can])
env_cfg = IsaacLabArenaEnvironment(
    name="franka_kitchen_example",
    embodiment=embodiment,
    scene=scene,
)

builder_cfg = ArenaEnvBuilderCfg()
env_builder = ArenaEnvBuilder(env_cfg, builder_cfg)
env = env_builder.make_registered()
env.reset()

Python callers set builder options directly on ArenaEnvBuilderCfg. Runner scripts continue to accept the same options as CLI flags, such as --num_envs 4 --seed 7, and translate them into an ArenaEnvBuilderCfg before building the environment.

Continue in the Documentation

Getting Started

Choose a guide based on what you want to do:

• First Arena Environment — Compose a scene, embodiment, and task into a reusable environment.
• First Arena Experiment — Define and run multiple evaluation configurations as one experiment.
• Exploring Environment Variations — Sample controlled changes to lighting, cameras, and backgrounds.
• Running a Real Policy — Evaluate a pretrained policy from a saved configuration.

Ready-to-Use Environments

• Example Environments — Browse Python-registered environments, RoboLab-inspired tasks, and Kitchen Benchmark specifications.

Example Workflows

Explore complete workflows for:

• Evaluation — Run controlled sweeps and analyze the conditions associated with policy success or failure.
• Agentic Environment Generation — Generate Arena environment specifications from natural-language prompts.
• Imitation Learning — Collect data, post-train a policy, and run closed-loop evaluation.
• Reinforcement Learning — Set up an environment, train a policy, and run closed-loop evaluation.

Project Structure