Isaac Lab-Arena

Isaac Lab Arena supports end-to-end imitation learning workflows, which include:

• Teleoperation data collection
• Data generation
• Policy post-training
• Closed-loop evaluation

Available task examples include:

• G1 Loco-Manipulation Box Pick and Place Task
• G1 Static Apple-to-Plate Task
• GR1 Open Microwave Door Task
• GR1 Sequential Pick & Place and Close Door Task

IsaacLab Arena provides several pre-configured example environments for testing and demonstration. The current available environments are:

• KitchenPickAndPlaceEnvironment: A task involving picking and placing an object into a drawer within a kitchen scene.
• GalileoPickAndPlaceEnvironment: A task involving picking and placing an object into a drawer within a Galileo scene.
• Gr1OpenMicrowaveEnvironment: A task requiring the robot to open a microwave door.

To find the specific CLI arguments supported by a particular environment, you must check its corresponding environment file.

The galileo_g1_locomanip_pick_and_place task involves a Unitree G1 humanoid robot (29 DOF) navigating a lab environment to pick up a brown box from a shelf and place it into a blue bin. This task requires full-body coordination, including locomotion, squatting, and bimanual manipulation.

Key Specifications:

• Embodiment: Unitree G1 (29 DOF humanoid with Whole Body Controller)
• Skills: Squat, Turn, Walk, Pick, Place
• Scene: Galileo Lab Environment
• Manipulated Object: Brown box (rigid body)
• Policy: GR00T N1.6 (vision-language-action foundation model)
• Physics: PhysX (200Hz @ 4 decimation)
• Closed-loop: Yes (50Hz control)
• Metrics: Success rate
• Interop: Isaac Lab Mimic
• Tags: Room-scale loco-manipulation

The galileo_g1_static_pick_and_place task is a tabletop manipulation workflow for the Unitree G1 humanoid robot. The robot performs a pick-and-place operation (moving an apple to a plate) while standing in place using a Whole Body Controller (WBC) for balance, without locomotion or squatting.

Key Specifications:

• Embodiment: Unitree G1 (29 DOF) with WBC for balance.
• Action Layout: 23-D action layout driven by PinkIK.
• Policy: GR00T N1.7 (vision-language-action foundation model).
• Data Format: LeRobot (converted from teleop HDF5).
• Physics: PhysX (200Hz @ 4 decimation).
• Control: Closed-loop at 50Hz.
• Environment: Galileo Lab (single shelf setup).

Isaac Lab Arena provides end-to-end reinforcement learning workflows that cover environment setup, policy training, and closed-loop evaluation.

Available workflow examples include:

• Franka Lift Object Task: Uses a Franka Panda robot, PhysX physics, and joint-position control.
• Dexsuite Kuka Allegro Lift Task (Newton): Uses a Kuka robot with an Allegro hand, utilizing the Newton physics engine for dexterous manipulation tasks.

The RoboLab Task Catalog provides a collection of robotics simulation tasks, each defined by a specific task configuration (YAML), a scene configuration (YAML), and a natural language prompt. Tasks are categorized by the scene they inhabit and include metadata such as object counts and subtask counts.

Common task types include:

• Object Manipulation: e.g., BowlInBinTask, PickDrillTask, ReorientRedMugTask.
• Organization/Sorting: e.g., RedItemsInBinTask, ToolOrganizationTask, RecycleCartonTask.
• Stacking/Packing: e.g., StackWhiteMugsTask, FoodPacking2BoxesTask.
• Counting/Quantity-based: e.g., BananasInBinThreeTotalTask, BananasInBinOneMoreTask.

Each task is associated with a specific scene (e.g., tools_container.yaml, shelf_mugs_jug_bowl.yaml) and a prompt that describes the goal for the robot (e.g., "droid put the bowl in the grey bin").

The lift_object task is a reinforcement learning example where a Franka Panda robot learns to grasp and lift objects (default: dex_cube) to target positions. The task uses a command-based goal specification where the agent learns to reach sampled target poses.

Task Specifications:

• Embodiment: Franka Panda (9 DOF arm + 2 DOF gripper)
• Skills: Reach, Grasp, Lift
• Training Method: Reinforcement Learning (on-policy PPO via RSL-RL)
• Physics: PhysX (50Hz @ 2 decimation)
• Command Space: Target position [x, y, z] relative to the object's initial pose
• Closed-loop: Yes (50Hz control)
• Estimated Training Time: ~6 hours (12,000 iterations on 512 environments using an A6000 GPU)

A Scene is a collection of assets that defines the physical environment for a simulation. It is designed to be independent of the robot (embodiment) and the task, allowing you to swap backgrounds or objects without modifying the underlying task logic.

To create a scene, you load assets from the asset_registry by name and pass them as a list to the Scene constructor. You can then pass this Scene instance to an IsaacLabArenaEnvironment.

background = asset_registry.get_asset_by_name("kitchen")()
pick_object = asset_registry.get_asset_by_name("cracker_box")()

pick_object.set_initial_pose(Pose(position_xyz=(0.4, 0.0, 0.1)))

scene = Scene(assets=[background, pick_object])

environment = IsaacLabArenaEnvironment(
    name="my_scene",
    scene=scene,
)

Isaac Lab-Arena is an open-source extension for NVIDIA Isaac Lab designed for simplified task curation and large-scale robotic policy evaluation. It uses a composable architecture that allows developers to assemble environments at runtime from three independent primitives, avoiding the need to maintain massive, redundant configuration files for every combination of robot, object, and scene.

Core Primitives

ArenaEnvBuilder takes these primitives and composes them into a standard ManagerBasedRLEnvCfg that is natively compatible with Isaac Lab.

A policy in Arena serves as a standardized interface between a machine learning model and the evaluation pipeline (such as the single-job runner or the Experiment Runner). Instead of writing ad-hoc inference loops, you implement the get_action(env, obs) method. This consistent contract allows policies to be used seamlessly across different runners without modification.

Key lifecycle interaction:

1. The runner provides the environment (env) and the current observation (obs).
2. The policy processes these inputs and returns an action tensor via get_action.

policy = ZeroActionPolicy(config=ZeroActionPolicyCfg())
obs, _ = env.reset()
action = policy.get_action(env, obs)

An embodiment represents the robot within Isaac Lab-Arena, encompassing its physical description, control interface, sensors, and cameras.

Embodiments are designed to be independent of the scene and the task. This decoupling allows you to swap robots (e.g., switching from a Franka to a G1) without modifying the task or scene definitions. When creating an IsaacLabArenaEnvironment, you pass the embodiment instance as a parameter alongside the scene and task.

embodiment = asset_registry.get_asset_by_name("franka_ik")(enable_cameras=True)

environment = IsaacLabArenaEnvironment(
    name="kitchen_pick_and_place",
    embodiment=embodiment,
    scene=scene,
    task=task,
)