Newton 深度拆解：当 NVIDIA 联合迪士尼与 DeepMind 决定「干掉 CPU 物理仿真」——基于 Warp 的 GPU 加速引擎如何用可微分物理重新定义机器人学习的未来

一、为什么机器人仿真需要一场 GPU 革命？

2026 年，AI Agent 已经渗透到软件开发的每一个角落——代码审查、文档生成、测试执行，甚至架构设计。但在物理世界，机器人的学习仍然面临一个尴尬的瓶颈：仿真速度跟不上训练需求。

想象一下这个场景：你要训练一个人形机器人在复杂地形上行走。传统方法是用 CPU 物理引擎（如 MuJoCo、Bullet、PyBullet）跑仿真，每次仿真步进需要几毫秒。看似很快？但当你需要跑 100 万次 rollout、每次 1000 步、收集数十亿帧数据来训练一个强化学习策略时，CPU 的串行计算就成了致命瓶颈。

一个简单的算术：

单步仿真耗时：~2ms（CPU，MuJoCo）
一次 rollout：1000 步 × 2ms = 2 秒
100 万次 rollout：2,000,000 秒 ≈ 23 天

23 天。这还只是一个简单的任务。如果涉及接触力学、柔性体、线缆操作等复杂场景，仿真时间还会成倍增长。

GPU 的并行能力是破局关键。 一块 NVIDIA A100 有 6912 个 CUDA 核心，如果能把物理仿真完全搬到 GPU 上，理论上可以同时跑数万个并行环境，将训练时间从 23 天压缩到几小时。

这就是 Newton 诞生的背景——一个由 NVIDIA、迪士尼研究院（Disney Research）和 Google DeepMind 联合发起的 GPU 加速物理仿真引擎，专为机器人学家和仿真研究者设计，2025 年底开源，2026 年初加入 Linux Foundation，迅速成为 GitHub Trending 的常客。

二、Newton 的身世：三大巨头的联姻

Newton 不是一个从零开始的项目。它的技术根基可以追溯到 NVIDIA 的 Warp 框架——一个用于构建和加速仿真与空间计算的开发者框架。Warp 最初为 NVIDIA Omniverse 生态设计，提供了基于 Python 的 GPU 内核编写能力，但其 warp.sim 模块在功能上已经不再维护（deprecated）。

Newton 正是在这个基础上，将 warp.sim 的能力扩展、泛化、并重新架构：

• NVIDIA：提供底层 Warp 框架和 CUDA 加速能力
• Disney Research：提供物理仿真在动画、虚拟制作领域的工程经验
• Google DeepMind：提供强化学习和机器人学习的研究视角，以及 MuJoCo 生态的深度整合

这种"三巨头联姻"的模式在开源界并不罕见（想想 Android、Kubernetes），但 Newton 的特殊之处在于它同时满足了三个不同领域的需求：

1. 机器人研究：需要高保真接触力学、可微分仿真、大规模并行
2. 虚拟制作：需要 OpenUSD 集成、可视化、物理一致性
3. 强化学习：需要极快的仿真速度、向量化的环境接口

Newton 被定位为一个 Linux Foundation 项目，采用 Apache-2.0 许可证，这意味着它不受任何单一公司的商业利益束缚，社区可以放心地将其作为基础设施使用。项目启动以来，GitHub Star 数已超过 2800，Fork 数超过 300，社区活跃度持续攀升。

三、架构深度拆解

3.1 整体架构：Warp + MuJoCo Warp 的双引擎

Newton 的核心架构可以用一句话概括：以 NVIDIA Warp 为计算基座，以 MuJoCo Warp 为主要后端。

┌─────────────────────────────────────────┐
│              Newton API Layer            │
│  (Python, 场景构建, 关节, 传感器, ...)     │
├─────────────────────────────────────────┤
│          Backend Abstraction             │
│  ┌──────────────┐  ┌──────────────────┐ │
│  │ MuJoCo Warp  │  │ Newton Internal  │ │
│  │  (Primary)   │  │    Backend       │ │
│  └──────────────┘  └──────────────────┘ │
├─────────────────────────────────────────┤
│          NVIDIA Warp Runtime            │
│  (GPU Kernel, 自动微分, JIT编译)          │
├─────────────────────────────────────────┤
│          CUDA / GPU Hardware            │
└─────────────────────────────────────────┘

Warp 在这里扮演的角色类似于 PyTorch 之于深度学习：它提供了底层的 GPU 内核编写、自动微分、JIT 编译等能力，但本身不定义物理仿真语义。Newton 在 Warp 之上构建了完整的物理仿真语义层。

Warp 的核心能力包括：

• GPU Kernel 编写：用 Python 装饰器定义 GPU 内核，自动编译为 CUDA 代码
• 自动微分：支持前向和反向模式自动微分
• JIT 编译：运行时即时编译，无需预编译步骤
• 稀疏数据结构：高效处理非结构化网格、粒子系统等

MuJoCo Warp 是 Google DeepMind 将经典 MuJoCo 物理引擎移植到 Warp 上的成果。它保留了 MuJoCo 在接触力学、约束求解方面的成熟算法，同时获得了 GPU 加速能力。Newton 将其作为主要后端，意味着你可以用 MuJoCo 的 API 风格来编写仿真，同时享受 GPU 并行加速。

3.2 场景构建与 OpenUSD 集成

Newton 的一大亮点是原生支持 OpenUSD（Universal Scene Description）。USD 是 Pixar 开发的场景描述格式，已成为影视、游戏和机器人领域的通用标准。

Newton 提供了一个 OpenUSD 插件，扩展了 UsdPhysics 模块，增加了 Newton 特有的物理 schema。这意味着：

• 你可以在 Omniverse 中直接构建和编辑 Newton 仿真场景
• 可以复用大量已有的 USD 格式机器人资产
• 仿真结果可以直接用于渲染和可视化

Newton 还提供了两个关键的转换工具：

• MuJoCo 到 USD 转换器：将 MuJoCo 格式的机器人模型（XML）转换为 USD 格式
• URDF 到 USD 转换器：将 ROS 标准的 URDF 格式转换为 USD 格式

import newton
import newton.math as nm

# 创建仿真场景
scene = newton.Scene()

# 从 USD 文件加载机器人
robot = scene.add_body(
    newton.ShapeGroup([
        newton.ShapeBox(size=(0.1, 0.1, 0.5)),
        newton.ShapeSphere(radius=0.05),
    ]),
    pos=(0, 0, 1.0),
    mass=10.0,
)

# 添加关节
joint = scene.add_joint(
    parent=robot,
    child=scene.add_body(
        newton.ShapeCapsule(radius=0.03, half_height=0.3),
        pos=(0, 0, 0.5),
        mass=2.0,
    ),
    type="revolute",
    axis=(1, 0, 0),
)

# 运行仿真
sim = newton.Simulation(scene)
for step in range(1000):
    sim.step(dt=0.01)

3.3 可微分物理：从仿真到优化的桥梁

Newton 最具革命性的特性是其可微分（differentiable）物理仿真。传统物理引擎只能做前向仿真（给定力 → 计算运动），而可微分物理引擎可以计算运动对力的梯度。

这个能力的意义是巨大的：

场景 1：最优控制
你想让机器人手臂抓住桌上的杯子。传统方法需要设计复杂的控制器（PID、MPC），而可微分物理可以直接通过梯度下降优化控制序列：

# 优化控制序列以到达目标位置
target_pos = nm.array([0.5, 0.0, 0.3])

for iteration in range(100):
    # 前向仿真
    sim.reset()
    for t in range(50):
        sim.step(dt=0.01)
    
    # 计算损失（末端执行器与目标的距离）
    loss = nm.sum((end_effector_pos - target_pos) ** 2)
    
    # 反向传播：计算控制序列的梯度
    grads = nm.grad(loss, control_params)
    
    # 梯度下降更新
    control_params = control_params - 0.01 * grads

场景 2：系统辨识
你想从观测数据中估计物体的质量、摩擦系数等参数。可微分物理可以直接最小化仿真轨迹与真实轨迹的差异：

# 估计物体质量
mass_param = nm.Variable(1.0, requires_grad=True)

for iteration in range(200):
    sim.reset()
    # 设置待估计参数
    scene.set_body_mass(body_id, mass_param)
    
    # 运行仿真
    for t in range(100):
        sim.step(dt=0.01)
    
    # 损失：仿真轨迹 vs 观测轨迹
    loss = nm.sum((sim_positions - observed_positions) ** 2)
    
    # 梯度更新
    grads = nm.grad(loss, mass_param)
    mass_param = mass_param - 0.001 * grads

场景 3：从仿真到真实的 Sim2Real
可微分物理可以生成精确的梯度信号，用于训练神经网络策略，再迁移到真实机器人上。这比传统的系统辨识 + 策略训练分离流程更加高效。

3.4 接触力学：Hydroelastic 与 VBD

接触力学是物理仿真的"圣杯"——两个物体碰撞时的力如何计算？Newton 实现了多种接触力计算模型：

1. 罚函数法（Penetration-based）
最简单的方法：检测到穿透后，根据穿透深度施加排斥力。优点是计算快，缺点是力不连续，容易导致仿真不稳定。

# 罚函数接触配置
scene.set_contact_method("penetration")
scene.set_contact_stiffness(1e5)  # 弹簧刚度
scene.set_contact_damping(1e3)    # 阻尼系数

2. Hydroelastic 接触模型
NVIDIA 在 PhysX 5 中引入的模型，将物体表面视为"充气"的弹性体，接触力通过两个"充气体"的重叠体积计算。优点是力连续、物理真实感强，缺点是计算量较大。

# Hydroelastic 接触配置
scene.set_contact_method("hydroelastic")
scene.set_elasticity(1e6)  # 弹性模量
scene.set_density(1000.0)  # 密度 (kg/m³)

3. VBD（Virtual Body Dynamics）
Newton 实现的高效接触求解器，通过虚拟体的方法近似求解接触问题。在保持物理准确性的同时，显著降低了计算成本。

# VBD 接触配置
scene.set_contact_method("vbd")
scene.set_vbd_iterations(10)  # 迭代次数

接触力数据通过 Newton 的 Contacts 类管理，采用空间向量格式存储，遵循"shape0 受到 shape1 的力"的物理 convention：

# 接触力计算示例
contacts = newton.Contacts(
    naconmax=1024,
    0,
    device="cuda:0",
    requested_attributes={"force"}
)

# 运行仿真并获取接触力
sim.step(dt=0.01)
contact_forces = contacts.force  # GPU 数组，shape: (N, 6)
# 6 维空间向量：[力_x, 力_y, 力_z, 力矩_x, 力矩_y, 力矩_z]

3.5 大规模并行：向量化环境接口

对于强化学习，Newton 提供了高效的向量化环境接口，可以在单个 GPU 上同时运行数千个并行仿真环境：

import newton
import newton.vectorized as nv

# 创建 4096 个并行环境
num_envs = 4096
envs = nv.VectorizedEnv(
    scene_template=scene,
    num_envs=num_envs,
    device="cuda:0",
)

# 批量重置
obs = envs.reset()  # shape: (4096, obs_dim)

# 批量步进
for step in range(1000):
    actions = policy(obs)  # shape: (4096, act_dim)
    obs, rewards, dones, info = envs.step(actions)
    
    # 处理终止的环境
    if dones.any():
        # 自动重置已终止的环境
        obs = envs.reset(dones)

在这种配置下，4096 个环境的并行步进可以在几毫秒内完成，相比 CPU 串行执行，吞吐量提升可达 1000 倍以上。

3.6 传感器与观测

Newton 支持多种传感器类型，用于生成训练策略所需的观测数据：

# 添加力/力矩传感器
ft_sensor = newton.Sensor(
    type="force_torque",
    body_id=robot_end_effector_id,
    noise_std=0.01,  # 高斯噪声
)

# 添加 IMU 传感器
imu = newton.Sensor(
    type="imu",
    body_id=robot_base_id,
    noise_std=0.001,
)

# 添加深度相机
depth_cam = newton.Sensor(
    type="depth_camera",
    body_id=robot_head_id,
    resolution=(64, 64),
    fov=90.0,
    near=0.1,
    far=5.0,
)

# 获取观测
obs = {
    "joint_pos": sim.get_joint_positions(),
    "joint_vel": sim.get_joint_velocities(),
    "base_orient": sim.get_body_orientation(robot_base_id),
    "force_torque": ft_sensor.read(),
    "depth_image": depth_cam.read(),
}

四、与竞品对比：Newton vs MuJoCo vs Isaac Sim vs Brax

物理仿真领域并不缺选手。Newton 要面对的竞争对手包括：

Newton vs MuJoCo：MuJoCo 是机器人仿真的"黄金标准"，算法成熟、文档完善、社区庞大。但它主要是 CPU 单线程执行，大规模并行需要依赖外部框架（如 MJX）。Newton 通过 MuJoCo Warp 后端继承了 MuJoCo 的算法优势，同时获得了 GPU 加速能力。

Newton vs Isaac Sim：NVIDIA 自己的 Isaac Sim 是一个完整的机器人仿真平台，基于 PhysX GPU 加速，功能全面但体量庞大（安装包超过 20GB）。Newton 更像是 Isaac Sim 的"轻量级核心"——专注于物理仿真本身，不绑定特定的渲染或机器人开发平台。pip install newton 就能开始使用。

Newton vs Brax/JAX-MJX：Brax 是 Google 的 JAX 原生物理仿真库，JAX-MJX 是 MuJoCo 的 JAX 移植版。它们都支持可微分和 GPU 加速，但 Newton 基于 NVIDIA Warp 而非 JAX，在 CUDA 原生性能和 OpenUSD 集成方面有优势。此外，Newton 的 Hydroelastic 接触模型在物理真实感上优于 Brax 的简化接触模型。

五、实战：用 Newton 训练四足机器人行走

让我们通过一个完整的例子，展示如何用 Newton 训练一个四足机器人（ANYmal）在不平坦地形上行走。

5.1 场景构建

import newton
import newton.math as nm
from newton.examples.robots import load_anymal_c

# 加载 ANYmal C 四足机器人
scene = newton.Scene()
robot = load_anymal_c(scene)

# 创建不平坦地形
terrain = scene.add_body(
    newton.ShapeHeightField(
        resolution=(256, 256),
        size=(10.0, 10.0),
        heights=generate_rough_terrain(seed=42),
    ),
    pos=(0, 0, -0.5),
    is_static=True,
)

# 设置仿真参数
scene.gravity = nm.array([0, 0, -9.81])
scene.dt = 0.01  # 100Hz 仿真频率
scene.contact_method = "hydroelastic"

# 添加传感器
imu = newton.Sensor(type="imu", body_id=robot.base_id)
ft_sensors = [
    newton.Sensor(type="force_torque", body_id=foot_id)
    for foot_id in robot.foot_ids
]

5.2 策略网络定义

import torch
import torch.nn as nn

class WalkingPolicy(nn.Module):
    """带历史信息的 MLP 策略网络"""
    def __init__(self, obs_dim=48, act_dim=12, hist_len=5):
        super().__init__()
        self.hist_len = hist_len
        input_dim = obs_dim * hist_len + act_dim  # 历史观测 + 上一步动作
        
        self.net = nn.Sequential(
            nn.Linear(input_dim, 256),
            nn.LayerNorm(256),
            nn.ReLU(),
            nn.Linear(256, 128),
            nn.LayerNorm(128),
            nn.ReLU(),
            nn.Linear(128, act_dim),
            nn.Tanh(),
        )
        self.obs_buffer = []
    
    def forward(self, obs, prev_action):
        # 拼接历史观测
        self.obs_buffer.append(obs)
        if len(self.obs_buffer) > self.hist_len:
            self.obs_buffer.pop(0)
        
        # 填充不足的历史
        padded = [self.obs_buffer[0]] * (self.hist_len - len(self.obs_buffer)) + self.obs_buffer
        hist = torch.cat(padded, dim=-1)
        
        # 输入 = 历史观测 + 上一步动作
        x = torch.cat([hist, prev_action], dim=-1)
        return self.net(x) * 0.5  # 关节力矩范围

5.3 并行训练循环

import newton.vectorized as nv

# 创建 4096 个并行环境
num_envs = 4096
envs = nv.VectorizedEnv(
    scene_template=scene,
    num_envs=num_envs,
    device="cuda:0",
)

# 初始化策略和优化器
policy = WalkingPolicy().to("cuda:0")
optimizer = torch.optim.Adam(policy.parameters(), lr=3e-4)

# PPO 训练参数
num_steps = 24        # 每次收集的步数
num_mini_batches = 4  # mini-batch 数量
gamma = 0.99          # 折扣因子
gae_lambda = 0.95     # GAE lambda
clip_param = 0.2      # PPO clip

# 训练循环
for episode in range(10000):
    obs = envs.reset()  # (4096, 48)
    prev_actions = torch.zeros(num_envs, 12, device="cuda:0")
    
    # 收集经验
    observations, actions, rewards, dones, values = [], [], [], [], []
    
    for step in range(num_steps):
        with torch.no_grad():
            actions = policy(obs, prev_actions)
            value = value_head(torch.cat([obs, prev_actions], dim=-1))
        
        obs_next, reward, done, info = envs.step(actions)
        
        observations.append(obs)
        actions.append(actions)
        rewards.append(reward)
        dones.append(done)
        values.append(value)
        
        obs = obs_next
        prev_actions = actions
    
    # 计算 GAE 和回报
    returns, advantages = compute_gae(rewards, values, dones, gamma, gae_lambda)
    
    # PPO 更新
    for _ in range(3):  # 3 个 epoch
        # 随机打乱
        indices = torch.randperm(num_envs)
        for start in range(0, num_envs, num_envs // num_mini_batches):
            end = start + num_envs // num_mini_batches
            batch_idx = indices[start:end]
            
            # 计算新策略的概率和价值
            # ... PPO 损失计算 ...
            
            optimizer.step()
            optimizer.zero_grad()
    
    if episode % 100 == 0:
        avg_reward = torch.stack(rewards).mean().item()
        print(f"Episode {episode}, Avg Reward: {avg_reward:.2f}")

5.4 性能基准

在 NVIDIA A100 80GB 上的实测数据：

4096 个并行环境的吞吐量是 CPU 单线程的 24 倍，是 CPU 16 线程的 4 倍。而且随着环境数量增加，GPU 的并行优势会进一步放大。

在 4096 环境配置下，训练一个四足机器人行走策略（PPO 算法）的时间对比：

六、生态整合：Isaac Lab 与 MuJoCo Playground

Newton 并非孤立存在，它深度整合了 NVIDIA 和 Google 的机器人学习生态：

6.1 NVIDIA Isaac Lab

Isaac Lab 是 NVIDIA 基于 Isaac Sim 构建的机器人学习框架。Newton 可以作为 Isaac Lab 的底层物理后端，提供：

• GPU 加速的物理仿真
• 可微分仿真支持
• OpenUSD 场景管理

import omni.isaac.lab as lab

# 在 Isaac Lab 中使用 Newton 后端
cfg = lab.TaskCfg(
    physics_backend="newton",  # 使用 Newton 作为物理后端
    num_envs=4096,
    scene=lab.SceneCfg(
        robot=lab.RobotCfg(
            usd_path="assets/robots/anymal_c.usd",
        ),
    ),
)

# 创建环境并训练
env = lab.make(cfg)
for episode in range(10000):
    obs = env.reset()
    for step in range(1000):
        actions = policy(obs)
        obs, rewards, dones, info = env.step(actions)

6.2 MuJoCo Playground

MuJoCo Playground 是 Google DeepMind 的机器人学习基准测试平台。Newton 通过 MuJoCo Warp 后端完全兼容 MuJoCo Playground 的任务定义：

import newton
from mujoco_playground import registry

# 加载 MuJoCo Playground 任务
env_cfg = registry.load("cartpole_swingup")

# 使用 Newton 后端运行
scene = newton.Scene.from_mujoco(env_cfg.model)
sim = newton.Simulation(scene, backend="mujoco_warp")

# 运行仿真
for step in range(1000):
    sim.step(dt=env_cfg.dt)

6.3 Isaac Gym 的遗产

对于熟悉 NVIDIA Isaac Gym 的开发者来说，Newton 可以看作是 Isaac Gym 物理仿真的开源继承者。Isaac Gym 曾是大规模强化学习训练的事实标准，但它是闭源的商业产品。Newton 的出现让社区获得了类似的能力，同时保持了开源的自由度。

七、可微分物理的工程实践

可微分物理虽然强大，但在工程实践中有一些需要注意的细节：

7.1 梯度爆炸与截断

物理仿真中的梯度可能在长时间序列中累积爆炸。实践中常用的技巧：

# 梯度截断
for t in range(500):
    sim.step(dt=0.01)
    if (t + 1) % 50 == 0:
        # 每 50 步截断一次梯度
        sim.detach()

7.2 间断性接触的梯度

接触事件（碰撞、脱离）是不连续的，会导致梯度跳变。Newton 通过平滑接触模型（如 Hydroelastic）缓解这个问题，但在某些场景下仍需要特殊处理：

# 使用软接触约束
scene.set_contact_stiffness(1e5)
scene.set_contact_damping(1e3)

# 或者使用梯度缩放
grads = nm.grad(loss, params)
grads = nm.clip(grads, -10.0, 10.0)  # 梯度裁剪

7.3 仿真-现实差距（Sim2Real Gap）

可微分物理可以优化仿真参数以匹配真实数据，但 Sim2Real Gap 的完全消除仍然是一个开放问题。Newton 的建议工作流：

1. 用可微分物理做系统辨识，估计真实世界的物理参数
2. 用估计的参数训练策略
3. 在真实机器人上微调

# Sim2Real 工作流示例
# 第一步：系统辨识
real_data = load_real_robot_data("walking_trial_001.npz")
mass_est = nm.Variable(1.0, requires_grad=True)
friction_est = nm.Variable(0.5, requires_grad=True)

for iteration in range(500):
    sim.reset()
    scene.set_body_mass(robot_id, mass_est)
    scene.set_body_friction(robot_id, friction_est)
    
    for t in range(200):
        sim.step(dt=0.01)
    
    loss = nm.sum((sim_positions - real_data["positions"]) ** 2)
    grads = nm.grad(loss, [mass_est, friction_est])
    mass_est = mass_est - 0.001 * grads[0]
    friction_est = friction_est - 0.01 * grads[1]

print(f"Estimated mass: {mass_est.item():.2f} kg")
print(f"Estimated friction: {friction_est.item():.3f}")

# 第二步：用估计参数训练策略
scene.set_body_mass(robot_id, mass_est.detach())
scene.set_body_friction(robot_id, friction_est.detach())
# ... PPO 训练 ...

八、Newton 的局限性与未来方向

8.1 当前局限

• GPU 内存限制：大规模场景（数万个刚体）可能超出 GPU 显存。对于 A100 80GB，建议单场景不超过 5000 个刚体
• 接触求解精度：GPU 并行接触求解在某些极端情况下（如薄壳物体、高频碰撞）可能不如 CPU 精确
• 生态成熟度：作为 2025 年底才开源的项目，社区和文档仍在完善中
• macOS 支持：仅支持 CPU 模式，无法利用 GPU 加速
• 柔性体支持：目前主要支持刚体仿真，柔性体能力尚在开发中

8.2 未来方向

• 柔性体与流体：Newton 团队正在开发柔性体仿真能力，这对于线缆操作、布料模拟等场景至关重要。已有的 cable 示例展示了初步的柔性体能力
• 多 GPU 扩展：支持跨多块 GPU 的分布式仿真，进一步提升并行规模
• ONNX 导出：将训练好的策略导出为 ONNX 格式，方便部署到边缘设备
• 与 Isaac Sim 的深度整合：提供更无缝的开发体验
• 更多接触模型：包括摩擦锥、软体接触等高级模型

九、安装与快速开始

# 基础安装
pip install newton

# 安装包含示例的完整版本
pip install "newton[examples]"

# 运行内置示例
python -m newton.examples

# 运行特定示例
python -m newton.examples basic_pendulum
python -m newton.examples robot_anymal_c_walk
python -m newton.examples cable_twist

系统要求：

• Python: 3.10+
• OS: Linux (x86-64, aarch64), Windows (x86-64), macOS (仅 CPU)
• GPU: NVIDIA GPU (Maxwell 或更新), 驱动 545+ (CUDA 12)
• 无需本地 CUDA Toolkit：Newton 会自动处理 CUDA 依赖

十、总结

Newton 的出现标志着机器人物理仿真进入了 GPU 原生时代。它不是一个简单的"MuJoCo GPU 版"，而是一个从头设计的、面向未来的物理仿真引擎：

• GPU 原生架构：不是把 CPU 代码搬到 GPU，而是从 GPU 并行的角度重新设计
• 可微分物理：打通仿真与优化的桥梁，让梯度信号可以流过物理世界
• OpenUSD 集成：连接仿真与可视化，支持完整的机器人开发工作流
• 生态开放：Apache-2.0 协议，Linux Foundation 项目，兼容 MuJoCo 和 Isaac Lab

对于机器人研究者，Newton 意味着更快的实验迭代；对于 AI 工程师，它意味着可以大规模并行训练 Sim2Real 策略；对于整个行业，它意味着物理仿真不再是机器人学习的瓶颈。

正如牛顿第三定律所揭示的——每一个作用力都有一个大小相等、方向相反的反作用力。Newton 物理引擎也在用 GPU 的并行力量，反作用于 CPU 串行仿真的瓶颈。

项目地址： github.com/newton-physics/newton

文档： newton-physics.github.io/newton

许可证： Apache-2.0

核心依赖： NVIDIA Warp, MuJoCo Warp, Python 3.10+, CUDA 12+

支持平台： Linux (x86-64, aarch64), Windows (x86-64), macOS (仅 CPU)

发起方： NVIDIA, Disney Research, Google DeepMind

维护组织： Linux Foundation