PYTHON · NUMPY

The industry agrees: structure-as-differentiation, at scale

See that the principle this course has built lesson by lesson — a physics-structured, differentiable model, identified and controlled by gradient — is the same bet three 2025–2026 efforts are placing at industrial and research scale: Newton (GPU differentiable physics, contributed to the Linux Foundation by Disney Research, Google DeepMind, and NVIDIA), gradient-based system identification on real robots using MJX, and OrbiSim's argument that a world model should itself be a differentiable physics engine rather than a generative video predictor.

01Challenge

Three results converged in the time since this course's capstone loop was designed, each making the identical bet: a model with the right physical structure is worth more, gradient for gradient, than one without it — and worth building at the scale of a GPU cluster as much as at the scale of a browser tab. Newton is a GPU-accelerated, differentiable physics engine co-developed by Disney Research, Google DeepMind, and NVIDIA and contributed to the Linux Foundation; it puts differentiable rigid-body and contact dynamics behind a standard robotics stack so that gradients propagate through contact the way they propagate through this course's tape. Two 2025–2026 papers take MJX — the differentiable rewrite of MuJoCo — and do exactly what the capstone's Stage 1 did: identify a plant's parameters from position/velocity trajectories, not torque sensors, but on real legged robots and real actuators. And OrbiSim argues a level further: a world model should not be a black box that hallucinates the next video frame, but should itself be a differentiable physics engine, so the model you learn is also a model you can verify and control by gradient — the same argument this course has made against black-box learners since Module 1, made independently, in an outside paper, of anything BMI wrote. None of that runs in a browser tab. The Bench below runs a small, honest echo instead: it identifies a nonlinear, non-conservative friction coefficient by differentiating a multi-step rollout against trajectory data — the same trajectory-matching idea the MJX papers run on hardware, at a scale small enough to read start to finish.

Predict firstA world model predicts the next video frame directly, pixel by pixel, from the current frame and an action — no explicit position, velocity, or mass anywhere inside it. Can it violate conservation of momentum during a predicted collision?

02Model

Newton (contributed to the Linux Foundation in September 2025, built on NVIDIA Warp and OpenUSD) exposes multiple solvers — Euler, Featherstone, XPBD, and others — behind one differentiable interface, so a simulation built on it inherits backprop-through-contact for free, the same way ferromotion's tape gives every lesson in this course a gradient. NVIDIA's own GTC 2026 benchmark reports Newton reaching 475× MuJoCo-XLA (MJX) on manipulation tasks and 252× on locomotion, on an RTX PRO 6000 Blackwell GPU. Read that number exactly as labeled: it is a vendor's own comparison, on its own new hardware, of raw simulation throughput — not an independently replicated figure, and not a claim about gradient accuracy or sim-to-real fidelity. What is not in question is the design choice underneath it: differentiable-by-construction physics, industrialized. Two papers ride the same idea on MJX directly, on real hardware. 'Achieving Precise and Reliable Locomotion with Differentiable Simulation-Based System Identification' (arXiv:2508.04696) folds identification into the RL training loop, fitting a legged robot's mass, inertia, and a neural friction correction from trajectories alone — no torque sensor — and reports a real-hardware 75% cut in rotational drift and a 46% gain in commanded-direction travel versus its RL baseline. 'Trajectory-based actuator identification via differentiable simulation' (arXiv:2604.10351) fits an effective actuator model straight from motion trajectories by backpropagating through MJX, closing the actuation gap without instrumenting the motor. Both are the capstone's Stage 1 — identify a plant by differentiating a rollout against data — run on a real robot instead of a simulated point mass. OrbiSim (arXiv:2605.16395, a May 2026 preprint, part of the NeoWorld project) makes the architectural case explicit: a generative video model predicting the next frame pixel-by-pixel has no obligation to conserve momentum or respect contact, while a world model built as a differentiable physics engine — explicit state, explicit dynamics, a renderer bolted on after — inherits the physics for free and stays a model you can identify and control by gradient. That is an external paper's claim, reached independently of this course; the honest note is that it converges with, rather than originates, the structure-as-differentiation thesis this course has been building since Module 1. The Bench's own numbers below are a ferromotion nano-simulation, run on your device for this lesson — illustrative of the method, not a claim of scale or of replicating any cited paper's hardware result.

03Guided practice

Step A (the wrong model): the Bench starts with a guessed friction coefficient c — the predicted trajectory (green) drifts away from the measured data (gold dots) as the rollout runs. Step B (differentiate the rollout): press Train. Each step, the tape rolls the nonlinear plant v̇ = (u − c·v·|v|)/m forward, accumulates a trajectory-matching loss against the data, and backpropagates through every timestep into c — exactly the method arXiv:2508.04696 and arXiv:2604.10351 run on real legged robots and real actuators. Step C (it converges): the predicted trajectory slides onto the measured one; the identified c approaches the true (nano, simulated) value to within the pass tolerance. Step D (the scale note): this Bench identified one nonlinear coefficient on a point mass on your CPU in a few hundred milliseconds; the cited papers ran the identical idea — gradient through a differentiable rollout, matched to trajectory data — on real hardware, and Newton and OrbiSim are building the substrate to run it at the scale of a fleet or a generative world model. The idea does not change size. The hardware under it does.

04Feedback

PASS WHEN PASS when differentiating the nonlinear rollout identifies the true friction coefficient and the predicted trajectory overlays the measured data — the nano version of what the cited papers run on real robots.

If your run fails, check:

Press Train: the gradient of the trajectory-matching loss flows back through every rollout step into the friction coefficient, the same way it does in the MJX system-ID papers.
Watch the predicted (green) trajectory slide onto the measured (gold) data as c converges — no torque sensor, no closed-form fit, only the gradient of a rollout.

05Retrieve & space

What is the one design principle Newton, the MJX system-identification papers, and OrbiSim all share with every lesson in this course — and what does 'structure-as-differentiation' mean as a one-sentence description of it?
Why is Newton's reported 475×/252× speedup over MJX a claim you should read carefully rather than repeat as a settled fact — whose benchmark is it, on whose hardware, and what does it measure?
What does OrbiSim argue is structurally different between a generative video world model and a world model built as a differentiable physics engine — and why does that argument belong to OrbiSim's paper, not to this course?

06Mastery & project

You identified a nonlinear plant by differentiating a rollout against trajectory data — the exact method, at nano scale, that two 2025–2026 papers run on real legged robots with MJX, and the same design bet that Newton is industrializing behind a GPU physics engine and that OrbiSim argues world models themselves should be built on. The idea you have practiced all course — give the learner physical structure, get a model you can differentiate — is not a classroom simplification. It is where three separate, well-resourced efforts landed in the same eighteen months.

The last lesson turns from what you build to what you build it ON — the real, adaptive, cross-fabric compute substrate under every Bench in this course, running live in your own tab right now.

GO FURTHER · THE LIVE PLAYGROUND

Newton — Linux Foundation announcement (Disney Research, Google DeepMind, NVIDIA) ↗ — the GPU-accelerated, differentiable physics engine this lesson's Newton claims are about — read the primary announcement, not just the benchmark writeups.
OrbiSim: World Models as Differentiable Physics Engines for Embodied Intelligence (arXiv:2605.16395) ↗ — external preprint, unreplicated by BMI — the source of this lesson's 'world models should be differentiable physics engines' claim.
Achieving Precise and Reliable Locomotion with Differentiable Simulation-Based System Identification (arXiv:2508.04696) ↗ — real-hardware MJX system identification from trajectories only — the capstone's Stage 1, on a real legged robot.
Trajectory-based actuator identification via differentiable simulation (arXiv:2604.10351) ↗ — the actuator-only version of the same idea — no torque sensor, gradient through MJX instead.
ferromotion-learn: nonlinear trajectory-matching system ID, in pure Rust ↗ — the nonlinear rollout and gradient you just trained, verified against a known friction coefficient.

← Learn in imagination Your device is a fabric →

PYTHON · NUMPY

The industry agrees: structure-as-differentiation, at scale

Live ferromotion-wasm: identify a nonlinear friction coefficient by differentiating a multi-step rollout against trajectory data — a nano echo, on your device, of the trajectory-matching system identification arXiv:2508.04696 and arXiv:2604.10351 run on real robots with MJX.

You read

the arrays and values already in scope

You change

the code you write in each cell

Fixed

the dataset and the checks that grade you