NVIDIA Isaac
NVIDIA Isaac is an open robotics development platform: simulation and robot learning frameworks (Isaac Sim, Isaac Lab), CUDA-accelerated ROS 2 packages (Isaac ROS), robot foundation models (Isaac GR00T) and reference workflows for building mobile robots, robot arms and humanoids.1
Also known as NVIDIA Isaac platform, Isaac Gym (predecessor of Isaac Lab)
At a glance
- What is it?
- Isaac is NVIDIA's set of software for building robots, from simulation to deployment. Isaac Sim is an open source reference framework for robot simulation and synthetic data, built on Omniverse libraries. Isaac Lab is an open source framework for training robot policies at scale, built on Isaac Sim. Isaac ROS is an open source set of ROS 2 packages accelerated for NVIDIA hardware. Isaac GR00T is NVIDIA's research initiative and reference platform for humanoid robots, with open robot foundation models. NVIDIA positions DGX systems for training, OVX for simulation and Jetson-based AGX systems for running robots.12
- What does it do?
- Isaac lets a team import a robot and its environment, simulate physics and sensors, and generate labeled synthetic data. Robot behaviors can then be trained with reinforcement or imitation learning on many GPUs in parallel and evaluated in simulation (Isaac Lab-Arena). Once trained, perception, localization, mapping and manipulation software runs on the robot through Isaac ROS, typically on Jetson. Software-in-the-loop and hardware-in-the-loop tests close the gap between simulation and the real machine.2
- Who needs it?
- Companies and labs that build autonomous mobile robots, robot arms or humanoids and want to test and train in simulation before field trials. ROS 2 developers who need GPU acceleration for perception. Researchers working on robot learning and foundation models for robots.
- What does it need?3
- Isaac Sim minimum: Ubuntu 22.04/24.04 or Windows 11, 4-core CPU, 32 GB RAM, 50 GB SSD, GeForce RTX 4080 with 16 GB VRAM
- GPUs without RT Cores, such as A100 and H100, are not supported for Isaac Sim
- Extra RAM and VRAM for Isaac Lab training runs
- Robot models in URDF, MJCF or CAD form
- ROS 2 skills and a Jetson or x86 system with an NVIDIA GPU for Isaac ROS
- Python and basic reinforcement or imitation learning knowledge
- What it is not
- Isaac is not a robot and not a turnkey robot controller; it is a set of tools a robotics team builds with. It does not replace ROS: Isaac ROS stays compatible with ROS 2 and adds accelerated packages. Isaac Sim is not the same as Omniverse; it is a robotics framework built on Omniverse libraries. A good simulation result is not proof of safe real-world behavior, and a questionnaire or ROI calculator about robots is not a simulation. NVIDIA describes GR00T as a research initiative and development platform, and Isaac GR00T 1.7 is in Early Access ahead of a full commercial release.45
Availability and licensing. NVIDIA states Isaac Sim is free and open source under Apache 2.0 on GitHub, with some materials under the NVIDIA Isaac Sim Additional Software and Materials License. Isaac Lab (BSD-3-Clause; its isaaclab_mimic extension is Apache 2.0) and Isaac ROS are open source. Isaac GR00T 1.7 is in Early Access, and NVIDIA lists production deployment with commercial support as not yet supported. The Isaac Sim FAQ still says redistributing Omniverse Kit inside a product needs a separate NVIDIA license; check this against Omniverse's May 2026 terms. Newton is in beta and Isaac for Healthcare is in early access.256
The problem it solves
Robots learn and are tested slowly in the real world. Every trial uses hardware time, risks damage, and covers only the conditions that happen to occur that day. Collecting and labeling sensor data for perception is expensive, and rare situations are hard to capture at all.
Isaac moves much of this work into GPU-accelerated simulation: robots and sensors are modeled in physically based scenes, policies are trained across many parallel environments, and the resulting software is deployed on the robot through ROS 2 packages built for NVIDIA hardware.
How it works
- Build the scene. Isaac Sim imports CAD, URDF, MJCF or real-world captures, converts them to OpenUSD, and lets you assign materials, physics, robots and sensors.
- Generate data. Randomize lighting, color and positions to produce annotated images (RGB, bounding boxes, segmentation) exported as COCO or KITTI; Cosmos models can augment the data further.
- Train policies. Isaac Lab runs reinforcement and imitation learning across many GPU-parallel environments, with Newton, PhysX, Warp or MuJoCo as physics backends, and scales to multi-GPU and multi-node runs (OSMO handles cloud orchestration).
- Evaluate. Isaac Lab-Arena evaluates policies in simulation; Isaac Sim supports software-in-the-loop and hardware-in-the-loop tests.
- Deploy. Isaac ROS packages, accelerated by NITROS, run perception, localization, mapping and manipulation on Jetson or x86 systems with ROS 2.27
Diagram as a list
Applications & solutions
- Robot and scene assets (CAD, URDF, MJCF)Inputs converted to OpenUSDConnects to Isaac Sim
- Isaac SimSimulation, sensor models and synthetic dataConnects to Isaac Lab and Isaac Lab-Arena, Isaac ROS (ROS 2, NITROS)
Models & frameworks
- Isaac Lab and Isaac Lab-ArenaPolicy training and evaluationConnects to Isaac GR00T foundation model, Isaac ROS (ROS 2, NITROS)
- Isaac GR00T foundation modelPretrained humanoid policy to post-trainConnects to Isaac ROS (ROS 2, NITROS)
Inference & runtime software
- Omniverse libraries and OpenUSDRendering, physics and scene foundation of Isaac SimConnects to Isaac Sim
- Isaac ROS (ROS 2, NITROS)On-robot perception, mapping and manipulationConnects to Jetson / AGX on the robot
Operations & orchestration
- OSMO orchestrationScales simulation and training across clustersConnects to Isaac Lab and Isaac Lab-Arena
Accelerated computing
- DGX and OVX systemsTraining and simulation computeConnects to Isaac Sim, Isaac Lab and Isaac Lab-Arena
- Jetson / AGX on the robotRuns the deployed robot software
Capabilities
Isaac Sim simulation and synthetic data23
Open source reference framework for robot simulation, testing and synthetic data generation in physically based scenes, with importers for URDF, MJCF, OnShape and CAD.
Why it matters: Gives a safe place to test robots and produce labeled training data.
Limits: Needs an RTX-class GPU; the container runs only on Linux; some assets fall under a separate NVIDIA license.
Isaac Lab robot learning7
Open source, GPU-accelerated framework for training robot policies with reinforcement and imitation learning, scaling across GPUs and nodes.
Why it matters: Trains locomotion and manipulation skills in parallel simulated environments.
Limits: Training needs more RAM and VRAM than basic simulation; policies still need real-world validation.
Isaac ROS accelerated packages4
Open source ROS 2 packages for perception, localization, mapping, manipulation and inference, with NITROS for accelerated message transport.
Why it matters: Adds GPU acceleration to an existing ROS 2 robot without changing frameworks.
Limits: Acceleration targets NVIDIA platforms such as Jetson and NVIDIA GPUs.
Isaac GR00T for humanoids5
Reference platform with an open robot foundation model that takes language and images, can be post-trained for specific robots, and runs on Jetson Thor.
Why it matters: A starting point for humanoid manipulation tasks such as grasping and handing items between arms.
Limits: Isaac GR00T 1.7 is in Early Access: NVIDIA supports experimentation, prototyping and research, and lists production deployment with commercial support as not supported.
Policy evaluation with Isaac Lab-Arena7
Open source framework built on Isaac Lab for evaluating robot policies in simulation at scale.
Why it matters: Compares policies under many simulated conditions before hardware tests.
Limits: Simulated scores do not replace field trials.
Newton physics engine2
Open source, GPU-accelerated physics engine co-developed by Google DeepMind and Disney Research, managed by the Linux Foundation and built on Warp and OpenUSD.
Why it matters: Improves contact modeling for robot learning and works with Isaac Lab and MuJoCo Playground.
Limits: NVIDIA describes Newton as being in beta.
Domain workflows14
Isaac for Manipulation (still called Isaac Manipulator on the main Isaac page) builds on Isaac ROS for robot arms, and Isaac for Healthcare provides a digital twin and training framework for healthcare robots.
Why it matters: Packages common robot types into ready workflows.
Limits: Isaac for Healthcare is offered through an early access application.
Practical use cases
A warehouse mobile robot needs reliable perception and localization before it goes on the floor.
- Approach
- Model the warehouse and robot in Isaac Sim, generate labeled sensor data, then deploy Isaac ROS perception and localization packages on Jetson.
- Role of NVIDIA Isaac
- Supplies the simulation, synthetic data and on-robot ROS 2 packages.
- Data, infrastructure and skills
- Robot model, sensor specs, a map or CAD of the site, and ROS 2 skills.
- Type of benefit
- Fewer on-site trial runs
- Caveats
- Lighting, reflections and clutter in the real site may differ from the scene.
- First step
- Import the robot's URDF into Isaac Sim and attach its real sensor models.
A robot arm must learn a new pick-and-place task without weeks of manual programming.
- Approach
- Train the policy with imitation or reinforcement learning in Isaac Lab across many parallel environments, evaluate it in Isaac Lab-Arena, then test on hardware.
- Role of NVIDIA Isaac
- Provides GPU-parallel training and evaluation.
- Data, infrastructure and skills
- Demonstrations or a reward design, GPU capacity, and a safe hardware test cell.
- Type of benefit
- Faster skill development
- Caveats
- Sim-to-real transfer must be checked; contact-rich tasks are harder to simulate.
- First step
- Run an Isaac Lab sample manipulation task, then swap in your robot.
A humanoid developer needs a starting model instead of training from scratch.
- Approach
- Post-train the Isaac GR00T model (version 1.7, in Early Access) on data from the target robot and test it on Jetson Thor as a prototype.
- Role of NVIDIA Isaac
- Provides the pretrained model, data pipelines and simulation frameworks.
- Data, infrastructure and skills
- Robot-specific demonstration data and Jetson Thor hardware.
- Type of benefit
- Shorter path to a working baseline
- Caveats
- Early Access: NVIDIA lists production deployment with commercial support, a stable feature set and product-level support as not supported; verify license and version in the repository.
- First step
- Review the NVIDIA/Isaac-GR00T repository and its supported embodiments.
Sources 5
Who uses it
BMW Group · Automotive manufacturing
BMW Group: planning car plants in an Omniverse-based Virtual Factory
BMW Group plans and checks its car plants in a Virtual Factory built on NVIDIA Omniverse and OpenUSD. BMW says digital twins now cover more than 30 production sites, cut collision checks for new models from almost four weeks to about three days, and are projected to lower planning costs by up to 30 percent.
Scaling
Foxconn (Hon Hai Technology Group) · Electronics manufacturing
Foxconn: digital twins for new server plants with Omniverse, Isaac and Metropolis
Foxconn uses NVIDIA Omniverse digital twins to plan production lines, Isaac to simulate robots and Metropolis for camera-based monitoring, from Hsinchu to new server plants in Mexico and the US. Most published results are expectations, such as a forecast energy cut of over 30 percent in Mexico.
In production
Works with
Requires
- NVIDIA OmniverseIsaac Sim is built on NVIDIA Omniverse libraries.
Optional integration
- NVIDIA CosmosCosmos models can augment synthetic data generated in Isaac Sim.
Complementary tools
- NVIDIA JetsonIsaac ROS and GR00T run on Jetson for on-robot deployment.
- NVIDIA OmniverseIsaac Sim is a robotics framework built on Omniverse libraries.
- NVIDIA CosmosIsaac Sim and Cosmos together generate synthetic data for robot perception.
- NVIDIA Holoscan SDKIsaac for Healthcare is a domain framework built on Isaac Sim, Isaac Lab, Omniverse and Holoscan.
Relationship labels follow NVIDIA's documentation. "Alternative approaches" does not mean one is better: each profile says when it fits.
Getting started
Check your workstation
Compare CPU, RAM, GPU, VRAM and driver with the Isaac Sim requirements page, then run the Isaac Sim Compatibility Checker after install.
Check: The checker passes and the GPU has RT Cores (an RTX model).
Install Isaac Sim
Download Isaac Sim from GitHub, or use the NGC container (Linux) or a Brev cloud instance if local hardware falls short.
Check: Isaac Sim opens and loads a sample scene.
Import your robot
Use the URDF or MJCF importer, or the CAD converter, and attach the robot's sensors.
Check: The robot's joints move as expected under simulated physics.
Train a sample policy
Install Isaac Lab from GitHub and run one of its tutorial training tasks headless.
Check: Training completes and the trained policy plays back in simulation.
Set up Isaac ROS on the target
Follow the Isaac ROS quick start on a Jetson device and run one accelerated perception package.
Check: The ROS 2 node publishes results on the Jetson.
Official resources
Could this technology help you?
Describe your project to the Solution Architect. It starts with NVIDIA Isaac as context but recommends independently, including when you do not need it.
Sources
Each statement above links to the source it comes from. Labels say who reported it.
- NVIDIA Isaac (developer page) (opens in a new tab)
- NVIDIA Isaac Sim (developer page and FAQ) (opens in a new tab)
- Isaac Sim documentation: system requirements (opens in a new tab)
- NVIDIA Isaac ROS (developer page) (opens in a new tab)
- NVIDIA Isaac GR00T (developer page) (opens in a new tab)
- Isaac Lab GitHub repository README (opens in a new tab)
- NVIDIA Isaac Lab (developer page) (opens in a new tab)
Thank you. Your correction was sent.
The editors check it against the sources. If you left an email address, they may reply about it.