# NVIDIA Isaac Lab-Arena

> Source: https://aiwiki.ai/wiki/isaac_lab_arena
> Updated: 2026-07-24
> Categories: AI Benchmarks, Developer Tools, NVIDIA, Open Source AI, Physical AI, Robotics
> License: CC BY 4.0 (https://creativecommons.org/licenses/by/4.0/)
> From AI Wiki (https://aiwiki.ai), the free encyclopedia of artificial intelligence. Reuse freely with attribution to "AI Wiki (aiwiki.ai)".

NVIDIA Isaac Lab-Arena is an open-source framework for composing simulated robot tasks and evaluating learned policies at scale. It is developed by the NVIDIA Robotics Team, with its evaluation and task layers co-developed with Lightwheel, as an extension to [NVIDIA Isaac Lab](/wiki/isaac_lab). NVIDIA announced the public pre-alpha release on January 5, 2026.[1][2]

Arena is a separate project rather than a feature name inside Isaac Lab. It has its own `isaac-sim/IsaacLab-Arena` repository, documentation, versioned branches, task and policy interfaces, evaluation runners, metrics, tests, and Apache License 2.0 license. The repository labels the current code family `v0.2.x` alpha and says it is neither Early Access nor General Availability. Its APIs may change without deprecation, features and documentation remain incomplete, and NVIDIA explicitly advises against production use.[2][4]

## Purpose and architecture

Isaac Lab-Arena addresses a configuration problem in [robot learning](/wiki/robot_learning): evaluating one policy across many robots, objects, scenes, and tasks can produce a separate, largely duplicated environment definition for every combination. Arena instead assembles an environment at runtime from three reusable parts.[2][3]

| Part | Responsibility |
| --- | --- |
| Scene | Physical layout, objects, furniture, fixtures, and lighting |
| Embodiment | Robot body, observations, actions, sensors, and controllers |
| Task | Objective, success and failure conditions, terminations, events, and metrics |

`ArenaEnvBuilder` compiles these parts into an Isaac Lab `ManagerBasedRLEnvCfg`. An object can expose an affordance such as `Openable` or `Pressable`, allowing one task definition to operate on different compatible objects. Placement relationships such as `On`, `NextTo`, and `AtPosition` describe layouts without hard-coding every pose.[3][4]

Arena does not provide a physics engine. [NVIDIA Isaac Sim](/wiki/nvidia_isaac_sim) supplies the simulation runtime and RTX rendering, while Isaac Lab supplies batched environments, physics integration, sensors, and workflows for [reinforcement learning](/wiki/reinforcement_learning) and [imitation learning](/wiki/imitation_learning). Arena adds task composition, policy adapters, experiment execution, recording, and evaluation. Current documentation aligns the main `v0.2.x` path with Isaac Lab 3.0 and Isaac Sim 6.0, including PhysX and experimental [Newton](/wiki/newton) workflows.[2][4][8][12]

## Tasks, assets, and policies

The official examples cover tabletop manipulation, room-scale loco-manipulation, articulated objects, assembly, and reinforcement-learning tasks. They are examples and reusable components, not a fixed benchmark suite.[4][7]

| Area | Representative examples |
| --- | --- |
| Pick and place | Kitchen object placement, DROID tabletop tasks, Galileo lab tasks |
| Articulated objects | Open or close a door, turn a mixer knob, press a button |
| Sorting and assembly | Object sorting, peg insertion, gear meshing |
| Goal and lift | Franka object lifting, Kuka-Allegro dexterous lifting |
| Sequential tasks | Pick an item, place it in a refrigerator, then close the door |
| Loco-manipulation | Unitree G1 walking, squatting, picking, and placing in a room-scale scene |

Documented embodiment integrations include Franka Panda, DROID, Unitree G1, Fourier GR-1, Agibot, Galbot, and Kuka with an Allegro hand. Asset registries hold robot and object configurations, backgrounds, lighting, and teleoperation devices. Many meshes and scenes are fetched from Isaac Sim or partner asset stores rather than embedded as self-contained files in the Arena package.[2][7][8]

A policy in Arena implements a common observation-to-action interface. The core documentation describes zero-action validation, HDF5 action replay, and RSL-RL checkpoint inference, while the repository includes local and remote GR00T adapters. Custom policy classes can be registered without changing the evaluation runners.[2][5]

The [Hugging Face](/wiki/hugging_face) [LeRobot](/wiki/lerobot) integration distributes Arena environments and compatible datasets through EnvHub. Its examples cover GR00T N models, PI0.5, SmolVLA, ACT, and diffusion policies, including pretrained PI0.5 and SmolVLA policies for a GR1 microwave task. These integrations vary by branch and package; they are not all bundled into every Arena version.[10]

## Evaluation protocol and metrics

Isaac Lab-Arena is a framework for building and running benchmarks, not one benchmark with a canonical split, episode budget, aggregate score, or leaderboard. A benchmark author chooses the task, embodiment, objects, policy, success predicate, episode count, seed, observations, action space, controller settings, and simulator configuration. External projects can keep those definitions in their own repositories while using Arena as the execution layer.[2][5]

The official ecosystem lists Lightwheel RoboFinals, ports of [RoboCasa](/wiki/robocasa) and [LIBERO](/wiki/libero) tasks, RoboTwin 2.0 integration, and the LeRobot Environment Hub. Results from these projects belong to the named benchmark and configuration. Using Arena does not make their tasks or scores interchangeable with the original implementations.[2][4][10]

Arena exposes two main evaluation paths.[5]

| Runner | Evaluation unit | Parallel behavior |
| --- | --- | --- |
| Policy runner | One environment configuration and one policy | One GPU, or multiple GPUs with one Isaac Sim process per GPU |
| Experiment runner | A JSON-defined sequence of environment-policy jobs | Jobs run sequentially in one persistent process; no distributed mode |

The policy runner can stop after a selected number of steps or completed episodes. Environments that support object sets can assign different objects across parallel simulations. The experiment runner tears down each environment between jobs, continues after a failed job, and aggregates the surviving metrics.[5]

Metrics belong to task definitions. Built-in examples include success rate, object-moved rate, and revolute-joint-moved rate, plus hooks for custom measures. Success rate is the number of successful recorded episodes divided by the total recorded episodes. The recorder can collect measurements before resets, after steps, on events, or continuously, with episode data organized in HDF5. Batch metrics can be saved as JSON.[6]

The command-line interface has a default seed of 42 and a separate placement seed. The implementation seeds Python, NumPy, PyTorch, CUDA, and the environment; distributed processes add their local rank to the base seed. These controls help repeat a run, but they do not replace a full reproducibility record. Comparable results still require the repository commit and submodule revisions, container, assets, policy checkpoint, task thresholds, episode count, camera and controller settings, and hardware.[2][5][6]

## Performance evidence

NVIDIA and Lightwheel reported one evaluation-throughput comparison in the launch blog. They ran the [Isaac GR00T N1.5](/wiki/groot_n1_5) policy on ten RoboCasa tasks, with 4,096 homogeneous environment variations per task across eight 6000D GPUs. Parallel Arena evaluation took 0.76 hours, compared with 34.9 hours for sequential Arena evaluation, a reported speedup of about 40 times.[1]

The result is specific to that setup. It measures evaluation time rather than policy accuracy, simulator fidelity, or physical-robot reliability. The blog does not publish repeated-run variance, confidence intervals, every seed, or enough raw data to reproduce the timing from the article alone. Camera-heavy [vision-language-action models](/wiki/vision_language_action_model), remote inference, larger scenes, and different hardware can shift the bottleneck away from simulation.[1][5]

There was no standalone peer-reviewed Isaac Lab-Arena paper at the time of research. The repository supplies a software citation attributed to the NVIDIA Isaac Lab-Arena Contributors. The underlying Isaac Lab architecture is described in a November 2025 arXiv paper by Mittal and collaborators.[2][12]

RoboLab provides related academic context but remains a separate research benchmark. Its April 2026 paper defines RoboLab-120, with 120 tasks organized by visual, procedural, and relational competencies at three difficulty levels. NVIDIA says RoboLab research informs Arena, but RoboLab results are not Arena scores and do not validate every Arena environment or simulator configuration.[13]

## Installation and hardware

The supported `v0.2.x` route is source installation inside a Docker container. Users clone the repository, initialize its Git submodules, and launch `./docker/run_docker.sh`. The prerequisites are Ubuntu 22.04 or later, an NVIDIA GPU, Docker, NVIDIA Container Toolkit, and Git. Pip packaging is listed as future work.[2][8]

Version compatibility matters. The current main and `release/0.2.0` documentation target Isaac Lab 3.0, Isaac Sim 6.0, and Python 3.12 or later. Earlier Arena branches target Isaac Lab 2.3, Isaac Sim 5.x, and Python 3.10 or later. Mixing documentation, assets, submodules, and policy packages from different branches can produce an environment that is not equivalent to the published example.[2][8]

Arena inherits its baseline hardware requirements from Isaac Sim. For x86-64 Isaac Sim 6.0, NVIDIA lists 32 GB RAM, a 50 GB SSD, an RTX 4080, and 16 GB VRAM as the minimum. Its good configuration raises memory and storage to 64 GB RAM and a 500 GB SSD, while the ideal configuration lists an RTX PRO 6000 Blackwell with 48 GB VRAM and a 1 TB NVMe SSD. Sensor-heavy scenes and Isaac Lab training can need more memory.[9]

The Arena Docker path is Linux-only even though Isaac Sim itself also supports a Windows workstation install. Isaac Sim 6.0 says GPUs without RT cores, including A100 and H100, are not supported as simulator GPUs. A remote policy server may use separate hardware according to that model's requirements.[5][9]

## Reproducibility, safety, and limitations

Versioned branches, Docker scripts, submodules, seeds, public tests, example job files, HDF5 recordings, and JSON metrics provide useful reproducibility controls. The repository nevertheless warns that testing is limited and that `main` may contain untested work. Release notes also describe performance hardening, pip installation, easier sensitivity analysis, greater variation across parallel environments, and agentic task generation as incomplete or evolving.[2][4]

Simulation results depend on collision geometry, mass, friction, sensors, rendering, control frequency, actuator limits, and asset accuracy. A task author also controls the success predicate. Two evaluations with the same task name can therefore be incomparable if their thresholds, assets, controller, or simulator version differ. Ports of community benchmarks may change physics and task details even when they preserve the original benchmark's labels.[4][6][13]

Arena is not a certified robot safety system, real-time fail-safe controller, or substitute for testing on physical hardware. Success in simulation does not cover unmodeled contacts, sensor failures, communication delays, unexpected people or objects, or other deployment hazards unless a benchmark explicitly represents them. The repository provides an NVIDIA PSIRT route for software vulnerabilities, but that security process is distinct from physical robot safety.[2]

EnvHub adds another software-security boundary: loading an environment can execute third-party Python with `trust_remote_code=True`. Hugging Face recommends using trusted repositories and pinning a commit for security and reproducibility.[11] Together with the project's alpha status and no-production warning, these limits make Arena most appropriate for research, benchmark development, and pre-deployment analysis rather than as evidence that a policy is ready for unsupervised physical operation.

## References

1. Subramanian, Sangeeta; Vadrevu, Kalyan Meher; Omotuyi, Oyindamola; et al. [Simplify Generalist Robot Policy Evaluation in Simulation with NVIDIA Isaac Lab-Arena](https://developer.nvidia.com/blog/simplify-generalist-robot-policy-evaluation-in-simulation-with-nvidia-isaac-lab-arena/). NVIDIA Technical Blog, January 5, 2026, updated February 3, 2026.
2. NVIDIA Isaac Lab-Arena Contributors. [Isaac Lab-Arena repository](https://github.com/isaac-sim/IsaacLab-Arena). GitHub, 2025-2026.
3. NVIDIA Isaac Lab-Arena Contributors. [Welcome to Isaac Lab Arena](https://isaac-sim.github.io/IsaacLab-Arena/main/index.html). Isaac Lab-Arena documentation, 2026.
4. NVIDIA Isaac Lab-Arena Contributors. [Isaac Lab-Arena release notes](https://isaac-sim.github.io/IsaacLab-Arena/main/pages/references/release_notes.html). Isaac Lab-Arena documentation, 2026.
5. NVIDIA Isaac Lab-Arena Contributors. [Evaluation Types](https://isaac-sim.github.io/IsaacLab-Arena/main/pages/concepts/policy/concept_evaluation_types.html). Isaac Lab-Arena documentation, 2026.
6. NVIDIA Isaac Lab-Arena Contributors. [Metrics Design](https://isaac-sim.github.io/IsaacLab-Arena/release/0.1.1/pages/concepts/concept_metrics_design.html). Isaac Lab-Arena documentation, 2026.
7. NVIDIA Isaac Lab-Arena Contributors. [Example Environments](https://isaac-sim.github.io/IsaacLab-Arena/main/pages/example_workflows/example_environments.html). Isaac Lab-Arena documentation, 2026.
8. NVIDIA Isaac Lab-Arena Contributors. [Installation](https://isaac-sim.github.io/IsaacLab-Arena/release/0.2.1/pages/quickstart/installation.html). Isaac Lab-Arena documentation, 2026.
9. NVIDIA. [Isaac Sim Requirements](https://docs.isaacsim.omniverse.nvidia.com/6.0.0/installation/requirements.html). Isaac Sim documentation, 2026.
10. Hugging Face. [NVIDIA IsaacLab Arena and LeRobot](https://huggingface.co/docs/lerobot/en/envhub_isaaclab_arena). LeRobot documentation, 2026.
11. Hugging Face. [Loading Environments from the Hub](https://huggingface.co/docs/lerobot/envhub). LeRobot documentation, 2026.
12. Mittal, Mayank; Roth, Pascal; Tigue, James; et al. [Isaac Lab: A GPU-Accelerated Simulation Framework for Multi-Modal Robot Learning](https://arxiv.org/abs/2511.04831). arXiv:2511.04831, November 2025.
13. Yang, Xuning; Dagli, Rishit; Zook, Alex; et al. [RoboLab: A High-Fidelity Simulation Benchmark for Analysis of Task Generalist Policies](https://arxiv.org/abs/2604.09860). arXiv:2604.09860, April 2026.