v3.0.0-EA

Isaac Lab 3.0 Early Access

Isaac Lab 3.0 Early Access is ready.

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; Warp-native data paths; and unified workflows from installation through training, evaluation, and deployment.

This release is built for Isaac Sim 6.1, Python 3.12, PyTorch 2.11, NVIDIA Warp 1.16, and Newton 1.5.2.

Note

Early Access status

The architecture and feature set for Isaac Lab 3.0 are ready for users to build on. From Early Access to General Availability, the release/3.0.0 branch will focus only on bug fixes, stability, compatibility, and documentation improvements. General Availability is targeted toward the end of October 2026.

We encourage you to start migrating, training, and testing now—and to tell us what you find.

Try Isaac Lab 3.0 today

Install uv, clone the Early Access branch, and launch a kit-less Newton workflow:

git clone --branch release/3.0.0 https://github.com/isaac-sim/IsaacLab.git
cd IsaacLab

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

For a fully kit-less PhysX and RTX rendering workflow, use OVPhysX and OVRTX backends. The ov extra installs both optional runtimes; Isaac Sim is not installed or launched:

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

For the full Isaac Sim experience with Isaac Sim PhysX, Isaac Sim RTX rendering, Isaac Sim ROS bridge, and other Kit integrations:

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

See the Isaac Lab 3.0 installation guide and quickstart for the complete setup options.

Highlights

One environment, multiple backends

Isaac Lab 3.0 introduces a factory-based, multi-backend architecture. Common asset, sensor, and scene APIs dispatch to the selected implementation, allowing supported tasks to change physics, rendering, or visualization without rewriting the environment.

Use tested configuration selectors at launch:

physics=isaacsim_physx
physics=ovphysx
physics=newton_mjwarp

renderer=isaacsim_rtx
renderer=ovrtx
renderer=newton_renderer

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

Physics, rendering, and visualization are now separate choices. A task can use Newton physics with the Newton Warp renderer, for example, while being inspected through Newton GL, Rerun, or Viser. Supported combinations remain task-specific and are reported through each task’s --help output. See Backends and Presets.

franka_sim2sim_collage_seed123.mp4

eb1b82545824985e1b064899b34c2f43.MP4

Kit-less robot learning

Many Isaac Lab workflows can now run without installing or launching Isaac Sim:

• Newton physics with multi-solver capabilities - MuJoCo-Warp, VBD, MPM and coupled-solver workflows, with expanded support for deformables, cables, and particle systems.
• Experimental Kamino solver for complex articulations.
• Newton Warp camera rendering.
• Lightweight Newton GL visualization, as well as 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 needs capabilities such as XR teleoperation, Isaac Sim PhysX, Isaac Sim RTX, Isaac Sim ROS bridge, livestreaming, or Kit tooling.

Warp-native simulation data

Asset and sensor data now 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, cached views, and CUDA graph support reduce Python and tensor-conversion overhead while keeping PyTorch interoperability straightforward.

Unified training, playback, and benchmarking

The new isaaclab command replaces library-specific workflow scripts:

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

Isaac Lab provides unified integration for:

• RSL-RL (installed by default)
• skrl
• RL-Games
• Stable-Baselines3
• RLinf for VLA post-training

Checkpoint selection is standardized around --checkpoint, including latest, best, pretrained, and explicit paths. The benchmark system now covers startup, runtime, training, playback, and multi-GPU workflows through one typed API. See Reinforcement Learning.

Pluggable visualization and recording

Isaac Lab 3.0 includes five visualizers:

• Newton GL for lightweight local inspection and physics debugging.
• Newton RTX for high-quality kit-less rendering.
• Kit for the complete Isaac Sim and USD experience.
• Viser for browser-based visualization and sharing.
• Rerun for web viewing, recording, and timeline replay.

Visualizers can be selected with --viz:

uv run --extra rerun isaaclab play \
    --task Isaac-Cartpole \
    --checkpoint latest \
    --viz newton_gl

Recording is now configuration-owned and can capture a visualizer, a tiled view, or a scene camera. Camera pipelines also gain HDR output and the renderer-neutral PPISP image-signal-processing pipeline. See Visualization.

Stronger sensors, deformables, and simulation contracts

Isaac Lab 3.0 adds/expands:

• Backend-neutral contact, frame-transformer, IMU/PVA, joint-wrench, and ray-caster workflows.
• Explicit normal, friction, filtered, and aggregate contact-force contracts.
• A Warp-native ray-casting pipeline.
• Surface and volume deformables with backend-specific implementations.
• Newton VBD and rigid/deformable/MPM coupling.
• Backend-neutral visual materials and material randomization.
• Deterministic physics requests translated by each supported backend.

From simulation to deployment

Isaac Lab 3.0 strengthens the complete robot-learning workflow:

• Isaac Teleop integration with pipeline-based retargeting, CloudXR, and MCAP record/replay.
• Isaac Lab Mimic and SkillGen demonstration-generation workflows.
• Visually augmented imitation learning.
• Multi-GPU and multi-node RL training.
• LEAPP policy export and deployment commands.
• Bidirectional PhysX↔Newton policy-transfer guidance and validated examples for Franka Lift, G1 rough locomotion, and ANYmal-D rough locomotion.

See Transfer Policies Between PhysX and Newton.

A better developer experience

Isaac Lab 3.0 makes the common path much simpler:

• 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 task presets and builds launch commands interactively.
• The performance dashboard compares backends and tracks regressions.
• The repository ships 17 user-facing agent skills for installation, migration, environment creation, backend selection, Newton asset preparation, training, debugging, sim-to-sim transfer, sensors, actuators, and more.

Core breaking changes

Isaac Lab 3.0 is a major release. Compatibility shims remain for several renamed APIs, but downstream projects should migrate now rather than depending on those shims.

Installation and runtime

• Start from a fresh Python 3.12 environment; do not upgrade a 2.x environment in place.
• Full Isaac Sim workflows require Isaac Sim 6.1.
• uv run is now the recommended workflow; isaaclab.sh is deprecated and will be removed in a future release.
• Optional integrations are selected through extras such as isaacsim, ovphysx, ovrtx, teleop, mimic, and individual RL libraries.

Quaternions changed from WXYZ to XYZW

All Isaac Lab quaternion APIs, configuration values, asset and 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 therefore changes from (1, 0, 0, 0) to (0, 0, 0, 1).

Review hard-coded asset rotations, reset states, goals, controller targets, observations, and custom math. The migration guide includes a source scanner and a runtime detector for quaternion-bearing ProxyArray.torch accesses.

Data properties now return ProxyArray

Asset and sensor .data.* properties no longer return a torch.Tensor directly. Use .torch or .warp explicitly:

root_pos = robot.data.root_pos_w.torch

Temporary Torch interoperability remains available for some operations but emits deprecation warnings.

Write methods distinguish indices from masks

The ambiguous write_*_to_sim(data, env_ids) methods were removed. Use:

robot.write_root_pose_to_sim_index(root_pose=pose, env_ids=env_ids)
robot.write_root_pose_to_sim_mask(root_pose=pose, env_mask=env_mask)

This convention applies across rigid objects, articulations, rigid-object collections, and joint-property writers.

Backend configuration is explicit

Solver-common schema configuration lives under isaaclab.sim.schemas; PhysX- and Newton-specific configuration lives under isaaclab_physx and isaaclab_newton.

Core asset imports such as Articulation remain backend-neutral, while backend-owned APIs such as SurfaceGripper move to their backend package. Multi-backend tasks should use PresetCfg and typed physics= / renderer= selectors.

Custom scripts that load registered task configuration should use the shared task-composition helpers rather than passing unresolved configuration classes directly to an environment.

Actuator ownership moved to ActuatorCollection

Actuator commands and telemetry now live under robot.actuators:

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

Actuator setters are keyword-only. Canonical limit names now distinguish the actuator’s rated 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, which can change clipping behavior.

Sensor contracts changed

• The 2.x full-state IMU is now PVA.
• The new IMU reports only angular velocity and linear acceleration.
• ArticulationData.body_incoming_joint_wrench_b was removed; configure a JointWrenchSensor.
• Contact-force properties now distinguish total, normal, friction, aggregate, and filtered forces.
• Contact-sensor pose properties are deprecated; use FrameTransformer.

Asset and view naming changed

• 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 through the 3.x line.

Training and checkpoint commands changed

Backend-local and RL-library-local train.py and play.py entrypoints were removed. Use isaaclab train and isaaclab play with --rl_library.

Resume and playback workflows now consistently use --checkpoint.

Visualization and recording changed

• --viz selects visualizers.
• --headless is removed and no longer disables configured visualizers.
• Use --viz none to explicitly disable all visualizers.
• Viewport configuration moved from env_cfg.viewer to SimulationCfg visualizer configuration.
• gym.wrappers.RecordVideo is no longer supported; use VideoRecorderCfg.

Direct Isaac Sim imports require attention

Isaac Lab no longer preloads extensions simply to make their Python modules importable. Downstream projects that import Isaac Sim extensions directly must enable them after the Kit application starts:

from isaaclab.sim.utils import enable_extension

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

Legacy isaacsim.core.* and isaacsim.sensors.* imports should be replaced with Isaac Lab APIs where available or the corresponding Isaac Sim experimental APIs.

URDF and MJCF importers were rewritten

The new importer pipelines change output layout and remove/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 now use nested rigid bodies.

URDF and MJCF importers now generate multi-backend physics enabled assets with nested rigid bodies.
Review custom conversion scripts and code that traverses generated USD hierarchies.

Teleoperation moved to Isaac Teleop

The native isaaclab.devices.openxr stack is deprecated. Use isaaclab_teleop, IsaacTeleopDevice, IsaacTeleopCfg, and Isaac Teleop’s pipeline-based retargeters.

Benchmark entrypoints were consolidated

Legacy benchmark scripts and wrapper shell scripts were replaced by:

isaaclab benchmark runtime
isaaclab benchmark startup
isaaclab benchmark training
isaaclab benchmark play

The public benchmark API moved from isaaclab.test.benchmark to isaaclab.benchmark.

Migration 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, discovered automatically by Codex and Claude. 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."

These skills route the agent through the current documentation, APIs, examples, and focused validation commands instead of relying on remembered 2.x patterns.

Known limitations

Backend and preset support remains task-specific. Important limitations include:

• Surface-gripper tasks require CPU simulation with physics=isaacsim_physx.
• Pink IK tasks are supported on Linux x86_64 and aarch64; their dependencies are not available through the Windows installation.
• Closed-loop Digit articulations remain PhysX-only.
• Isaac Sim backends cannot be combined with OVPhysX and OVRTX.

Review the current Known Issues for more details.

Help us finish 3.0

Early Access is the best time to exercise your real projects:

• Migrate a 2.x task.
• Try the same environment in PhysX and Newton.
• Test your checkpoints with the unified play workflow.
• Exercise Windows, aarch64, Docker, and multi-GPU setups.
• Try the migration and troubleshooting agent skills.
• Share demonstrations and performance results.

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

Thank you to every contributor and early adopter who helped reshape Isaac Lab for 3.0. We are excited to see what you build.

Full changes since Beta 2 Patch 1