Back to Blog
Robotics Simulation
Newton Physics Engine: How NVIDIA, Google DeepMind & Disney Are Reshaping Sim-to-Real Robotics
Before a robot takes its first step in the real world, it's already walked millions of miles in simulation. Every grasp, every pivot, every recovery from a stumble—all rehearsed in a virtual environment where failure costs nothing. But here's the problem roboticists have wrestled with for years: what works in simulation often falls apart in reality.
This gap between virtual and physical has been the industry's persistent headache. Until now.
On September 29, 2025, something significant happened. The Linux Foundation announced that three industry giants—NVIDIA, Google DeepMind, and Disney Research—had contributed Newton, a next-generation physics engine, to the open-source community. This isn't just another physics library. It's a coordinated effort to fundamentally change how robots learn to navigate the physical world.
The Sim-to-Real Problem: Why Physics Simulation Matters
If you've ever trained a reinforcement learning policy for a robot, you know the drill. Millions of training iterations in simulation, then the moment of truth: deployment on real hardware. More often than not, the robot that performed flawlessly in simulation suddenly becomes clumsy, hesitant, or outright broken in the physical world.
This is the sim-to-real gap. It exists because:
- â—ŹReal-world friction isn't perfectly uniform
- â—ŹActuators don't respond exactly as modeled
- â—ŹSensor readings are noisy
- â—ŹContact dynamics are incredibly complex
- â—ŹMass properties drift over time
Traditional approaches address this through extensive domain randomization—training with deliberately imperfect physics to make policies robust. It works, but it's brute force. What if your simulator could simply be better?
That's Newton's promise.
What Exactly is Newton?
Newton is an open-source, GPU-accelerated physics engine designed specifically for robotics simulation. But calling it "just" a physics engine undersells its ambition.
Core Architecture
At its foundation is NVIDIA Warp—a Python framework for writing high-performance GPU kernels. Think of Warp as a bridge between Python's accessibility and CUDA's raw performance. On top of this foundation, Newton layers specialized solvers for different physics domains:
- â—ŹMuJoCo-Warp: Rigid body solver based on the proven MuJoCo physics model
- â—ŹVBD Solver: Cloth and deformable materials simulation
- â—ŹMPM Solver: Granular materials like sand, soil, and powders
- â—ŹDisney Kamino: Future integration for advanced material simulation
Key Capabilities
- â—ŹGPU-native parallelization: Run thousands of simulation environments simultaneously
- â—ŹDifferentiable physics: Gradients flow through the simulation, enabling gradient-based optimization
- â—ŹOpenUSD integration: Universal Scene Description for robot and environment modeling
- â—ŹMuJoCo compatibility: Existing MJCF files work directly with MuJoCo-Warp
The differentiability aspect deserves special attention. Traditional simulators are black boxes—you feed in actions, you get out states. With Newton, you can backpropagate through the entire physics simulation. This opens doors that were previously locked: direct policy gradient computation, system identification, and end-to-end trajectory optimization.
The Three Pillars: Why This Collaboration Matters
Newton didn't emerge from a single company's R&D lab. It's the result of deliberate collaboration between three organizations with distinct but complementary expertise.
NVIDIA: The GPU Acceleration Foundation
NVIDIA contributes Warp, the differentiable GPU simulation framework that serves as Newton's computational backbone. Miles Macklin, Eric Heiden, and Yashraj Narang from NVIDIA have been central to the engine's development.
Warp provides:
- â—ŹJIT compilation of Python to efficient GPU kernels
- â—ŹAutomatic differentiation via the Tape API
- â—ŹIntegration with PyTorch, JAX, and Paddle
Warp's value proposition is subtle but important: it lets researchers write simulation code in Python while achieving performance competitive with hand-written CUDA. This matters because the robotics community largely works in Python, and the friction of context-switching to C++/CUDA has historically slowed iteration cycles.
Google DeepMind: The MuJoCo Legacy
DeepMind's contribution centers on MuJoCo-Warp—a GPU-optimized reimplementation of the venerable MuJoCo physics engine. When DeepMind open-sourced MuJoCo in 2022, it was a watershed moment for robotics research. Now, MuJoCo-Warp takes that proven physics model and accelerates it massively.
The performance numbers are striking:
| Benchmark | vs MuJoCo MJX (JAX) |
|---|---|
| Humanoid Locomotion | faster |
| Manipulation Tasks | faster |
These benchmarks were measured on an NVIDIA RTX 4090. The speedup comes from Warp's native CUDA implementation, which is more tightly optimized for NVIDIA hardware than JAX's more general approach.
Disney Research: The Deformable Materials Experts
Disney Research brings expertise in soft body and cloth simulation—critical for tasks involving fabrics, deformable objects, and granular materials. Their contributions include work toward the Kamino solver and expertise in contact physics.
This makes sense if you think about Disney's needs: simulating realistic cloth for animated characters requires solving many of the same problems as robotic manipulation of fabrics.
Performance: The Numbers That Matter
Let's talk specifics. Speed matters in robotics simulation because training happens at scale. A speedup doesn't just save time—it changes what's possible.
Training a Quadruped Locomotion Policy
- â—Ź4,096 parallel environments on a single GPU
- â—Ź~4 hours to train a walking policy on RTX 4090
- â—Ź85,000-95,000 FPS throughput during training
For comparison, training the same policy on CPU-based MuJoCo would take days, not hours.
Dexterous Manipulation Performance
65% faster than NVIDIA PhysX for dexterous manipulation benchmarks. This matters because dexterous manipulation—think robot hands grasping varied objects—requires contact-rich physics that's traditionally expensive to simulate.
MuJoCo-Warp: A Closer Look
If you're familiar with the robotics simulation landscape, MuJoCo's name carries weight. Created by Emo Todorov and acquired by DeepMind, it's been the physics engine of choice for countless robotics research papers.
MuJoCo-Warp preserves what made MuJoCo great while unlocking GPU parallelization:
What Stays the Same
- â—ŹMJCF (MuJoCo XML) file format compatibility
- â—ŹContact physics model (soft convex, elliptic cone friction)
- â—ŹIntegration with existing MuJoCo ecosystem tools
What Changes
- â—ŹRuns on GPU via NVIDIA Warp
- â—ŹSupports massive parallelization (thousands of environments)
- â—ŹFully differentiable
Key Insight:
The backward compatibility is crucial. Teams with existing MuJoCo-based projects can migrate to MuJoCo-Warp without rewriting their simulation assets. The joint maintenance by Google DeepMind and NVIDIA signals long-term commitment.
Neural Robot Dynamics: When Physics Meets Learning
One of Newton's most forward-looking features is NeRD (Neural Robot Dynamics), a neural simulation framework that uses learned models to predict robot dynamics.
The concept is elegant: instead of solving analytical physics equations at every timestep, train a neural network to predict the next state. This learned simulator can then be fine-tuned with real-world data, effectively bridging the sim-to-real gap.
How NeRD Works
- 1Training Data Generation: 100K random trajectories per robot, 100 timesteps each
- 2Architecture: Causal transformer (lightweight GPT-2 implementation)
- 3Input: 10-step context window with robot state, contact info, joint torques
- 4Output: Predicted next state
Demonstrated Results
- â—ŹPolicies trained exclusively in NeRD achieve <0.1% error vs analytical simulator
- â—ŹSuccessful zero-shot transfer to real 7-DoF Franka robot arm
- â—ŹFine-tuning with real-world data significantly improves accuracy
The vision is compelling: imagine a robot equipped with a neural dynamics model that continuously improves through real-world operation. As the robot's joints wear or environmental conditions change, the learned simulator adapts. It's a self-improving digital twin.
Sim-to-Real Success Stories
Theory is one thing. Deployment is another. Let's look at how these simulation capabilities translate to actual robots in the physical world.
Boston Dynamics Spot: Quadruped Locomotion
NVIDIA's Isaac Lab team demonstrated zero-shot sim-to-real transfer to Boston Dynamics' Spot robot using the exact workflow Newton enables.
Training Configuration
- â—ŹTask: Track target x, y, and yaw base velocities on flat terrain
- â—ŹNetwork: MLP [512, 256, 128] neurons
- â—ŹAlgorithm: PPO with RSL-rl library
- â—ŹTraining: 15,000 iterations, ~4 hours on RTX 4090
Domain Randomization Applied
- â—ŹRobot mass variations ()
- â—ŹSurface friction randomization
- â—ŹRandom push disturbances
- â—ŹSensor noise injection
Deployment
- â—ŹPolicy exported to ONNX format
- â—ŹInference on NVIDIA Jetson AGX Orin
- â—ŹReal-time control via Boston Dynamics API
The result? The robot walks successfully in the real world without any real-world training data. Zero-shot transfer.
Industrial Assembly: Contact-Rich Manipulation
Perhaps more impressive is the industrial assembly demonstration using Isaac Lab.
The Challenge: Gear assembly—a contact-rich task requiring precise grasp generation, free-space motion planning, and insertion with continuous contact.
The Solution: RL-trained policies using LSTM + MLP architecture, 60 Hz joint position control, custom impedance controller for compliance, and domain randomization across robot dynamics, controller gains, and object geometry.
Key Insight:
The result is zero-shot sim-to-real transfer for contact-rich manipulation—one of the hardest problems in robotic assembly.
Domain Randomization: The Bridge Builder
Newton's speed enables aggressive domain randomization—the practice of deliberately varying simulation parameters to create robust policies.
| Category | Parameters |
|---|---|
| Physics | Mass, friction, damping, joint stiffness |
| Dynamics | Actuator characteristics, time delays, control frequency |
| Sensors | Position noise, velocity noise, measurement delays |
| Environment | Object poses, terrain variations, disturbances |
Best Practice: Curriculum Learning
Rather than throwing everything at the policy from the start:
- 1Stage 1: No randomization (establish baseline)
- 2Stage 2: Small physics variations
- 3Stage 3: Add sensor noise
- 4Stage 4: External disturbances
- 5Stage 5: Full randomization
Newton's parallel simulation capability makes this practical. You can evaluate thousands of randomized scenarios simultaneously, building robust policies in hours instead of weeks.
The Competitive Landscape
Newton doesn't exist in a vacuum. Let's situate it against alternatives.
Newton vs. Genesis
Genesis represents a different philosophy—a ground-up physics platform built on Taichi that prioritizes cross-platform GPU support over NVIDIA optimization. Its claimed 43 million FPS for Franka arm simulation suggests aggressive performance focus, though benchmark comparisons across different engines are notoriously difficult to normalize.
| Aspect | Newton | Genesis |
|---|---|---|
| Backend | NVIDIA Warp (CUDA) | Taichi (multi-platform) |
| GPU Support | NVIDIA-optimized | NVIDIA, AMD, Apple |
| MuJoCo Compatibility | Native (MuJoCo-Warp) | MJCF import |
| Governance | Linux Foundation | Independent |
| Key Backers | NVIDIA, DeepMind, Disney | Academic consortium |
Newton's advantages: Native MuJoCo compatibility, Linux Foundation governance, tighter NVIDIA integration.
Genesis advantages: Multi-platform GPU support, potentially higher raw FPS numbers.
Newton vs. Traditional MuJoCo
If you're already using MuJoCo, why switch to MuJoCo-Warp?
- â—ŹSpeed: faster on GPU vs MJX
- â—ŹDifferentiability: Full gradient support via Warp autodiff
- â—ŹParallelization: 4,096+ environments vs 1-8 with CPU threading
The trade-off: CPU-based MuJoCo remains easier to debug and doesn't require GPU hardware.
Newton vs. PhysX/Isaac Sim
NVIDIA's own PhysX powers Isaac Sim. Why does NVIDIA also support Newton?
PhysX/Isaac Sim strengths: Full rendering pipeline, Omniverse ecosystem integration, industrial digital twin applications.
Newton strengths: Faster for RL training (65% faster for dexterous manipulation), differentiable physics, better MuJoCo compatibility for research workflows.
Key Insight:
Think of Newton as optimized for policy training, while PhysX/Isaac Sim excels at full-stack digital twin applications.
Beyond Rigid Bodies: Cloth, Fluids, and Granular Materials
Robotics isn't just about rigid body dynamics. Real-world manipulation involves fabrics, granular materials, and deformables.
VBD Solver (Variational Boundary Dynamics)
Contributed by Style3D, the VBD solver handles cloth and thin-shell simulation:
- â—ŹReal-time cloth at 60+ FPS
- â—ŹSelf-collision handling
- â—ŹFriction modeling
- â—ŹImplicit time integration
Application: Robot folding laundry—cloth modeled with VBD, gripper contact simulated, folding sequence planned.
MPM Solver (Material Point Method)
A hybrid Lagrangian-Eulerian method for:
- â—ŹGranular materials (sand, gravel, powder)
- â—ŹFluids (water, viscous liquids)
- â—ŹSoft bodies (rubber, foam)
Application: Robot scooping soil—particles modeled with MPM, shovel as rigid body, particle-rigid coupling for force feedback.
Physical AI: The Bigger Picture
Newton fits into a larger trend NVIDIA calls "Physical AI"—the $50 trillion opportunity Jensen Huang highlighted at GTC 2025.
Newton provides the physics backbone for training robot foundation models—large pre-trained models for robotics analogous to LLMs for language.
Why Physics Simulation is Critical for Foundation Models
- 1Massive Data Generation: Billions of robot interactions without real-world cost
- 2Diverse Scenarios: Domain randomization at scale
- 3Safe Training: No robot damage during learning
- 4Gradient Signal: Differentiable physics for efficient learning
NVIDIA Cosmos world foundation models integrate with Newton—physics-based world generation for synthetic training data.
Key Insight:
Newton isn't just a simulation tool. It's infrastructure for the next generation of robot AI.
Getting Started with Newton
For teams considering Newton, here's the practical entry point.
Requirements
- â—ŹPython 3.9+
- â—ŹNVIDIA GPU (GeForce GTX 9xx or newer)
- â—ŹCUDA Toolkit 12.0+
- â—ŹNVIDIA Driver 525+
Key Resources
| Resource | Link |
|---|---|
| Newton GitHub | github.com/newton-physics/newton |
| NVIDIA Warp | github.com/NVIDIA/warp |
| MuJoCo-Warp | github.com/google-deepmind/mujoco_warp |
| Isaac Lab | developer.nvidia.com/isaac/lab |
| NeRD | github.com/NVlabs/neural-robot-dynamics |
Migration Path
If you're coming from existing workflows:
- â—ŹFrom MuJoCo: MJCF files work directly; wrap training loops with Warp
- â—ŹFrom Isaac Gym: Similar parallel environment paradigm; different physics backend
- â—ŹFrom PyBullet: More significant changes; consider asset conversion to MJCF first
What This Means for the Industry
The Linux Foundation governance model is significant. By placing Newton under neutral governance:
- â—ŹVendor neutrality: Multiple contributors share trust
- â—ŹLong-term sustainability: Project survives any single company's priorities
- â—ŹBroader adoption: Permissive Apache 2.0 license enables commercial use
Early Ecosystem Partners
- â—ŹETH Zurich Robotic Systems Lab (RSL)
- â—ŹPeking University (Taccel)
- â—ŹStyle3D
- â—ŹTUM AIDX Lab
- â—ŹLightwheel AI
This isn't a proprietary tool you license. It's infrastructure you can build on, modify, and extend.
Our Perspective
At Robolabs AI, we've worked extensively with NVIDIA Isaac Sim, MuJoCo, and various simulation frameworks across robotics projects. Newton represents a meaningful shift in what's possible.
What Excites Us
- 1Training time reduction: Hours instead of days changes iteration velocity
- 2Differentiable physics: Opens gradient-based optimization pathways we've previously approximated
- 3MuJoCo compatibility: Existing assets and workflows migrate cleanly
- 4Open governance: We can build production systems without licensing uncertainty
What We're Watching
- 1Stability: Newton is still in alpha/beta; production deployments need careful evaluation
- 2Community growth: Ecosystem tools and integrations are still emerging
- 3Multi-solver coupling: Rigid-soft-fluid interactions need more development
For teams doing sim-to-real robotics—whether it's mobile manipulation, quadruped locomotion, or industrial assembly—Newton warrants serious evaluation. The collaboration between NVIDIA, DeepMind, and Disney suggests this isn't a side project; it's a strategic investment in robotics infrastructure.
The sim-to-real gap won't close overnight. But with physics engines like Newton, we're getting meaningfully closer to robots that learn in simulation and perform in reality.
Key Takeaways
- â—ŹNewton is a GPU-accelerated, differentiable physics engine for robotics, contributed to the Linux Foundation by NVIDIA, Google DeepMind, and Disney Research (September 2025)
- â—ŹPerformance: faster than MuJoCo MJX for humanoid locomotion, faster for manipulation tasks on RTX 4090
- â—ŹMuJoCo-Warp brings GPU acceleration to the proven MuJoCo physics model with full MJCF compatibility
- ●Differentiable physics enables gradient-based optimization for robot learning—backpropagate through the simulation itself
- â—ŹNeRD (Neural Robot Dynamics) offers learned simulation that can be fine-tuned with real-world data
- â—ŹMulti-solver architecture handles rigid bodies, cloth (VBD), and granular materials (MPM)
- â—ŹOpen governance under Linux Foundation ensures vendor neutrality and long-term sustainability
References & Further Reading
Subscribe to Our Blog
Get the latest insights on robotics and AI delivered to your inbox.
No spam. Unsubscribe anytime.
Ready to Build Something Impactful?
Let's discuss how our team can help bring your AI and robotics vision to life.