[isaacsim.physics.newton] Isaac Sim Newton Physics#

Version: 1.0.6

Overview#

The isaacsim.physics.newton extension integrates Newton physics simulation into Isaac Sim, providing an alternative physics engine to PhysX with support for advanced solvers including XPBD and MuJoCo backends. This extension enables high-performance physics simulation with CUDA graph capture optimization and tensor-based interfaces for machine learning workflows.

Key Components#

Physics Engine Management#

The extension provides APIs to manage multiple physics engines within Isaac Sim. The get_available_physics_engines function lists all registered physics engines with their active status, while get_active_physics_engine returns the currently active engine name. This allows applications to query and switch between different physics backends dynamically.

Newton Physics Interface#

The core physics control is accessed through acquire_physics_interface, which returns a NewtonPhysicsInterface for controlling simulation parameters and execution. The interface manages simulation stepping, state synchronization, and provides access to the underlying Newton solver systems.

Stage Management#

The acquire_stage function provides access to the NewtonStage object, which handles the simulation stage and USD integration. This stage object manages the physics scene representation and coordinates with the broader Isaac Sim USD workflow.

Configuration System#

NewtonConfig serves as the primary configuration class, following IsaacLab’s pattern of separating simulation-level parameters from solver-specific settings. Key configuration areas include:

Performance Settings: CUDA graph capture, physics frequency, and substep control
USD Integration: Fabric synchronization, PhysX tracker coordination, and joint processing options
Contact Parameters: Stiffness, damping, friction coefficients, and restitution settings
Joint Settings: Limit parameters, armature values, and PD controller scaling

Solver Configurations#

The extension supports multiple solver backends through specialized configuration classes:

XPBDSolverConfig configures the Extended Position-Based Dynamics solver, an implicit integrator for rigid and soft body simulation. Parameters include iteration counts, relaxation values for different constraint types, and compliance settings for joint behaviors.

MuJoCoSolverConfig provides extensive configuration for the MuJoCo Warp solver backend, including constraint limits, solver type selection, integrator options, and actuator gear mappings. This solver can operate in pure MuJoCo CPU mode or utilize the mujoco_warp GPU acceleration.

Integration#

The extension integrates with Isaac Sim’s unified physics interface through omni.physics, allowing applications to switch between Newton and other physics engines seamlessly. The isaacsim.core.simulation_manager dependency provides coordination with the broader simulation workflow, while usdrt.scenegraph enables direct Fabric integration for high-performance scene graph access.

Performance optimization is achieved through CUDA graph capture, which can be controlled via the capture_graph_physics_step setting. The extension can automatically become the active physics engine on startup through the auto_switch_on_startup setting.

Enable Extension#

The extension can be enabled (if not already) in one of the following ways:

Command-line interface

Define the next entry as an application argument from a terminal.

APP_SCRIPT.(sh|bat) --enable isaacsim.physics.newton

Experience/extension configuration

Define the next entry under [dependencies] in an experience (.kit) file or an extension configuration (extension.toml) file.

[dependencies]
"isaacsim.physics.newton" = {}

Extension Manager UI

Open the Window > Extensions menu in a running application instance and search for isaacsim.physics.newton. Then, toggle the enable control button if it is not already active.

Extension: {{ extension_version }}

Documentation Generated: Sep 10, 2026

Settings#

Settings Provided by the Extension#

exts.”isaacsim.physics.newton”.capture_graph_physics_step#

Default Value: true
Description: Enable CUDA graph capture for physics stepping to improve GPU performance.

exts.”isaacsim.physics.newton”.auto_switch_on_startup#

Default Value: true
Description: Automatically switch to the Newton physics engine when the extension starts.

exts.”isaacsim.physics.newton”.load_textures#

Default Value: false
Description: Load material textures into Newton. Off by default: they feed Newton’s own viewer only – Kit renders the stage through Hydra – and a texture that loads also makes Newton build a second UV-expanded render mesh per textured prim. Measured on a four-conveyor scene, world.reset() was 8.5 s off vs 37.5 s on.

Python API#

The following table summarizes the available classes and functions.

`acquire_physics_interface`	Get the Newton physics interface.
`acquire_stage`	Get the Newton simulation stage.
`configure_newton`	Set the Newton runtime configuration.
`get_newton_config`	Return the live Newton configuration.
`get_active_physics_engine`	Get the name of the currently active physics engine.
`get_available_physics_engines`	Get list of all available physics engines.

Configuration Classes#

`NewtonConfig`	Configuration for Newton physics simulation in Isaac Sim.
`CollisionConfig`	Configuration for the Newton collision pipeline.
`HydroelasticConfig`	Runtime configuration for hydroelastic contact.
`XPBDSolverConfig`	Configuration for XPBD (Extended Position-Based Dynamics) solver.
`MuJoCoSolverConfig`	Configuration for MuJoCo Warp solver-related parameters.

Tensor Interface#

The Newton tensor backend is provided by the separate isaacsim.physics.newton.tensors extension. Its generated Python API lists the simulation and view interfaces available when the extension is loaded.

Functions#

acquire_physics_interface() → NewtonPhysicsInterface | None#

Get the Newton physics interface.

Returns:: The physics interface for controlling simulation, or None if not initialized.

acquire_stage() → NewtonStage | None#

Get the Newton simulation stage.

Function name has a typo (“acuire”) but is kept for backward compatibility.

Returns:: The simulation stage object, or None if not initialized.

configure_newton( cfg: NewtonConfig, ) → None#

Set the Newton runtime configuration.

Applied on the next play or re-initialization. Call before play from a standalone script or extension.

Parameters:: cfg – Newton simulation configuration.

get_newton_config() → NewtonConfig | None#

Return the live Newton configuration.

Returns:: The current configuration, or None if the Newton stage has not been created.

get_active_physics_engine() → str#

Get the name of the currently active physics engine.

Returns:: Name of the active engine (“newton”, “physx”, etc.) or “Unknown” if none active.

get_available_physics_engines( verbose: bool = False, ) → list[tuple[str, bool]]#

Get list of all available physics engines.

Parameters:: verbose – If True, print available engines to console.
Returns:: List of tuples (engine_name, is_active) for all registered engines.

Configuration Classes#

class NewtonConfig( num_substeps: int = 1, debug_mode: bool = False, use_cuda_graph: bool = True, time_step_app: bool = True, physics_frequency: float = 600.0, update_fabric: bool = True, disable_physx_fabric_tracker: bool = True, collapse_fixed_joints: bool = False, fix_missing_xform_ops: bool = True, contact_ke: float = 10000.0, contact_kd: float = 100.0, contact_kf: float = 10.0, contact_mu: float = 1.0, contact_ka: float = 0.5, restitution: float = 0.0, contact_margin: float = 0.01, soft_contact_margin: float = 0.01, joint_limit_ke: float = 100.0, joint_limit_kd: float = 1.0, armature: float = 0.1, joint_damping: float = 1.0, pd_scale: float = 1.0, solver_cfg: ~isaacsim.physics.newton.impl.solver_config.NewtonSolverConfig = <factory>, collision_cfg: ~isaacsim.physics.newton.impl.collision_config.CollisionConfig = <factory>, )#

Bases: object

Configuration for Newton physics simulation in Isaac Sim.

This configuration follows IsaacLab’s pattern of separating simulation-level parameters from solver-specific parameters.

armature: float = 0.1#: Default joint armature (rotor inertia).

collapse_fixed_joints: bool = False#

Whether to merge bodies connected by fixed joints during USD parsing.

When enabled, reduces body count and improves performance.

collision_cfg: CollisionConfig#: Collision pipeline configuration, including hydroelastic contact.

contact_ka: float = 0.5#: Default contact adhesion coefficient.

contact_kd: float = 100.0#: Default contact damping coefficient.

contact_ke: float = 10000.0#: Default contact stiffness (spring constant).

contact_kf: float = 10.0#: Default contact friction force coefficient.

contact_margin: float = 0.01#: Contact margin for rigid body collision detection.

contact_mu: float = 1.0#: Default friction coefficient (Coulomb friction).

debug_mode: bool = False#: Whether to enable debug mode for the solver.

disable_physx_fabric_tracker: bool = True#: Whether to pause PhysX fabric change tracking (if PhysX is loaded).

fix_missing_xform_ops: bool = True#: Whether to add missing identity xform operations to geometry prims to suppress USD warnings.

joint_damping: float = 1.0#: Default joint damping coefficient.

joint_limit_kd: float = 1.0#: Default joint limit damping.

joint_limit_ke: float = 100.0#: Default joint limit stiffness.

num_substeps: int = 1#: Number of substeps to use for the solver.

pd_scale: float = 1.0#: Scaling factor for PD controller gains when parsing USD joint drives.

physics_frequency: float = 600.0#: Physics simulation frequency in Hz.

restitution: float = 0.0#: Default coefficient of restitution (bounciness). 0 = no bounce, 1 = perfectly elastic.

soft_contact_margin: float = 0.01#: Contact margin for soft body collision detection.

solver_cfg: NewtonSolverConfig#: Solver-specific configuration.

time_step_app: bool = True#

Whether the application should drive simulation time stepping.

If True, the stage update node calls step_sim(). If False, external code must step.

update_fabric: bool = True#: Whether to synchronize Newton state to USD Fabric each frame.

use_cuda_graph: bool = True#

Whether to use CUDA graph capture for performance optimization.

When enabled, the simulation loop is captured as a CUDA graph for faster execution. Highly recommended for production use.

class CollisionConfig( broad_phase: ~typing.Literal['nxn', 'sap', 'explicit'] = 'explicit', rigid_contact_max: int | None = None, hydroelastic: ~isaacsim.physics.newton.impl.collision_config.HydroelasticConfig = <factory>, )#

Bases: object

Configuration for the Newton collision pipeline.

broad_phase: Literal['nxn', 'sap', 'explicit'] = 'explicit'#: Broad-phase pair generation mode.

hydroelastic: HydroelasticConfig#: Hydroelastic contact runtime settings.

rigid_contact_max: int | None = None#

Maximum number of rigid contacts to allocate, or None to derive it from the model.

Must be at least the per-world contact capacity of the solver, such as MuJoCoSolverConfig.nconmax.

class HydroelasticConfig( enabled: bool = True, reduce_contacts: bool = True, buffer_fraction: float = 1.0, buffer_mult_broad: int = 1, buffer_mult_iso: int = 1, buffer_mult_contact: int = 1, normal_matching: bool = True, anchor_contact: bool = False, margin_contact_area: float = 0.01, output_contact_surface: bool = False, mc_edge_clamp_min: float = 0.02, )#

Bases: object

Runtime configuration for hydroelastic contact.

Per-shape opt-in (enable, stiffness, SDF resolution) is authored in USD via NewtonSDFCollisionAPI and parsed automatically.

anchor_contact: bool = False#: Add an extra contact at the center of pressure per normal bin.

buffer_fraction: float = 1.0#

(0, 1].

Type:: GPU buffer size relative to the worst-case estimate. Range

buffer_mult_broad: int = 1#

Multiplier for the broad-phase block pair buffer, applied after buffer_fraction.

Increase when a broad phase overflow warning is reported.

buffer_mult_contact: int = 1#

Multiplier for the face contact buffer, applied after buffer_fraction.

Increase when a face contact overflow warning is reported.

buffer_mult_iso: int = 1#

Multiplier for the iso-surface extraction buffers, applied after buffer_fraction.

Increase when an iso subblock or iso voxel overflow warning is reported.

enabled: bool = True#: Whether to run the hydroelastic contact path when hydroelastic shapes are present.

margin_contact_area: float = 0.01#: Area used for non-penetrating margin contacts [m²].

mc_edge_clamp_min: float = 0.02#: Marching-cubes edge clamp parameter.

normal_matching: bool = True#: Align reduced contact normals with the aggregate force direction.

output_contact_surface: bool = False#: Export contact patch triangles for visualization.

reduce_contacts: bool = True#: Merge patch triangles into fewer representative contacts.

class XPBDSolverConfig( solver_type: Literal['xpbd'] = 'xpbd', iterations: int = 2, )#

Bases: NewtonSolverConfig

Configuration for XPBD (Extended Position-Based Dynamics) solver.

An implicit integrator using eXtended Position-Based Dynamics (XPBD) for rigid and soft body simulation.

References

Miles Macklin, Matthias Müller, and Nuttapong Chentanez. 2016. XPBD: position-based simulation of compliant constrained dynamics. In Proceedings of the 9th International Conference on Motion in Games (MIG ‘16). Association for Computing Machinery, New York, NY, USA, 49-54. https://doi.org/10.1145/2994258.2994272
Matthias Müller, Miles Macklin, Nuttapong Chentanez, Stefan Jeschke, and Tae-Yong Kim. 2020. Detailed rigid body simulation with extended position based dynamics. In Proceedings of the ACM SIGGRAPH/Eurographics Symposium on Computer Animation (SCA ‘20). Eurographics Association, Goslar, DEU, Article 10, 1-12. https://doi.org/10.1111/cgf.14105

iterations: int = 2#: Number of solver iterations.

solver_type: Literal['xpbd'] = 'xpbd'#

‘xpbd’, ‘mujoco’, ‘featherstone’, ‘semiImplicit’, ‘vbd’.

Type:: Type of solver to use

class MuJoCoSolverConfig( solver_type: Literal['mujoco'] = 'mujoco', njmax: int = 1200, nconmax: int | None = 200, use_mujoco_cpu: bool = False, disable_contacts: bool = False, update_data_interval: int = 1, save_to_mjcf: str | None = None, use_mujoco_contacts: bool = False, include_sites: bool = False, )#

Bases: NewtonSolverConfig

Configuration for MuJoCo Warp solver-related parameters.

These parameters are used to configure the MuJoCo Warp solver. For more information, see the MuJoCo Warp documentation.

disable_contacts: bool = False#: Whether to disable contact computation in MuJoCo.

include_sites: bool = False#: If True, Newton shapes marked with ShapeFlags.SITE are exported as MuJoCo sites.

nconmax: int | None = 200#: Number of contact points per environment (world).

njmax: int = 1200#: Number of constraints per environment (world).

save_to_mjcf: str | None = None#: Optional path to save the generated MJCF model file.

solver_type: Literal['mujoco'] = 'mujoco'#

‘xpbd’, ‘mujoco’, ‘featherstone’, ‘semiImplicit’, ‘vbd’.

Type:: Type of solver to use

update_data_interval: int = 1#: Frequency (in simulation steps) at which to update the MuJoCo Data object from the Newton state.

use_mujoco_contacts: bool = False#: Whether to use MuJoCo’s contact computation.

use_mujoco_cpu: bool = False#: Whether to use the pure MuJoCo backend instead of mujoco_warp.

Python API