Steel
New1. Overview
Steel stands for Scalable Throughput-optimized Engine for Embodied Learning. It is a GPU-accelerated rigid-body dynamics solver introduced by Skild AI together with NVIDIA in November 2026 and contributed to the open-source Newton physics engine, where it is exposed as newton.solvers.SolverSteel. The launch article is the primary source for this entry; the standalone skild-ai/steel repository is mostly a README, a launch poster and a licence, while the implementation lives in the Newton source tree at newton/_src/solvers/steel. Understanding that split is the first step in evaluating the project, because the code, the release cadence and the API contract all belong to Newton.
For a physics-AI practitioner the interesting claim is not one more speed record. Simulation throughput determines how much experience a robot policy can collect, and the dominant GPU simulation architectures are most efficient when one structured workload is replicated thousands of times. General-purpose manipulation asks for the opposite: arms, dexterous hands, humanoids and quadrupeds practising different tasks inside one batch. Steel is designed for complexity within environments and heterogeneity across them, and its published numbers are deliberately framed around that axis. The project reports 3.8 times PhysX simulation throughput as a geometric mean over 20 single-task benchmarks, faster on 19 of the 20, and 9.2 to 13.0 times PhysX peak measured throughput on batches mixing 5 to 20 task types.
This site already documents the GPU kernel substrate in Warp, the contact-dynamics core in MuJoCo and the upper motion-learning layer in ProtoMotions. Steel sits beside them as an alternative solver inside Newton, sharing its model representation and collision infrastructure. After reading this guide you should be able to answer four questions: what the per-environment scheduling design actually changes; which measurement conditions the headline ratios depend on; how Steel relates to PhysX, MuJoCo Warp and Isaac Lab; and what a reproduction or a deployment review requires. The physics simulation primer supplies the vocabulary, the classical solver cost boundary frames cost comparisons, and the Skild AI company report gives the vendor context.
All version, licence and capability statements below were checked on 12 November 2026 against the launch blog and its measurement notes, the Steel, Newton and steel-webgpu repository README files, the Newton releases page and NVIDIA's CoRL 2026 announcement. Every throughput and memory figure is a project measurement or a transcription of one, recorded with its hardware, task and baseline conditions in Sections 6 and 9. This site does not certify those numbers for your workload.
2. How It Works
The problem Steel addresses is uneven work. A robot arm reaching in free space, a dexterous hand reorienting a cube and a manipulator working through a cluttered bin have different joint counts, constraint counts and active contacts, and even one scene changes its workload from step to step as contacts appear and disappear. Treating all three as if they need the same amount of computation leaves much of the GPU poorly allocated. The launch blog describes three responses: dynamics and constraints are organised per environment; articulations with similar joint counts are grouped so the GPU executes tidy bundles; and contact-solving work is routed according to each environment's current demands. Grouping and routing reduce padding and unnecessary solve work when a batch contains heterogeneous scenes. The numerics and solvers collection and the AMGX GPU linear solver case give the wider solver context.
Under the hood the design combines reduced-coordinate articulation dynamics with projected Gauss-Seidel constraint solving. The project states that it reuses the factorisation of each articulation's joint-space mass matrix across its contacts, without constructing a dense matrix of pairwise constraint interactions. That is the specific claim behind the articulation-heavy results: dense articulation factorisations grow expensive as robots become more complex, and the design avoids paying that cost per contact. Reduced coordinates keep joint constraints implicit in the representation, while the contact solve is handled iteratively. The physics simulation primer explains why coordinate choice and contact formulation are coupled decisions, and Warp documents the kernel language Newton is built upon.
Three further mechanisms appear in the launch demonstrations. Settled groups of bodies fall asleep as separate islands and Steel skips most of their solve work; a compliant hydroelastic contact demo with a Panda grasping a pen fits an entire step inside one captured CUDA graph; and an opt-in differentiable step lets Newton's tape backpropagate through Steel, used in a drone model-predictive control example. A separate example differentiates a ball's launch velocity through an experimental smooth contact model. Both gradient features are labelled Experimental in the announcement. Coupled demos show a Franka placing a VBD cable, cloth manipulation, rigid boxes landing on implicit MPM sand and a sphere denting a VBD soft-body beam; in each case Steel supplies the rigid side of a Newton coupled solver, with the deformable physics handled elsewhere in Newton. JAX and PhysicsNeMo cover the array and physics-library layers that surround such workflows.
3. Scope and Assumptions
The first boundary is the physics domain. Steel is a rigid-body dynamics solver for articulated mechanisms and contact. It does not compute fluid flow, heat transfer or electromagnetic fields, and a project whose deliverable is a validated continuum-field solution belongs with OpenFOAM or PhysicsNeMo. The demos that show cloth, cables, sand and soft bodies are Newton coupling demonstrations: Steel is explicitly the rigid side. A reader who concludes that Steel simulates deformable continua on its own has misread the launch material.
The second boundary is the host stack. Steel is developed directly within Newton and shares Newton's model representation and collision infrastructure, so there is no standalone engine to install. Newton is built on NVIDIA Warp, extends the deprecated warp.sim module and integrates MuJoCo Warp as its primary backend; Steel is an additional solver, not a replacement for that backend. The Newton README specifies Python 3.10 or newer with 3.10 deprecated and removal planned for Newton 1.9, recommends 3.11 or newer, and states that fresh installs select Warp 1.18, which requires an NVIDIA Turing GPU of compute capability 7.5 or higher and driver R580 or newer for CUDA acceleration. On an R545 to R579 driver or an older supported GPU it advises pinning warp-lang to 1.17.0. macOS runs on CPU only. The Warp entry and the MuJoCo entry explain those two layers.
The third boundary is the measurement contract. The published benchmarks were run on the Newton release-1.8 candidate 01ea1293, with reuse_kinematics set to True in the single-task suite and not active in the heterogeneous suite because joint velocity limits were on. PhysX came from Isaac Sim 6.1.0.0 with omni.physx 110.3.2 and MuJoCo Warp was version 3.17, all on one NVIDIA RTX PRO 6000 Blackwell GPU. The heterogeneous runs used one 5 millisecond physics step per environment step, small noisy hold-position targets, no policy, no domain randomisation, no cameras and CUDA graphs enabled. The single-task suite timed physics stepping only at the host-return boundary, excluding observations, rewards and resets and synchronising the device per step. Throughput under these conditions is not end-to-end policy-training speed, and the classical solver cost boundary guide explains why the distinction matters.
The fourth boundary is legal and operational. Steel and the Newton source are Apache-2.0, Newton documentation is CC BY 4.0, third-party licence texts live in newton/licenses, and the steel-webgpu package keeps its bundled robot models under separate BSD-3-Clause and MIT terms. The Skild blog says Steel is intended to integrate with NVIDIA Isaac Lab; NVIDIA's CoRL announcement describes Isaac Lab 3.0 as able to switch between PhysX and Newton solvers. Those are compatible statements with different levels of commitment, and this entry records both without asserting a production-grade integration that neither document claims.
4. Getting Started
The zero-install entry point is the browser. The launch article embeds 24 live scenes rendered by steel-webgpu, a WebGPU port of the Steel solver, with objects that can be dragged while solver settings change; the playground exposes the full demo page. The repository states that Chrome, Edge or Safari with WebGPU on desktop or mobile is required, and that the scenes run on the reader's own GPU with no recording involved. For application work the package @skild-ai/steel-webgpu exposes three entry points: the engine with Sim, SceneBuilder, scene loading and URDF, MJCF and USDA import; a three.js layer for rendering, picking and dragging; and React Three Fiber components and hooks. Development uses Bun, and Newton models export to a scene folder with tools/newton_export.py. The Python robotics entry covers the tooling that surrounds this kind of asset pipeline.
For local physics work, install Newton with pip install "newton[examples]" and run one of the two Steel examples named in the Newton README, steel_sleeping and steel_determinism_arms, through python -m newton.examples. The solver itself is imported as newton.solvers.SolverSteel. The broader example set covers cartpole, G1 and H1 humanoids, ANYmal quadrupeds, an Allegro hand, hydroelastic contact, cloth, cables, MPM granular material and differentiable simulation, so a team can move from a single scene to a coupled one without changing stacks. Robot models can be drawn from MuJoCo Menagerie, RoboCasa, Isaac Sim assets or Universal Robots URDF, subject to each asset's own licence.
Before trusting any number, fix and record the Newton version, the commit or release candidate, the Python and Warp versions, the GPU and driver, the timestep, the solver flags, whether reuse_kinematics is enabled, the task mixture, the batch size and the PhysX or MuJoCo Warp baseline version. A first disciplined experiment is a matched-batch replay: run one of the 20 single-task benchmarks at the same batch size on Steel and on the PhysX version named in the measurement notes, timing physics stepping only, then repeat with reuse_kinematics both on and off to quantify what the opt-in path contributes. The second experiment mixes 5, 10, 15 and 20 task types and records both peak throughput and memory, since those were the two quantities the project reported. The physics-AI learning path and the physics simulation primer place these checks in a broader sequence, and the classical solver cost boundary gives the recording discipline.
5. Comparison with Alternatives
The comparison that matters is by contract. PhysX, as shipped in Isaac Sim 6.1.0.0, is the baseline the project chose, and the published results are ratios against that specific native runtime on one RTX PRO 6000 Blackwell GPU. MuJoCo Warp 3.17 is the second comparator: the launch article reports MuJoCo Warp at 2.9 times PhysX on the same 20 tasks and Steel at approximately 1.3 times MuJoCo Warp, with the 23-joint Kuka-Allegro lift task at 6.7 times PhysX and about 1.8 times MuJoCo Warp. That makes MuJoCo Warp a strong baseline rather than a slow one. The MuJoCo entry documents its soft convex contact model and the Beta caveats of the Warp backend, and Warp documents the kernel layer both projects use.
A common misreading is to place Steel and MuJoCo in competition. Newton is a Linux Foundation project initiated by Disney Research, Google DeepMind and NVIDIA, and its README describes MuJoCo Warp as its primary physics backend. Steel is an additional solver contributed to the same engine; both share Newton's model representation and collision infrastructure. MJX and the CPU MuJoCo kernel belong to a separate engine family with a different contact formulation. These are different layers and different approximations, and this guide does not rank them. OpenFOAM and PhysicsNeMo are further away again, since their subject is continuum fields.
Isaac Lab sits at the orchestration layer. NVIDIA's CoRL 2026 announcement describes Isaac Lab 3.0 as able to switch between PhysX and Newton solvers, to choose renderers for perception-based training and to apply a reinforcement post-training library to foundation models. It also reports up to 2.5 times the training throughput of Isaac Lab 2.3 with PhysX for Isaac Lab 3.0 with Newton on a vision-based dexterous manipulation benchmark. That is a training-throughput figure with its own benchmark, measured on a different quantity from the simulation-stepping ratios in Section 6, and the two should not be multiplied or compared directly. The NVIDIA company report gives the platform context, the Skild AI company report gives the vendor context, and the Westlake Robotics company report covers another participant in the same ecosystem.
A deployment review should also keep three layers separate. PhysX and Steel are solvers; Newton is the engine that combines solvers with a model representation, collision infrastructure and coupled physics; Isaac Lab owns the environment, rewards and training loop. Any layer can change version independently, so a benchmark report needs a version for each one and should treat a solver swap and a framework upgrade as two different events. The numerics and solvers collection and the AMGX GPU linear solver case give lower-level comparisons, while MuJoCo Menagerie shows why shared robot assets make cross-backend evaluation possible.
6. Benchmarks and Evidence
The public evidence base consists of one vendor benchmark campaign, documented with unusual care in the launch article's measurement notes. All figures are simulation-only throughput on one NVIDIA RTX PRO 6000 Blackwell GPU, with each engine at its best measured batch size unless a matched comparison is stated. On 20 single-task benchmarks, measured on 7 November 2026, Steel was faster than PhysX on 19 of them with a 3.8 times geometric mean; MuJoCo Warp averaged 2.9 times PhysX, making Steel roughly 1.3 times MuJoCo Warp. The 23-joint Kuka-Allegro lift task reached 6.7 times PhysX and about 1.8 times MuJoCo Warp. Batch sweeps went up to 524,288 environments. The one exception is Cartpole, where Steel's sweep stopped at 65,536 environments while its throughput was still rising, and the article plots that result as measured.
The heterogeneous campaign, measured on 8 and 9 November 2026, mixed 5, 10, 15 and 20 task types including humanoids, quadrupeds, arms and dexterous hands. Peak-throughput ratios were 9.2 times at 5 types (5.83 million against 632 thousand environment steps per second), 10.4 times at 10 types (4.95 million against 474 thousand), 12.5 times at 15 types (3.82 million against 306 thousand) and 13.0 times at 20 types (3.90 million at 245,760 environments against 300 thousand at 61,440 environments). At the matched batch size of 61,440 environments with 20 task types, Steel ran at 3.61 million environment steps per second, 12.0 times PhysX, using about 62 percent less GPU memory, approximately 11 versus 29 GiB. PhysX curves for the larger mixtures end early at its 64K-material limit. The classical solver cost boundary guide explains how to record these conditions.
Provenance matters as much as magnitude. The Steel build was the Newton release-1.8 candidate 01ea1293; the single-task suite used reuse_kinematics=True, while the heterogeneous suite had joint velocity limits on and therefore did not use that path. PhysX came from Isaac Sim 6.1.0.0 with omni.physx 110.3.2, and the article notes that Isaac Sim 6.0.0.0 ran these mixtures up to about 2.7 times faster than 6.1, a difference in the PhysX runtime alone. Throughput excludes observations, rewards and resets, synchronises the device per step and is not end-to-end training speed. No independent reproduction and no cross-engine contact-accuracy comparison are cited here. NVIDIA's separate CoRL claim of up to 2.5 times training throughput for Isaac Lab 3.0 with Newton belongs to a different benchmark and is recorded in Section 5. The NVIDIA company report and the Skild AI company report supply context, not validation.
7. Role in Physics-AI Workflows
In a physics-AI programme Steel occupies the layer where the cost of diverse experience is set. The launch article frames the motivation through Skild's S1 work and its omni-bodied research: capabilities improved as pretraining experience scaled, but for general policies the coverage of that experience matters alongside its volume. Real-world data remains essential for grounding and transfer validation, yet physical collection is expensive across every task and recovery scenario. Simulation supplies repeatable on-policy exploration, alternative actions from the same starting state, failures and recoveries. Steel addresses the specific cost of simulating different tasks, scenes and embodiments together. The article's own figure rates ordinary simulation as high on scalability and low on diversity, and marks high diversity with Steel as a research goal with illustrative, explicitly unmeasured levels. The physics-AI learning path orders the surrounding stages.
A second role is batch design. If a team can place locomotion, classic control, articulation-heavy manipulation and contact-rich tasks in one GPU batch without padding every environment to the largest one, then curriculum construction, replay composition and evaluation suites can be organised around what the policy should learn rather than around what the simulator executes efficiently. Asset collections such as Open X-Embodiment, RoboTurk, RoboTHOR and RoboCasa show the data side of that arrangement; Isaac Sim assets and Universal Robots URDF show the model side.
A third role is as a rigid-side component in coupled simulation and gradient-based work. The launch demos pair Steel with VBD cables, cloth, implicit MPM sand and VBD soft bodies through Newton's coupled solvers, and show an opt-in differentiable step used for drone model-predictive control plus an experimental smooth contact model used to optimise a ball's launch velocity. Both gradient features are marked Experimental. That supports trajectory optimisation and short-horizon control studies, provided the user remembers that a gradient of a solver is a gradient of that solver's model. JAX, Warp and MuJoCo document the execution substrates and the contact-model alternatives, and Python robotics covers connecting a policy to a controller.
8. Limitations and Failure Modes
The most common failure is treating throughput as physical fidelity. Every published figure measures environment steps per second under a fixed timestep and a defined task list; none measures contact accuracy, sim-to-real transfer or policy success. There is no independent blind benchmark in the launch material, and no third-party reproduction is claimed here. A policy trained on trajectories whose contact parameters, friction and actuator dynamics were never calibrated can converge quickly and still fail on hardware. Domain randomisation and system identification reduce that gap without closing it, and the physics simulation primer explains the modelling assumptions involved.
The second failure is dropping the measurement conditions. The single-task result depends on reuse_kinematics=True, an opt-in flag in Newton 1.8 that was not active in the heterogeneous runs because joint velocity limits were on. The 9.2 to 13.0 times ratios compare each engine at its own best batch size, while 12.0 times and the 62 percent memory saving are matched comparisons at 61,440 environments; writing all of them up as one universal speed-up would be a misreading. PhysX 6.0.0.0 ran the mixtures up to about 2.7 times faster than 6.1, so a baseline version change can move the ratio substantially. Cartpole remains a PhysX win under a truncated Steel sweep, and PhysX's 64K-material limit bounds some mixture curves. The classical solver cost boundary guide gives the discipline for recording these facts beside a result.
Version and platform risk is the third. All measurements used the Newton release-1.8 candidate 01ea1293, while the Newton releases page lists a v1.8.0 stable feature release dated 12 November 2026; a team deploying the stable build should re-run the benchmark rather than quote the candidate numbers. Warp 1.18 needs a Turing-class NVIDIA GPU and driver R580 or newer, older drivers require pinning warp-lang to 1.17.0, macOS is CPU-only, and Python 3.10 is deprecated with removal planned for Newton 1.9. The Warp entry covers the kernel-level consequences, and MuJoCo documents the separate caveats of the MuJoCo Warp backend.
Three more boundaries deserve attention. Differentiable stepping and smooth-contact gradients are labelled Experimental, and sleeping and islands appear as demonstrations; none is documented as a stable contract. Steel is the rigid side of Newton's coupled solver, so cloth, cables, sand and soft bodies are not Steel features. Licensing is granular: Apache-2.0 for Steel and Newton source, CC BY 4.0 for Newton documentation, third-party terms in newton/licenses, and BSD-3-Clause and MIT for robot models bundled with steel-webgpu. A deployment that reviews only the top-level licence has not finished its compliance work. Section 9 records the source of each statement, and the Skild AI company report gives the wider vendor risk picture.
9. Version and Source Notes
Record one: the launch article is titled Steel: Scaling Simulation Across Robots, Tasks, and Worlds, credited to the Skild Team in collaboration with NVIDIA and dated only "Nov 2026" in the article and the blog index. The skild-ai/steel README gives 9 November 2026 as the open-source launch, and NVIDIA's CoRL announcement places the release at the Conference on Robot Learning in Austin. NVIDIA spells the acronym STEEL in capitals; Skild's own materials use Steel. Both forms are recorded here without merging them. The name expands to Scalable Throughput-optimized Engine for Embodied Learning and has no connection to the material steel.
Record two: the user-supplied blog index URL is skild.ai/blogs/steel, while the Steel README links a launch write-up at skild.ai/steel and a playground at skild.ai/steel/playground. Both entry points appear in official materials; this entry uses the blog URL as its source and does not assert a redirect relationship. Record three: the standalone skild-ai/steel repository is described by the project as a home for the README, launch poster and licence; the implementation is in newton/_src/solvers/steel and the public class is newton.solvers.SolverSteel. Media coverage describing the repo as "mostly a README" is consistent with that structure. The Newton README also lists steel_sleeping and steel_determinism_arms as examples.
Record four: the measurement notes name the Newton release-1.8 candidate 01ea1293 for every benchmark, measured 7 to 9 November 2026. The Newton releases page lists v1.8.0 as a stable feature release dated 12 November 2026, with v1.7.0 on 14 October 2026 and v1.7.0rc1 and v1.7.0rc2 as the pre-releases. The benchmarks therefore describe a candidate, and this entry does not carry them over to the stable build as verified facts. Record five: reuse_kinematics=True is opt-in in Newton 1.8 and was used in the single-task suite; the heterogeneous suite had joint velocity limits on, so it was not active. The 3.8 times and the 9.2 to 13.0 times figures come from different solver configurations and are not combined.
Record six: 3.8 times is a geometric mean across 20 single-task benchmarks at each engine's best batch size; 13.0 times is a peak-throughput ratio on a 20-type mixture; 12.0 times and the 62 percent memory saving are matched comparisons at 61,440 environments. Media summaries frequently collapse these into a single "13 times" claim, which this entry does not do. Record seven: all throughput figures are simulation-only on one RTX PRO 6000 Blackwell, exclude observations, rewards and resets in the single-task suite, synchronise the device per step and are explicitly not end-to-end training speed. NVIDIA's separate 2.5 times training-throughput claim for Isaac Lab 3.0 with Newton is a different metric on a different benchmark.
Record eight: the Skild blog says Steel is intended to integrate with Isaac Lab; NVIDIA's CoRL announcement says Isaac Lab 3.0 can switch between PhysX and Newton solvers and describes Steel as built on Newton to accelerate robot training with Isaac Lab. The two statements are recorded side by side, and no production-grade integration depth is asserted. Record nine: licence layers are kept separate as stated in the Steel README, the Newton README and the steel-webgpu README, including the CC BY 4.0 documentation terms, third-party texts in newton/licenses and the BSD-3-Clause and MIT model terms.
Record ten: the Skild AI company report on this site predates Steel and states that the company's contribution lies in learning and control, that it depends on a third-party simulator and that it has no solver of its own. That framing was accurate for the period it covered and needs a date qualifier after 9 November 2026; this entry does not rewrite that report. The MuJoCo entry is the companion record for the engine whose Warp backend remains Newton's primary backend. All statements here were checked on 12 November 2026; a new Newton release should trigger a fresh pass over Sections 3, 6 and 8 before this entry is cited in a customer document.
10. References
- Skild AI, Steel: Scaling Simulation Across Robots, Tasks, and Worlds, skild.ai/blogs/steel, November 2026, including Sections 1 to 5 and the full Measurement notes with benchmark configurations.
- Skild AI, skild-ai/steel repository README, github.com/skild-ai/steel, 9 November 2026 open-source launch, Apache-2.0 licence and links to the Newton implementation, WebGPU port and playground.
- Newton Physics, newton-physics/newton repository README, Linux Foundation governance, founding partners, Warp 1.18 and Python requirements, example list including steel_sleeping and steel_determinism_arms, and licence layers.
- Skild AI, skild-ai/steel-webgpu repository README, WebGPU requirements, the three entry points of @skild-ai/steel-webgpu, Bun development workflow, newton_export.py and bundled model licences.
- Skild AI, Blog index, skild.ai/blogs, featuring the Steel article with a "Nov 2026" date alongside the S1 and Physical Self-Play entries.
- NVIDIA, Practice Makes Precise: At CoRL, NVIDIA and Partners Reveal How Robots Rehearse Delicate Work in Simulation, blogs.nvidia.com, 9 November 2026, Isaac Lab 3.0, the PhysX and Newton solver switch, the 2.5 times training-throughput figure and the STEEL announcement.
- Newton Physics, GitHub Releases page, github.com/newton-physics/newton/releases, v1.8.0 of 12 November 2026, v1.7.0 of 14 October 2026 and the v1.7.0rc1 and v1.7.0rc2 pre-releases.
- Newton Physics, CHANGELOG entries for 1.8.0 (12 November 2026) and 1.7.0 (14 October 2026), linked from the release notes.
- Skild AI, Introducing S1: In-Context Learning for Robotics, 18 August 2026, and Physical Self-Play, 23 September 2026, the pretraining and self-play context cited in the Steel article.
- AI Bacon, Skild AI Open-Sources Steel, a Physics Solver for Robots, 9 November 2026, secondary coverage of the launch, the release-candidate status and the benchmark configuration.
- The Inference, Skild AI open-sources its physics engine in Nvidia's Newton, November 2026, secondary coverage of the CoRL announcement and the 3.8 times to 13 times figures.
- This site, Skild AI company research report and MuJoCo tool entry, used for cross-entry reconciliation of the vendor and physics-engine context.