Train the Robot Before You Build It

NVIDIA’s robotics stack — Warp and Newton, Isaac Sim and Isaac Lab, Cosmos and GR00T, Jetson — what each piece is, what it runs on, what it costs to try, and the one part that ran on a machine with no GPU at all

Author

Behzad Samadi

Published

September 13, 2026

Robots are trained before they are built now. A quadruped learns to walk as thousands of copies of itself, running in parallel inside one GPU’s physics engine, before a motor turns; a humanoid rehearses a grasp against video a world model dreamed. The company that sells that GPU also sells nearly every other layer of the pipeline, under one name — Isaac — and it is the stack a working roboticist meets first, whether or not they end up using all of it.

This article is the map, read from the outside. Each layer gets the same four questions — what it is, what it runs on, what it costs to try, what was actually verified — and the answers are dated 13 September 2026, because this stack ships monthly. It was written on a machine with no NVIDIA GPU in it, which is not a handicap but the point. The Robotics course this site was started for runs in a browser tab; the honest question about NVIDIA’s stack is how much of it you can touch before you own an RTX card. The answer, measured below, is more than the brochure implies and less than you would like.

NoteTL;DR
  1. Two open engines at the bottom, one proprietary simulator on top. Warp and Newton are Apache-2.0, pip-installable, and run on a CPU — they ran here. Isaac Sim’s source is Apache-2.0 too, but the wheels you install are licensed “NVIDIA Proprietary Software”, need Ubuntu or Windows 11, an RTX 4080 or better, and Python 3.12 exactly.
  2. Three version lines are in flight at once. Isaac Sim 6.1.0, four days old on PyPI. Isaac Lab 2.3.2 on PyPI, for Isaac Sim 4.5–5.1 and Python 3.11. Isaac Lab 3.0 Beta 2 on GitHub, for Isaac Sim 6.0, built on Newton. Read the compatibility table before pip install.
  3. The models are open-weight, not open-source. GR00T N1.7 and the Cosmos family ship code under Apache-2.0 and weights under the NVIDIA Open Model License. GR00T’s 3 billion parameters infer on a 16 GB card, a Jetson Thor or a DGX Spark; fine-tuning wants 40 GB.
  4. No Mac, ever, for the simulator — but a Mac can drive one. Isaac Sim does not run on macOS. It streams to one: a headless instance on a rented L40S, a WebRTC client on the laptop. Newton runs on a Mac’s CPU natively.
  5. The price ladder is $0, $249, $3,499. Warp and Newton cost nothing. A Jetson Orin Nano Super developer kit is $249; the Jetson AGX Thor kit that runs GR00T at the edge is $3,499. In between sit a Linux box with an RTX 4080, or an hourly cloud GPU with RT cores — an A100 or H100 will not do.

The map

Layer Piece What it is Runs on Licence
Kernels Warp 1.17 Python functions JIT-compiled to CPU or CUDA kernels Linux, Windows, macOS (CPU) Apache-2.0
Physics Newton 1.6 GPU physics engine on Warp; MuJoCo Warp its primary solver Linux and Windows with an NVIDIA GPU; macOS and any CPU, slowly Apache-2.0, Linux Foundation
Simulator Isaac Sim 6.1 The world: Omniverse, OpenUSD, RTX rendering, sensors, synthetic data, ROS 2 Ubuntu 22.04/24.04 or Windows 11; RTX 4080 minimum; no macOS Source Apache-2.0; wheels proprietary
Learning Isaac Lab 2.3 / 3.0β Reinforcement and imitation learning over thousands of parallel environments Isaac Sim — or, in 3.0, Newton alone BSD-3
World models Cosmos Predict 2.5, Transfer 2.5, Reason 2 Video prediction, sim-to-real transfer, a physical-reasoning VLM Ampere or newer; 24–32 GB for Reason 2 Code Apache-2.0, weights Open Model License
Robot brain GR00T N1.7 A 3B vision-language-action model for humanoid manipulation 16 GB+ VRAM to run, 40 GB+ to fine-tune Code Apache-2.0, weights Open Model License
Runtime Isaac ROS 4.6 GPU-accelerated ROS 2 packages Jetson (JetPack 7.2), x86-64 with a GPU, DGX Spark; ROS 2 Jazzy NVIDIA’s own licence
Computer Jetson The robot’s brain hardware Orin Nano Super $249 · AGX Thor $3,499 —

Read the licence column twice. The bottom of the stack is as open as software gets; the top is open-source code around proprietary binaries; the models beside it are open weights with a licence of NVIDIA’s own drafting. None of that is unusual, and none of it is what the word “open” makes a newcomer expect.

Physics: Warp and Newton

Warp is the smallest piece and the one everything else is written in: “a Python framework for GPU-accelerated simulation, robotics, and machine learning” that “takes regular Python functions and JIT compiles them to efficient kernel code that can run on the CPU or GPU.” The CPU part is real — “The Windows x86-64 and Linux wheels support CPU execution,” and “The macOS wheels support CPU execution but not Metal acceleration” — and there is an Apple-silicon wheel on PyPI. Version 1.17.0 shipped on 31 August 2026, Apache-2.0. Its old warp.sim module is deprecated, because it grew up and moved out.

Newton is where it moved to: “a GPU-accelerated physics simulation engine built upon NVIDIA Warp, specifically targeting roboticists and simulation researchers.” Three names are on it — “initiated by Disney Research, Google DeepMind, and NVIDIA” — and it is “a Linux Foundation project that is community-built and maintained,” Apache-2.0. It “integrates MuJoCo Warp as its primary backend,” carries XPBD, VBD, Featherstone and an experimental Kamino solver beside it, does MPM, cloth and cables, and speaks OpenUSD. Version 1.0.0 reached PyPI on 10 March 2026, a week before GTC; 1.6.0 on 10 September — a release a month since. The requirements line is the one to read slowly: “Linux (x86-64, aarch64), Windows (x86-64), or macOS (CPU only)”; an “NVIDIA GPU (Maxwell or newer), driver 545 or newer”; “No local CUDA Toolkit installation required.”

pip install "newton[examples]"
python -m newton.examples basic_viewer     # a window; --viewer null for none
python -m newton.examples --list           # eighty-odd examples in 1.6.0

Read “GPU-accelerated” as the design, not the gate: without a GPU, Newton runs. How well is measured below.

The simulator: Isaac Sim

Newton moves bodies; Isaac Sim is the world they move in. Its README calls it “a simulation platform built on NVIDIA Omniverse, designed to develop, test, train, and deploy AI-powered robots in realistic virtual environments” — the OpenUSD scene, the RTX renderer, the cameras, lidars and now acoustic sensors, the synthetic-data pipeline, the ROS 2 bridge, the importers for URDF and MJCF. It is what draws the picture.

Runs on. “Windows 11 or Linux (Ubuntu 22.04/24.04)”. On a workstation the minimum is an RTX 4080 and the recommendation an RTX 5080 or 5880 Ada; in a datacenter an A40 at minimum and an L40S by preference. The 5.1 requirements page adds 16 GB of VRAM, 32 GB of RAM, 50 GB of disk (the pip install alone is about 25 GB), and one sentence that surprises people who have a cloud account: “GPUs without RT Cores (A100, H100) are not supported.” The renderer needs ray-tracing hardware; the training GPUs do not have it. There is no macOS build and no sign of one.

Versions. 5.0 went to GitHub under Apache 2.0 in August 2025; 5.1 followed in October. 6.0 arrived as an early developer release at GTC on 16 March 2026 — “Isaac Sim now supports multiple physics backends, including both PhysX and Newton,” Omniverse Kit 110 with Gaussian-splat reconstruction, robot-authoring tools, ROS 2 Jazzy through Python 3.12 — and went GA on 8 June with Newton software-in-the-loop, “a new deployable Model Context Protocol server” that “exposes Isaac Sim Extensions, APIs, and documentation to AI coding assistants,” and “a new Isaac Sim Skill” that “allows users to launch Isaac Sim and connect to a live, running instance directly from Claude Code” — the same agent that works this repository. 6.0.1 came on 22 June and 6.1.0 on 9 September, tagged GA, its release-notes link reported broken the next day. Fast, and not always tidy.

Costs. Nothing, to download. The licence FAQ says Isaac Sim is free with an NVIDIA account for research and internal development, and that an NVIDIA AI Enterprise licence is needed only to redistribute Isaac Sim itself or deliver it as a service — selling the datasets, videos or Python you make with it needs no licence. What the FAQ explains and PyPI states bluntly is that the source on GitHub is Apache-2.0 while the wheel is “NVIDIA Proprietary Software”: Omniverse Kit and the bundled assets are NVIDIA’s, under their own terms, and you cannot build the simulator without them.

One small trap. The 6.x wheels are ==3.12.*. From a Python 3.11 interpreter, pip index versions isaacsim reports 5.1.0.0 as the latest and says nothing about 6.x, because pip hides what it cannot install. If the version you see is not the version you read about, check python --version before anything else.

Learning: Isaac Lab

If Isaac Sim is the world, Isaac Lab is the school: “a GPU-accelerated, open-source framework designed to unify and simplify robotics research workflows, such as reinforcement learning, imitation learning, and motion planning.” Its job is the trick in the first paragraph — thousands of environments stepping in lockstep on one GPU, a policy learning from all of them at once. BSD-3, with its imitation-learning extension Apache-2.0.

Two lines are live, and the README on main describes only one of them. 2.3, the stable line, is on PyPI (2.3.2.post1, 11 February 2026), Python 3.11, “Isaac Sim 4.5 / 5.0 / 5.1” — and main still wears the 5.1 badge. 3.0 is the future: a beta at GTC on 17 March, “built on Isaac Sim 6.0,” with an isaaclab_newton extension that “enables running Isaac Lab environments without Isaac Sim (kit-less mode)” on the MuJoCo-Warp solver; Beta 2 on 23 June hardened the multi-backend paths — PhysX, Newton and the kit-less one — and added deformables and the Kamino solver; a patch on 2 July tracked Isaac Sim 6.0.1. It is on GitHub, not PyPI, and there is no date for a 3.0 GA. Kit-less is the line to watch: a learning framework that can run its physics without the renderer is a learning framework that could, one day, run without RT cores.

World models: Cosmos

Cosmos is the part of the stack that did not exist three years ago. Three families of “world foundation models,” all code Apache-2.0, all weights under the NVIDIA Open Model License, all wanting an Ampere-or-newer GPU: Predict 2.5 generates video of what happens next from text, an image or a clip (2B and 14B models, with robot-action-conditioned variants trained on RoboCasa and LIBERO); Transfer 2.5, built on it, “produces high-quality world simulations conditioned on multiple spatial control inputs” — the sim-to-real move, a rendered scene’s depth and segmentation restyled into photoreal video; Reason 2 is “an open, customizable, reasoning vision language model for physical AI and robotics,” Qwen3-VL underneath, 2B (24 GB of VRAM) and 8B (32 GB). The loop they close: Isaac Sim renders a scene, Transfer makes it look like the world, Predict extends it, Reason judges it — and the robot trains on all of it.

The robot brain: GR00T N1.7

“An open vision-language-action (VLA) model for generalized humanoid robot skills”: camera frames and an instruction in, joint actions out. N1.7’s backbone is Cosmos-Reason2-2B — the same model as above, which is the clearest sign the layers are meant to be one stack — with a flow-matching diffusion transformer producing the actions; 3 billion parameters in all, trained on “bimanual, semi-humanoid and an expansive humanoid dataset.” Code Apache-2.0; weights, once more, the NVIDIA Open Model License. Early access opened on 17 April 2026 and the GA release followed with terms that allow commercial use. The hardware line is the honest one in the README: “Inference: 1 GPU with 16 GB+ VRAM (e.g., RTX 4090, L40, H100, Jetson AGX Thor/Orin, DGX Spark)”; “Fine-tuning: 1 or more GPUs with 40 GB+ VRAM recommended.” Fine-tunes for DROID, LIBERO and SimplerEnv are published beside the base model. Install is uv sync --python 3.12 after a clone with --recurse-submodules, git-lfs, FFmpeg and a Hugging Face login.

The robot: Jetson and Isaac ROS

Everything above runs on a desk or in a rack. Jetson is what goes in the robot. Two doors: the Orin Nano Super Developer Kit at $249 — an 8 GB Orin Nano at 67 sparse TOPS, and an existing Orin Nano kit becomes one with a software update — and the AGX Thor Developer Kit at $3,499, on sale since 25 August 2025: up to 2,070 FP4 TFLOPS from a 2,560-core Blackwell GPU, a 14-core Arm Neoverse V3AE, 128 GB of LPDDR5X, 40–130 W, “7.5x more AI compute” than the Orin it replaces. Thor is the one GR00T lists as an inference target; the Nano is the one a student buys. Between them, and back on the desk, the DGX Spark — GB10, 128 GB of unified memory, $3,999 at its October 2025 launch and more since — appears in both GR00T’s and Isaac ROS’s supported lists.

Isaac ROS is the software on the Jetson: “a collection of NVIDIA-accelerated, high performance, low latency ROS 2 packages for making autonomous robots” — perception, localisation, depth, the GPU-side plumbing. 4.6.0 shipped in August 2026 on JetPack 7.2 and ROS 2 Jazzy, for Jetson Orin and Thor, x86-64 with a GPU, and the Spark. One caution the rest of the stack does not prepare you for: its licence file is the “NVIDIA Isaac ROS Software License,” not Apache. cuRobo, NVIDIA’s CUDA motion planner “built on PyTorch, CUDA, and Warp,” is Apache-2.0.

What ran here, with no GPU

The machine: a cloud Ubuntu 24.04 container, four Xeon vCPUs, 15 GB of RAM, no GPU — Warp’s first line at start-up was “Could not find or load the NVIDIA CUDA driver. GPU execution will not be available.” Python 3.11. Everything the documentation said would run on a CPU was tried; nothing that needs an RTX card was. The commands and full output are in the research notes.

Step Wall time Of which compile Simulation
pip install warp-lang "newton[examples]" (2.8 GB) 1 min 20 s — —
Warp, a 10-million-element kernel on cpu 2.6 s 1.9 s 26.8 ms per launch
Newton pendulum, XPBD, first run 23.7 s ≈ 20 s 1,454 frames/s
Newton pendulum, XPBD, second run 2.95 s ≈ 0 1,389 frames/s
Newton pendulum written to pendulum.usd 3.3 s ≈ 0 36 KB, binary USD
Newton quadruped from URDF, XPBD 11.4 s 4.0 s 45 frames/s
Newton Allegro hand and cube, MuJoCo Warp 57.8 s ≈ 35 s 10.1 frames/s

Three things to read off it. It all ran. Warp kernels, three Newton solvers including MuJoCo Warp itself, URDF and USD import, USD export — with no flag but --device cpu and --viewer null. The first run of anything is compile time, cached afterwards under ~/.cache/warp; budget half a minute per new example, once. Ten frames a second for a sixteen-joint hand is a reading speed, not a training speed. Newton’s design point is thousands of copies of that hand on one GPU; four cores give you one copy, slowly. That is exactly enough to read the code, step a robot, write a test, or teach a class — and nothing like enough to train a policy. The brochure and the benchmark are both telling the truth; they are describing different machines.

Without an RTX card

Four ways in, from cheapest to most permanent.

  • Run the open half on what you have. Warp and Newton, on a CPU, on all three operating systems — the macOS wheels are “CPU only” and on PyPI, Apple silicon included. Every Newton example, every solver, every USD file.
  • Rent an hour. NVIDIA’s own Brev launchable packages “a Visual Studio Code container,” Isaac Sim 6.0.1, Isaac Lab 3.0.0-beta2 and a Kit streaming client on a cloud GPU “with RT cores” — an L40S in the vendor’s walkthrough. “Brev instances are pay-by-the-hour,” its README warns, so “stop instances when they are not in use,” and “This project is intended for learning purposes.” For a first look at Isaac Lab that is precisely the point.
  • Stream to the laptop. Isaac Sim runs headless — isaac-sim.headless .webrtc.sh — and the docs ship a native WebRTC streaming client for Windows, Linux and macOS, x86-64 and Apple silicon, or a browser page at port 8211. The GPU is wherever it is; the window is on the Mac.
  • Buy the floor. A Linux box with an RTX 4080 or better — 16 GB of VRAM with RT cores, 32 GB of RAM, Ubuntu 24.04, Python 3.12 — is the smallest machine that runs the whole stack locally. A Jetson is not that machine: it is where the trained robot runs, not where the simulator does.

What to do this week

  • pip install "newton[examples]" and run basic_pendulum, then robot_allegro_hand, on whatever computer you have. Read the two example files; they are three hundred lines between them.
  • Read one Isaac Lab task before installing anything — the quadruped locomotion environment is the classic. The structure is the lesson; the install is 25 GB.
  • Pick a line and write it down: 2.3 on Isaac Sim 5.1 and Python 3.11, or 3.0 beta on 6.0, Newton and 3.12. Mixing them is the most common install failure, and pip will not warn you.
  • Without an RTX card, spend an hour on the launchable before spending a month deciding whether to buy one.
  • Buying: 16 GB, RT cores, Ubuntu 24.04. Not an A100 for this; not a Mac for this; not a Jetson for this.

Sources

Research notes — the pages read, the PyPI records, the full output of the CPU run, and the vendor pages that could not be fetched — are in the accompanying folder.