v3.0.0

Isaac Lab 3.0

Isaac Lab 3.0 is now generally available.

v3.0.0 is the official Isaac Lab 3.0 release and the recommended baseline for new projects and migrations from Isaac Lab 2.x.

Isaac Lab 3.0 establishes the foundation for the next generation of robot learning in Isaac Lab: one task API across multiple physics, rendering, and visualization backends; kit-less execution with Newton and OV library backends; Warp-native data paths; and unified workflows from installation through training, evaluation, and deployment.

• Newton is a Warp-native physics backend with multiple solver paths, including MuJoCo-Warp, VBD, and MPM. It lets Isaac Lab support rigid bodies, deformables, and particles without tying tasks to one physics engine.
• OV Libraries provide OVPhysX for PhysX and OVRTX for RTX rendering as standalone libraries.
• Isaac Sim remains the complete path when a workflow needs the full PhysX/RTX stack, ROS bridge, XR, livestreaming, or Kit tooling, but now fully optional.

MicroDuck rendering

VBD cable insertion

MPM liquid pouring

One task API; install and run only the capabilities you need.

This release targets Isaac Sim 6.2, Python 3.12, PyTorch 2.11 with CUDA 13.0, NVIDIA Warp 1.17, Newton 1.6.1, and RSL-RL 5.5.1.

Try Isaac Lab 3.0

Install uv, clone the official release, and launch a Newton workflow:

git clone --branch v3.0.0 --depth 1 https://github.com/isaac-sim/IsaacLab.git
cd IsaacLab

uv run isaaclab train \
    --rl_library rsl_rl \
    --task Isaac-Cartpole \
    --viz newton_gl \
    physics=newton_mjwarp

For standalone PhysX and RTX rendering, install the OV libraries:

uv run --extra ov isaaclab train \
    --rl_library rsl_rl \
    --task Isaac-Cartpole-Camera \
    --viz newton_gl \
    physics=ovphysx \
    renderer=ovrtx \
    presets=rgb

For the complete Isaac Sim experience, including Isaac Sim PhysX, Isaac Sim RTX, ROS bridge, XR, livestreaming, and Kit tooling:

uv run --extra isaacsim isaaclab train \
    --rl_library rsl_rl \
    --task Isaac-Cartpole \
    --viz kit \
    physics=isaacsim_physx

See the installation guide and quickstart for complete setup and platform-specific instructions.

Interactive browser demos

Explore Newton physics and pretrained policies directly in your browser—no installation required. Click a demo below to tune parameters, steer a robot, or inspect a policy in action.

MPM material response

Domino cascade

G1 velocity control

Franka drawer opening

Explore all 17 interactive demos →

The gallery includes VBD, rigid-body, and MPM tuning; pretrained locomotion and manipulation policies; and scripted contact scenes. Each demo runs a Newton simulation locally on your CPU through WebAssembly, with camera controls, pause, and reset.

Highlights

isaaclab3_backends_v10.mp4

One environment, multiple backends

Isaac Lab 3.0 introduces a factory-based, multi-backend architecture. Backend-neutral assets, sensors, scenes, and environments dispatch to the selected implementation, allowing supported tasks to change physics, rendering, or visualization without rewriting task logic.

Common selectors include:

physics=newton_mjwarp
physics=ovphysx
physics=isaacsim_physx

renderer=newton_renderer
renderer=ovrtx
renderer=isaacsim_rtx

--viz newton_gl
--viz newton_rtx
--viz viser
--viz rerun
--viz kit

Physics, rendering, and visualization are independent choices. A task can use Newton physics with the Newton Warp renderer while being inspected through Newton GL, Rerun, Viser, or Kit.

Supported combinations remain task-specific. Inspect them with:

uv run isaaclab list_envs --show_presets
uv run isaaclab train --task <TASK_NAME> --help

See Backends and Presets.

Kit-less robot learning

newton-single-env-corrected.1.mp4

Most Isaac Lab workflows can run without installing or launching Isaac Sim:

• Newton physics with MuJoCo-Warp, VBD, MPM, coupled solvers, and the experimental Kamino solver.
• Newton Warp camera rendering.
• Lightweight Newton GL visualization and experimental Newton RTX visualization.
• Browser-based visualization through Viser and Rerun.
• OV PhysX and OV RTX through optional runtime extras.

Install the full Isaac Sim stack only when a workflow requires capabilities such as Isaac Sim PhysX or RTX, ROS bridge integration, XR teleoperation, livestreaming, or Kit tooling.

Warp-native simulation data

Asset and sensor data use ProxyArray, providing explicit, zero-copy access to both Warp and PyTorch:

joint_pos_torch = robot.data.joint_pos.torch
joint_pos_warp = robot.data.joint_pos.warp

Structured Warp data, fused GPU kernels, lazy buffers, cached views, and CUDA graph support reduce Python and tensor-conversion overhead while preserving PyTorch interoperability.

Unified training and playback commands

The isaaclab command provides one workflow across supported RL libraries and backends:

uv run isaaclab train --rl_library rsl_rl --task Isaac-Cartpole
uv run isaaclab play --rl_library rsl_rl --task Isaac-Cartpole --checkpoint latest

Isaac Lab 3.0 integrates:

• RSL-RL
• RL-Games
• skrl with PyTorch or JAX
• Stable-Baselines3
• RLinf
• TorchRL

Checkpoint selection is standardized around --checkpoint, including latest, best, pretrained, and explicit paths.

See Reinforcement Learning.

Improved simulation functionalities

isaaclab3_soft_environments_v1.1.mp4

Isaac Lab 3.0 adds and expands:

• Backend-neutral sensors for frame-transformer, IMU/PVA, joint-wrench, and ray-caster workflows.
• Explicit total, normal, friction, filtered, and aggregate contact-force contracts.
• Warp-native ray casting.
• Surface and volume deformables with composable schema fragments.
• Newton VBD and rigid/deformable/MPM coupling.
• Backend-neutral visual materials and material randomization.
• Modular combinations between physics, renderer, and visualizers.

From simulation to deployment

Isaac Lab 3.0 strengthens the complete robot-learning workflow with:

• Isaac Capture integration through isaaclab_teleop, including pipeline-based retargeting, CloudXR, and MCAP record/replay.
• LEAPP policy export and deployment, including camera and deformable inputs.
• Bidirectional PhysX↔Newton policy-transfer guidance and validated examples.

See Transfer Policies Between PhysX and Newton.

A better developer experience

Isaac Lab 3.0 simplifies common development workflows:

• uv run creates and synchronizes the project environment automatically.
• Isaac Lab can be installed as a Python dependency in downstream projects.
• The installed CLI discovers downstream task packages through entry points.
• The environment browser exposes tasks, presets, supported RL libraries, and launch commands.
• Packaged examples are available through isaaclab demo and isaaclab example.
• Repository-owned agent skills guide installation, migration, environment creation, backend selection, training, debugging, asset preparation, and policy transfer.

Changes since Early Access

Updated dependencies

The GA release updates the core dependency versions from EA:

• Isaac Sim 6.1 → 6.2
• NVIDIA Warp 1.16 → 1.17
• Newton 1.5.2 → 1.6.1
• RSL-RL 5.4.1 → 5.5.1
• Kit-less OpenUSD 25.05 → 26.08 through usd-exchange 3.0.1
• OVRTX → 0.5.1
• OVStage → 0.2.1
• OVPhysX → 0.6.4

Runtime and platform stabilization

Since EA, Isaac Lab has received broad stabilization across:

• Isaac Sim 6.2 installation, assets, importers, containers, and China-region storage.
• Windows wheel installation and Newton CUDA graph initialization.
• Linux aarch64 and DGX Spark launch behavior.
• RTX multi-GPU training with PyTorch 2.11 and CUDA 13.
• Ctrl+C and shutdown handling across Kit and standalone visualizers.
• Monitor-free and virtual-display Newton visualization.
• OVRTX buffer lifetime, stream ordering, cloning, and multi-camera rendering.
• Newton camera poses, HDR backgrounds, distortion handling, and RTX markers.
• PhysX, OVPhysX, and Newton contact-force behavior.

Learning and environment improvements

GA adds and improves:

• TorchRL integration and PPO examples.
• A dedicated skrl-jax extra.
• RSL-RL mixed-precision and torch.compile options.
• Automatic Weights & Biases checkpoint resolution.
• Video capture for zero and random agents.
• Time-ordered observation histories and configurable observation delay.
• Improved task and RL-library compatibility reporting.
• Camera inputs and frame history for LEAPP.
• Additional deformable, particle, cable, and coupled-solver examples.
• Interactive demo and example selection in Newton GL.

Upgrading from Isaac Lab 3.0 Early Access to 3.0 GA

Application launching

AppLauncher now provides only limited compatibility. New and migrated scripts should use launch_simulation:

from isaaclab.app import launch_simulation

env_cfg = MyEnvCfg()

with launch_simulation(env_cfg, args_cli):
    env = MyEnv(env_cfg)
    env.reset()

    while env.sim.is_running():
        env.step(actions)

The following removed or changed APIs require attention in custom scripts:

• AppLauncher.is_available
• AppLauncher.has_gui
• AppLauncher.has_window
• AppLauncher.device
• SimulationContext.is_headless_or_exist_active_visualizer
• SettingsManager.instance()
• SettingsManager.set_bool, set_int, set_float, and set_string
• isaaclab.app.make_physics_cfg
• isaaclab.sim.utils.update_stage
• isaaclab.sim.utils.show_stage_in_viewport
• The hidden --cpu argument; use --device cpu

Use SimulationContext.is_running(), get_settings_manager(), SettingsManager.set(), and configuration-driven backend selection instead.

Programmatic task configuration

The old Hydra decorator and override helpers were removed.

Replace hydra_task_config, parse_overrides, and apply_overrides with:

from isaaclab_tasks.utils import resolve_task_config

env_cfg, agent_cfg = resolve_task_config(
    task_name,
    "rsl_rl_cfg_entry_point",
    play_mode=False,
    overrides=[
        "physics=newton_mjwarp",
        "env.scene.num_envs=128",
    ],
)

Pass the resolved environment and agent configurations directly to the environment or training entrypoint.

Direct environment configuration

Maintained Direct tasks now declare assets and sensors under cfg.scene.

Update paths such as:

# EA
cfg.robot_cfg
cfg.tiled_camera

to:

# GA
cfg.scene.robot
cfg.scene.tiled_camera

Custom _setup_scene() implementations copied from maintained tasks should be reviewed against the GA implementation. Reorientation environments using asymmetric observations must explicitly declare their joint-wrench sensor under cfg.scene.

Physics schema fragments

Maintained task and asset configurations now use composable schema fragments rather than combined property configurations.

Legacy combined configurations remain available as deprecated aliases in 3.0, but code that mutates the structure of shipped configurations may break because spawner slots now commonly contain fragment lists.

Replace:

import isaaclab.sim as sim_utils

rigid_props = sim_utils.RigidBodyPropertiesCfg(
    kinematic_enabled=False,
    linear_damping=0.1,
)

with:

from isaaclab.sim.schemas import UsdPhysicsRigidBodyCfg
from isaaclab_physx.sim.schemas import PhysxRigidBodyCfg

rigid_props = [
    UsdPhysicsRigidBodyCfg(kinematic_enabled=False),
    PhysxRigidBodyCfg(linear_damping=0.1),
]

Users modifying shipped assets must select the fragment that owns the field rather than assuming the slot is one object.

Three non-USD settings moved onto the spawner configuration:

• fix_root_link
• ensure_drives_exist
• mesh_collision_props

The legacy define_* and modify_* schema writers are deprecated in favor of expression-targeted apply_* writers.

Manager term entity selections

Resolved SceneEntityCfg selections may now be device tensors or slices instead of host lists.

Custom observation, reward, event, curriculum, and termination terms should preserve the selected dimension:

# Fragile with a device-resident selection
value = data[:, cfg.body_ids[0]]

# GA-compatible
value = data[:, cfg.body_ids][:, 0]

Replace patterns such as:

torch.tensor(cfg.body_ids)
isinstance(cfg.body_ids, list)

with direct use of the resolved tensor or an explicit slice check.

Class-based terms may still see host selections during __init__, but term calls receive finalized selections.

Environment reset selectors

ManagerBasedEnv.reset() accepts env_ids as its first positional argument. reset_to(state, env_ids=...) accepts the selector after state. Pass Gymnasium seed and options to reset() by keyword:

env.reset(env_ids)
env.reset(seed=42)

Custom reset callbacks must accept both slices and device indices:

def reset(self, env_ids: slice | torch.Tensor):
    selected_state = self.state[env_ids]
    batch_size = selected_state.shape[0]

Avoid assuming the selector supports:

len(env_ids)
env_ids.tolist()

When only the selected batch size is needed, derive it from selected data or from the slice bounds.

Observation noise callbacks

The observation manager no longer creates a defensive copy before calling configured noise functions. In-place noise can now modify a shared source tensor and corrupt other observations.

Replace:

def add_bias(data, bias):
    return data.add_(bias)

with:

def add_bias(data, bias):
    return data + bias

If in-place operations are required, clone first:

return data.clone().add_(bias)

Users with custom NoiseCfg or NoiseModelCfg implementations should audit every callback.

Logging values

Several manager and task metrics now report zero-dimensional device tensors instead of Python floats to avoid GPU synchronization.

Code that formats, serializes, or compares these values as Python numbers should convert explicitly:

success_rate = float(extras["log"]["Metrics/success_rate"])
# or
success_rate = extras["log"]["Metrics/success_rate"].item()

Camera observations

The generic isaaclab.envs.mdp.image term was removed. Use modality-specific terms:

• image_rgb
• image_depth
• image_normals
• image_segmentation

Also:

• Replace permute=True with channel_first=True.
• Remove the old clone option.
• Configure frame_stack on the image term.
• Expect image_rgb to drop the alpha channel.

For example:

policy_image = ObsTerm(
    func=mdp.image_rgb,
    params={
        "sensor_cfg": SceneEntityCfg("camera"),
        "channel_first": True,
        "frame_stack": 4,
    },
)

Vision-policy users should validate observation shapes, channel order, normalization, and frame history before loading an EA checkpoint.

Visualizer configuration

Renderer selection now takes a configuration object rather than a nickname:

# EA
cfg.streaming_cam_renderer = "ovrtx"

# GA
from isaaclab_ov.renderers import OVRTXRendererCfg

cfg.streaming_cam_renderer_cfg = OVRTXRendererCfg()

The tiled-camera fields move to the unified streaming-camera API:

EA field	GA field
tiled_cam_view	streaming_view
tiled_cam_num	streaming_envs
tiled_cam_prim_path	streaming_sensor_prim_path
tiled_cam_eye	streaming_cam_eye
tiled_cam_renderer	streaming_cam_renderer_cfg

NewtonVisualizerCfg is replaced by NewtonGLVisualizerCfg or NewtonRTXVisualizerCfg.

The CLI alias --viz newton remains deprecated; use:

--viz newton_gl

Code inspecting parsed visualizer arguments must now distinguish:

args_cli.visualizer is None  # --viz was omitted
args_cli.visualizer == []    # --viz none was passed

Video recording

gym.wrappers.RecordVideo is no longer the supported recording path. Configure recorders through the environment:

from isaaclab.envs.utils.video_recorder_cfg import VideoRecorderCfg

env_cfg.video_recorders = [
    VideoRecorderCfg(
        source="visualizer",
        output_dir="videos/",
        video_length=200,
    )
]

Viewport position should be configured through SimulationCfg.default_visualizer_cfg, not through VideoRecorderCfg.

Stable-Baselines3 action bounds

Sb3VecEnvWrapper now exposes normalized [-1, 1] bounds for otherwise unbounded continuous action spaces instead of the EA fallback of [-100, 100].

To preserve the EA action space while loading an existing checkpoint:

Sb3VecEnvWrapper(env, action_bounds=(-100, 100))

New training should generally use the GA default bounds.

TorchScript loading

load_torchscript_model now raises RuntimeError when loading fails instead of returning None.

Replace:

model = load_torchscript_model(path)
if model is None:
    ...

with:

try:
    model = load_torchscript_model(path)
except RuntimeError:
    ...

Migrating from Isaac Lab 2.x

Isaac Lab 3.0 is a major release. Downstream 2.x projects should review the complete Isaac Lab 2.x → 3.0 migration guide.

The most important migration areas are summarized below.

Installation

Start from a fresh Python 3.12 environment instead of upgrading a 2.x environment in place.

Use:

uv run isaaclab ...

Add optional runtimes before isaaclab:

uv run --extra isaacsim isaaclab ...
uv run --extra ov isaaclab ...

Backend configuration

Keep core asset imports backend-neutral and move backend-owned configuration into isaaclab_physx, isaaclab_newton, or isaaclab_ov.

Use PresetCfg and typed selectors:

physics=newton_mjwarp
physics=isaacsim_physx
renderer=newton_renderer
renderer=ovrtx
presets=rgb

Quaternion order

All Isaac Lab quaternion APIs, configuration values, asset data, sensor data, and math utilities now use:

Isaac Lab 2.x: (w, x, y, z)
Isaac Lab 3.0: (x, y, z, w)

The identity quaternion changes from:

(1, 0, 0, 0)

to:

(0, 0, 0, 1)

Review hard-coded rotations, reset states, goals, controller targets, observations, and custom math.

ProxyArray data access

Asset and sensor .data.* properties return ProxyArray.

Use .torch or .warp explicitly:

root_pos = robot.data.root_pos_w.torch
joint_pos = robot.data.joint_pos.torch
joint_pos_warp = robot.data.joint_pos.warp

Replace patterns such as:

robot.data.root_pos_w.clone()
torch.zeros_like(robot.data.joint_pos)

with:

robot.data.root_pos_w.torch.clone()
torch.zeros_like(robot.data.joint_pos.torch)

Indexed and masked writes

Migrate ambiguous asset writes to explicit index or mask variants:

robot.write_root_pose_to_sim_index(
    root_pose=partial_pose,
    env_ids=env_ids,
)

robot.write_root_pose_to_sim_mask(
    root_pose=full_pose,
    env_mask=env_mask,
)

Index variants accept partial data for selected environments. Mask variants accept full data for all environments plus a Boolean mask.

Actuator ownership

Actuator commands and telemetry now live under robot.actuators:

robot.actuators.target_command.set_effort_index(
    value=efforts,
    joint_ids=joint_ids,
)

applied_effort = robot.actuators.applied_effort.torch

Actuator setters are keyword-only.

Canonical limit names distinguish rated actuator limits from solver-enforced joint limits:

• effort_limit → actuator_effort_limit
• effort_limit_sim → joint_effort_limit
• velocity_limit_sim → joint_velocity_limit

Explicit actuator groups now preserve authored solver effort limits instead of automatically raising them. Review clipping behavior for policies that relied only on actuator-model limits.

Sensor contracts

• The 2.x full-state IMU is now PVA.
• The new IMU reports angular velocity and linear acceleration.
• Use JointWrenchSensor instead of ArticulationData.body_incoming_joint_wrench_b.
• Use FrameTransformer instead of contact-sensor pose properties.
• Prefer explicit total, normal, friction, aggregate, and filtered contact-force properties.

Asset and view naming

• XformPrimView → FrameView
• root_physx_view → backend-specific root_view
• RigidObjectCollection.object_* → body_*
• The former soft-body model is replaced by explicit surface and volume deformable APIs.

Several old names remain as deprecated aliases, but new code should use the GA names.

Training and checkpoints

Backend-local and RL-library-local train.py and play.py entrypoints were removed.

Use:

uv run isaaclab train --rl_library rsl_rl --task Isaac-Cartpole
uv run isaaclab play --rl_library rsl_rl --task Isaac-Cartpole --checkpoint latest

Resume and playback workflows consistently use --checkpoint.

Visualization and recording

• Use --viz to select visualizers.
• --headless no longer disables configured visualizers.
• Use --viz none to disable all visualizers.
• Move viewport configuration from env_cfg.viewer to SimulationCfg.
• Use VideoRecorderCfg instead of gym.wrappers.RecordVideo.

Direct Isaac Sim imports

Isaac Lab no longer preloads extensions only to make their Python modules importable.

If downstream code must import an Isaac Sim extension directly, enable it after Kit starts:

from isaaclab.sim.utils import enable_extension

enable_extension("isaacsim.core.experimental.prims")

Prefer an Isaac Lab API where one is available.

Do not import enable_extension from isaacsim.core.experimental.utils.app, because that module may not be importable until its extension is already enabled.

URDF and MJCF importers

The rewritten importers change output layout and remove or deprecate several options:

• URDF output filenames are determined automatically.
• make_instanceable is no longer supported; output is instanceable by default.
• MJCF fixedness, density, inertia, and site import are inferred from the model.
• MJCF-imported USDs use nested rigid bodies.
• Generated assets support multiple physics backends.

Review custom conversion scripts and code that traverses generated USD hierarchies.

Teleoperation

The native isaaclab.devices.openxr stack is deprecated.

Use Isaac Capture through:

• isaaclab_teleop
• IsaacTeleopDevice
• IsaacTeleopCfg
• Pipeline-based retargeters

Get help

The comprehensive Isaac Lab 2.x → 3.0 migration guide covers installation, package moves, API mappings, quaternions, ProxyArray, actuators, sensors, visualizers, recording, RL commands, importers, benchmarks, teleoperation, and deformables.

Isaac Lab also ships repository-owned agent skills that route coding agents through current documentation, source APIs, examples, and focused validation commands.

For example, ask your coding agent to:

• “Use isaaclab-migrating-2x-to-3x to migrate this project.”
• “Use isaaclab-selecting-backends to determine which backends this task supports.”
• “Use isaaclab-preparing-assets-for-newton to validate this robot for MJWarp.”
• “Use isaaclab-transferring-policies-sim-to-sim to evaluate this checkpoint in PhysX and Newton.”
• “Use isaaclab-setup-troubleshooting to diagnose this installation.”
• “Use isaaclab-migrating-from-isaac-gym to migrate a project from Isaac Gym.”

Report reproducible bugs through GitHub Issues, ask questions in GitHub Discussions, and join the NVIDIA Omniverse Discord.

Thank you to every contributor and Early Access user who tested migrations, reported regressions, and helped bring Isaac Lab 3.0 to General Availability. We are excited to see what you build with the official release.

Full changes since Early Access