Newton Physics Backend#

Isaac Sim supports multiple physics backends. In addition to the default PhysX SDK backend, you can now use Newton as the simulation backend.

Newton is a GPU-accelerated, extensible, and differentiable physics simulation engine designed for robotics and research. Built on NVIDIA Warp and integrating MuJoCo Warp. Newton provides high-performance simulation with multiple solver implementations including XPBD, MuJoCo, Featherstone, and SemiImplicit. Newton is an open-source project maintained by Disney Research, Google DeepMind, and NVIDIA.

Overview#

Isaac Sim integrates Newton through three key extensions:

  • isaacsim.physics.newton: The Newton physics backend implementation that:

    • Parses USD stage from your scene and builds Newton simulation objects

    • Synchronizes simulation state with Fabric for rendering and data access

    • Provides a tensor-based API (isaacsim.physics.newton.tensors) compatible with NumPy, PyTorch, and Warp

    • Registers Newton with the unified physics interface

  • isaacsim.core.simulation_manager: SimulationManager provides functionality for switching between physics engines at runtime, along with scene configuration classes (PhysicsScene, NewtonMjcScene) for Newton-specific settings.

  • isaacsim.core.experimental.prims: Uses isaacsim.physics.newton.tensors as its tensor backend when Newton is active. This extension provides engine-agnostic prim wrappers that work consistently across all physics backends.

When Newton is active, it replaces PhysX as the simulation backend while maintaining compatibility with standard USD Physics schemas used by your robot and environment assets.

Using the Experimental Core API#

The isaacsim.core.experimental extension provides engine-agnostic building blocks that ensure compatibility across different physics backends. User extensions and applications are highly recommended to use isaacsim.core.experimental to write simulation code that works with all physics backends (PhysX, Newton). Refer to Core Experimental API documentation for more details.

Launching Isaac Sim with Newton#

You can launch Isaac Sim with Newton as the default physics backend using the dedicated application file.

./isaac-sim.newton.sh

isaac-sim.newton.bat

When launched with this application, Newton is automatically enabled and PhysX is disabled.

Switching Physics Engines at Runtime#

You can switch between physics engines programmatically using the SimulationManager class. Use get_available_physics_engines() to list registered engines and switch_physics_engine() to activate Newton:

from isaacsim.core.simulation_manager import SimulationManager

engines = SimulationManager.get_available_physics_engines(verbose=True)
success = SimulationManager.switch_physics_engine("newton")
if success:
    print("Switched to Newton physics engine")

Note

Switching physics engines should be done before starting the simulation. The switch deactivates the previous engine and activates the new one. Currently, only one physics engine can be active at a time.

Basic Usage Example#

The following example demonstrates setting up a simple physics scene with Newton:

import omni.kit.actions.core
import omni.timeline
import omni.usd
from isaacsim.core.experimental.objects import Cube, Plane
from isaacsim.core.simulation_manager import SimulationManager
from isaacsim.core.simulation_manager.impl.mjc_scene import NewtonMjcScene
from pxr import Sdf, UsdGeom, UsdLux, UsdPhysics

omni.usd.get_context().new_stage()
SimulationManager.switch_physics_engine("newton")
stage = omni.usd.get_context().get_stage()

# Enable camera light and add distant light
action_registry = omni.kit.actions.core.get_action_registry()
action_registry.get_action("omni.kit.viewport.menubar.lighting", "set_lighting_mode_camera").execute()
UsdLux.DistantLight.Define(stage, Sdf.Path("/DistantLight")).CreateIntensityAttr(500)

# Create physics scene
mjc_scene = NewtonMjcScene("/World/PhysicsScene")
mjc_scene.set_gravity((0.0, 0.0, -9.81))

# Create ground plane (collision + visual)
UsdGeom.Xform.Define(stage, "/World/GroundPlane")
Plane("/World/GroundPlane/CollisionPlane", axes="Z")
UsdPhysics.CollisionAPI.Apply(stage.GetPrimAtPath("/World/GroundPlane/CollisionPlane"))
visual_mesh = UsdGeom.Mesh.Define(stage, "/World/GroundPlane/VisualMesh")
size = 50.0
visual_mesh.CreatePointsAttr([(-size, -size, 0), (size, -size, 0), (size, size, 0), (-size, size, 0)])
visual_mesh.CreateFaceVertexCountsAttr([4])
visual_mesh.CreateFaceVertexIndicesAttr([0, 1, 2, 3])
visual_mesh.CreateDisplayColorAttr([(0.5, 0.5, 0.5)])

# Create dynamic cube
Cube("/World/Cube", sizes=0.5, positions=[[0.0, 0.0, 2.0]])
cube_prim = stage.GetPrimAtPath("/World/Cube")
UsdPhysics.CollisionAPI.Apply(cube_prim)
UsdPhysics.RigidBodyAPI.Apply(cube_prim)

# Start simulation
timeline = omni.timeline.get_timeline_interface()
timeline.play()

Scene Configuration#

Newton USD Schemas#

Newton uses custom USD schemas to configure physics scenes. The Newton USD Schemas project provides extensions to OpenUSD’s UsdPhysics specification, allowing USD layers to fully specify Newton runtime parameters. These schemas follow a minimalist approach, capturing parameters that generalize across simulators and have clear physical meaning.

The key schemas include:

  • NewtonSceneAPI: Base Newton schema applied to all physics scenes, providing common attributes like timestep (newton:timeStepsPerSecond), gravity settings, and solver iterations.

  • MjcSceneAPI: MuJoCo solver-specific schema with integrator type, constraint solver algorithm, tolerance, and contact settings.

PhysicsScene Base Class#

The PhysicsScene class provides a Python interface to the NewtonSceneAPI schema attributes. When you create a PhysicsScene, it automatically applies the NewtonSceneAPI to the underlying USD prim, allowing you to configure common Newton settings:

from isaacsim.core.simulation_manager import PhysicsScene

physics_scene = PhysicsScene("/World/PhysicsScene")
physics_scene.set_gravity((0.0, 0.0, -9.81))
physics_scene.set_dt(0.001)
physics_scene.set_enabled_gravity(True)
physics_scene.set_max_solver_iterations(100)

MuJoCo Solver Configuration#

MuJoCo-specific parameters can be stored in USD through the MJC USD schemas, which capture settings for scenes, bodies, joints, and other elements. The MjcSceneAPI is one of these schemas, providing scene-level simulation parameters. The NewtonMjcScene class provides a Python interface to the MjcSceneAPI attributes, allowing you to configure MuJoCo solver settings directly on USD Physics Scene prims.

When you create a NewtonMjcScene, it applies both NewtonSceneAPI and MjcSceneAPI to the prim:

from isaacsim.core.simulation_manager.impl.mjc_scene import NewtonMjcScene

mjc_scene = NewtonMjcScene("/World/PhysicsScene")
mjc_scene.set_dt(0.002)
mjc_scene.set_integrator("implicit")  # euler, rk4, implicit, implicitfast
mjc_scene.set_solver("newton")  # pgs, cg, newton
mjc_scene.set_iterations(100)
mjc_scene.set_tolerance(1e-8)
mjc_scene.set_cone("elliptic")  # pyramidal, elliptic

Note

Additional engine-specific scene classes to incorporate other solver-specific schemas (XPBD, Featherstone) are under development and will be available in future releases.

Robot Simulation Example#

The following example loads a Franka robot and simulates it with Newton:

import omni.kit.actions.core
import omni.timeline
import omni.usd
from isaacsim.core.simulation_manager import SimulationManager
from isaacsim.core.simulation_manager.impl.mjc_scene import NewtonMjcScene
from isaacsim.core.utils.stage import add_reference_to_stage
from isaacsim.storage.native import get_assets_root_path
from pxr import Sdf, UsdLux

omni.usd.get_context().new_stage()
SimulationManager.switch_physics_engine("newton")
stage = omni.usd.get_context().get_stage()

action_registry = omni.kit.actions.core.get_action_registry()
action_registry.get_action("omni.kit.viewport.menubar.lighting", "set_lighting_mode_camera").execute()
UsdLux.DistantLight.Define(stage, Sdf.Path("/DistantLight")).CreateIntensityAttr(500)

mjc_scene = NewtonMjcScene("/World/PhysicsScene")
mjc_scene.set_dt(0.002)
mjc_scene.set_integrator("implicit")
mjc_scene.set_gravity((0.0, 0.0, -9.81))

asset_path = get_assets_root_path() + "/Isaac/Robots/FrankaRobotics/FrankaPanda/franka.usd"
add_reference_to_stage(usd_path=asset_path, prim_path="/World/Franka")

timeline = omni.timeline.get_timeline_interface()
timeline.play()
../_images/isim_6.0_full_ref_viewport_newton_engine_menu.png

The physics engine selector in the viewport menu.#

For more on the physics umbrella UI (engine selector, scene settings, and related controls), see the Omni Physics UI documentation.

To compare simulation results between Newton and PhysX:

  • stop the simulation

  • switch the physics engine from “newton” to “physx” using the menu shown above

  • play the simulation again

Asset Compatibility#

Existing PhysX-based assets in Isaac Sim are compatible with Newton. However, these assets are tuned for PhysX and may not produce optimal results with Newton/MuJoCo out of the box. You might need to adjust physics parameters (including: contact settings, solver iterations, timestep) to achieve desired simulation behavior with Newton/MuJoCo.

With the new asset structure and MJCF/URDF importers, we are working toward converting each asset to both PhysX schemas and MJC USD schemas. This will enable consistent simulation behavior between the original MJCF asset (using MuJoCo) and the converted MJC USD asset (using Newton).

Note

Newton integration in Isaac Sim is experimental. The API and features may change in future releases. Many Isaac Sim features and workflows that do not use the experimental core API are not yet supported with the Newton backend; support is being actively developed for the next release. The Newton backend in Isaac Sim has been tested only with a limited set of robots, including G1, H1, T1, UR5e, Wonik Allegro, and Shadow Hand.

Additional Resources#