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

Version: 0.6.0

Extension for simulating physics with Newton and connecting with Fabric. Includes tensor interface (isaacsim.physics.newton.tensors) for NumPy/PyTorch/Warp frontends.

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.

API#

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.
`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.
`XPBDSolverConfig`	Configuration for XPBD (Extended Position-Based Dynamics) solver.
`MuJoCoSolverConfig`	Configuration for MuJoCo Warp solver-related parameters.

Tensor Interface#

The tensor interface provides NumPy, PyTorch, and Warp frontends for physics data access.

`create_simulation_view`	Create a simulation view with the specified tensor frontend.
`NewtonArticulationView`	View for articulations in Newton physics simulation.
`NewtonRigidBodyView`	View for rigid bodies in Newton physics simulation.
`NewtonRigidContactView`	View for contact sensors in Newton physics simulation.

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.

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>, )#

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.

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. TODO: We should not need this anymore.

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 XPBDSolverConfig( solver_type: Literal['xpbd'] = 'xpbd', iterations: int = 2, soft_body_relaxation: float = 0.9, soft_contact_relaxation: float = 0.9, joint_linear_relaxation: float = 0.7, joint_angular_relaxation: float = 0.4, joint_linear_compliance: float = 0.0, joint_angular_compliance: float = 0.0, rigid_contact_relaxation: float = 0.8, rigid_contact_con_weighting: bool = True, angular_damping: float = 0.0, enable_restitution: bool = False, )#

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

angular_damping: float = 0.0#: Angular damping parameter for rigid contact simulation.

enable_restitution: bool = False#: Whether to enable restitution for rigid contact simulation.

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

joint_angular_compliance: float = 0.0#: Compliance parameter for joint angular simulation.

joint_angular_relaxation: float = 0.4#: Relaxation parameter for joint angular simulation.

joint_linear_compliance: float = 0.0#: Compliance parameter for joint linear simulation.

joint_linear_relaxation: float = 0.7#: Relaxation parameter for joint linear simulation.

rigid_contact_con_weighting: bool = True#: Whether to use contact constraint weighting for rigid contact simulation.

rigid_contact_relaxation: float = 0.8#: Relaxation parameter for rigid contact simulation.

soft_body_relaxation: float = 0.9#: Relaxation parameter for soft body simulation.

soft_contact_relaxation: float = 0.9#: Relaxation parameter for soft contact simulation.

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

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

Type:: Type of solver to use

class MuJoCoSolverConfig( solver_type: Literal['mujoco'] = 'mujoco', njmax: int = 1200, nconmax: int | None = 200, iterations: int = 100, ls_iterations: int = 15, solver: str = 'newton', integrator: str = 'implicitfast', cone: str = 'elliptic', impratio: float = 1.0, use_mujoco_cpu: bool = False, disable_contacts: bool = False, update_data_interval: int = 1, save_to_mjcf: str | None = None, ls_parallel: bool = True, use_mujoco_contacts: bool = True, tolerance: float = 1e-06, ls_tolerance: float = 0.001, 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.

cone: str = 'elliptic'#: The type of contact friction cone. Can be “pyramidal” or “elliptic”.

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

impratio: float = 1.0#: Frictional-to-normal constraint impedance ratio.

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

integrator: str = 'implicitfast'#: Integrator type. Can be “euler”, “rk4”, or “implicit”, or their corresponding MuJoCo integer constants.

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

ls_iterations: int = 15#: Number of line search iterations for the solver.

ls_parallel: bool = True#: Whether to use parallel line search.

ls_tolerance: float = 0.001#: Solver tolerance for early termination of the line search.

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: str = 'newton'#: Solver type. Can be “cg” or “newton”, or their corresponding MuJoCo integer constants.

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

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

Type:: Type of solver to use

tolerance: float = 1e-06#: Solver tolerance for early termination of the iterative solver.

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 = True#: Whether to use MuJoCo’s contact computation.

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

Tensor Views#

create_simulation_view( frontend_name: str, newton_stage: NewtonStage, stage_id: int = -1, ) → NewtonSimulationView#

Create a simulation view with the specified tensor frontend.

Parameters:

frontend_name – Name of the frontend framework.
newton_stage – The Newton stage object from isaacsim.physics.newton.
stage_id – USD stage ID (currently unused, kept for API compatibility).

Returns:

Simulation view object with the specified frontend.

Raises:

Exception – If backend creation fails or invalid frontend name is provided.

class NewtonArticulationView(backend: Any, frontend: Any)#

Bases: object

View for articulations in Newton physics simulation.

Provides tensor-based access to articulation properties like joint positions, velocities, transforms, etc.

Parameters:

backend – ArticulationSet backend instance from NewtonSimView.
frontend – Tensor framework frontend.

apply_forces( force_data: Any, indices: Any | None = None, is_global: bool = True, indices_mask: Any | None = None, ) → None#

Apply forces to articulation links (deprecated, use apply_forces_and_torques_at_position).

Parameters:

force_data – Forces to apply, shape (count, max_links, 3).
indices – Indices of articulations to apply forces to. If None, applies to all articulations.
is_global – If True, forces are in global frame. If False, in link local frame.
indices_mask – Optional mask for the indices.

apply_forces_and_torques_at_position( force_data: Any | None, torque_data: Any | None, position_data: Any | None, indices: Any, is_global: bool = True, indices_mask: Any | None = None, ) → None#

Apply forces and torques to articulation links at specified positions.

This function provides flexible force application to articulation links: - Apply forces at link centers or at specified positions - Apply torques directly to links - Work in global or local coordinate frames - When position is specified with force, automatically computes induced torque

Parameters:

force_data – Forces to apply, shape (count, max_links, 3). Can be None.
torque_data – Torques to apply, shape (count, max_links, 3). Can be None.
position_data – Positions where forces are applied, shape (count, max_links, 3). Can be None. If specified with force_data, the force is applied at this position relative to the link’s center of mass, generating additional torque.
indices – Indices of articulations to apply forces to.
is_global – If True, force/torque/position are in global frame. If False, in link local frame.
indices_mask – Optional mask for the indices.

check() → bool#

Check if the articulation view is valid and has articulations.

Returns:: True if the view has a valid backend with at least one articulation.

get_coms(copy: bool = True) → Any#

Get link center of mass positions and orientations.

Parameters:: copy – Whether to return a copy.
Returns:: Flat tensor that should be reshaped to (count, max_links, 7). Each COM has 7 values: position (3) + quaternion (4) in scalar-first (w,x,y,z) format. Newton stores COM as offset in body frame. Position is read from Newton, orientation is cached (Newton doesn’t support COM orientation).

get_coriolis_and_centrifugal_compensation_forces( copy: bool = True, ) → Any#

Get Coriolis and centrifugal compensation forces.

Parameters:: copy – Whether to return a copy.
Returns:: Tensor of shape (count, max_dofs).

get_disable_gravities( copy: bool = True, ) → Any#

Get gravity disable flags for links.

Parameters:: copy – Whether to return a copy.
Returns:: Tensor of shape (count, max_links).

get_dof_actuation_forces( copy: bool = True, ) → Any#

Get joint actuation forces/torques.

Parameters:: copy – Whether to return a copy.
Returns:: Tensor of shape (count, max_dofs).

get_dof_armatures( copy: bool = True, ) → Any#

Get joint armatures (rotor inertias).

Parameters:: copy – Whether to return a copy.
Returns:: Tensor of shape (count, max_dofs).

get_dof_dampings(copy: bool = True)#

Get joint dampings (for velocity control).

Parameters:: copy – Whether to return a copy.
Returns:: Tensor of shape (count, max_dofs) on CPU (host memory).

get_dof_drive_model_properties( copy: bool = True, ) → Any#

Get joint drive model properties.

Parameters:: copy – Whether to return a copy.
Returns:: Tensor of shape (count, max_dofs, 3) where the last dimension contains [speed_effort_gradient, max_actuator_velocity, velocity_dependent_resistance].

get_dof_friction_properties( copy: bool = True, ) → Any#

Get joint friction properties.

Parameters:: copy – Whether to return a copy.
Returns:: Tensor of shape (count, max_dofs, 3) where the last dimension contains [static_friction, dynamic_friction, viscous_friction].

get_dof_limits(copy: bool = True)#

Get joint limits [lower, upper].

Parameters:: copy – Whether to return a copy.
Returns:: Tensor of shape (count, max_dofs, 2).

get_dof_max_forces( copy: bool = True, ) → Any#

Get joint maximum forces/torques (effort limits).

Parameters:: copy – Whether to return a copy.
Returns:: Tensor of shape (count, max_dofs).

get_dof_max_velocities( copy: bool = True, ) → Any#

Get joint maximum velocities.

Parameters:: copy – Whether to return a copy.
Returns:: Tensor of shape (count, max_dofs).

get_dof_position_targets( copy: bool = True, ) → Any#

Get joint position targets (for position control).

Parameters:: copy – Whether to return a copy.
Returns:: Tensor of shape (count, max_dofs).

get_dof_positions(copy: bool = True)#

Get joint positions.

Parameters:: copy – Whether to return a copy.
Returns:: Tensor of shape (count, max_dofs).

get_dof_projected_joint_forces( copy: bool = True, ) → Any#

Get projected joint forces.

Parameters:: copy – Whether to return a copy.
Returns:: Tensor of shape (count, max_dofs).

get_dof_stiffnesses(copy: bool = True)#

Get joint stiffnesses (for position control).

Parameters:: copy – Whether to return a copy.
Returns:: Tensor of shape (count, max_dofs) on CPU (host memory).

get_dof_velocities(copy: bool = True)#

Get joint velocities.

Parameters:: copy – Whether to return a copy.
Returns:: Tensor of shape (count, max_dofs).

get_dof_velocity_targets( copy: bool = True, ) → Any#

Get joint velocity targets (for velocity control).

Parameters:: copy – Whether to return a copy.
Returns:: Tensor of shape (count, max_dofs).

get_drive_types( copy: bool = True, ) → Any#

Get joint drive types.

Parameters:: copy – Whether to return a copy.
Returns:: Tensor of shape (count, max_dofs) of type uint8.

get_generalized_mass_matrices( copy: bool = True, ) → Any#

Get generalized mass matrices.

Parameters:: copy – Whether to return a copy.
Returns:: Tensor of shape (count, max_dofs, max_dofs).

get_gravity_compensation_forces( copy: bool = True, ) → Any#

Get gravity compensation forces.

Parameters:: copy – Whether to return a copy.
Returns:: Tensor of shape (count, max_dofs).

get_inertias(copy: bool = True)#

Get link inertias.

Parameters:: copy – Whether to return a copy.
Returns:: Tensor of shape (count, max_links, 9).

get_inv_inertias(copy: bool = True)#

Get link inverse inertias.

Parameters:: copy – Whether to return a copy.
Returns:: Tensor of shape (count, max_links, 9).

get_inv_masses(copy: bool = True)#

Get link inverse masses (1/mass).

Parameters:: copy – Whether to return a copy.
Returns:: Tensor of shape (count, max_links).

get_jacobians(copy: bool = True) → Any#

Get Jacobian matrices.

Parameters:: copy – Whether to return a copy.
Returns:: Tensor of shape (count, num_links_effective, 6, num_dofs).

get_link_incoming_joint_force( copy: bool = True, ) → Any#

Get incoming joint forces for each link.

Parameters:: copy – Whether to return a copy.
Returns:: Tensor of shape (count, max_links, 6).

get_masses(copy: bool = True)#

Get link masses.

Parameters:: copy – Whether to return a copy.
Returns:: Tensor of shape (count, max_links).

get_metatype(index: int)#

Get metadata type for a specific articulation.

Parameters:: index – Index of the articulation in the view (0 to count-1).
Returns:: ArticulationMetaType object containing link names, joint names, DOF names, etc.
Raises:: IndexError – If index is out of range.

get_root_transforms(copy: bool = True)#

Get root body transforms [position(3) + quaternion(4)].

Parameters:: copy – Whether to return a copy.
Returns:: Tensor of shape (count, 7).

get_root_velocities(copy: bool = True)#

Get root body velocities [linear(3) + angular(3)].

Parameters:: copy – Whether to return a copy.
Returns:: Tensor of shape (count, 6).

set_coms( data: Any, indices: Any, indices_mask: Any | None = None, )#

Set link center of mass positions and orientations.

Parameters:

data – Tensor of COM data, shape should be (count, max_links, 7) or flat.
indices – Articulation indices.
indices_mask – Optional mask for indices.

set_disable_gravities( data: Any, indices: Any, indices_mask: Any | None = None, )#

Set gravity disable flags for links.

Parameters:

data – Gravity disable flags to set, shape (count, max_links).
indices – Articulation indices to update.
indices_mask – Optional mask for indices.

set_dof_actuation_forces( data: Any, indices: Any, indices_mask: Any | None = None, )#

Set joint actuation forces/torques.

Newton doesn’t have convert_joint_torques_to_body_forces like warp.sim. This directly sets the joint forces which will be applied by the solver.

Parameters:

data – Actuation force values to set.
indices – Articulation indices.
indices_mask – Optional mask for indices.

set_dof_armatures( data: Any, indices: Any, indices_mask: Any | None = None, )#

Set joint armatures (rotor inertias).

Parameters:

data – Armature values to set.
indices – Articulation indices.
indices_mask – Optional mask for indices.

set_dof_dampings( data: Any, indices: Any, indices_mask: Any | None = None, )#

Set joint dampings.

Parameters:

data – Damping values to set.
indices – Articulation indices.
indices_mask – Optional mask for indices.

set_dof_drive_model_properties( data: Any, indices: Any, indices_mask: Any | None = None, )#

Set joint drive model properties.

Parameters:

data – Drive model properties to set, shape (count, max_dofs, 3).
indices – Articulation indices to update.
indices_mask – Optional mask for indices.

set_dof_friction_properties( data: Any, indices: Any, indices_mask: Any | None = None, )#

Set joint friction properties.

Parameters:

data – Friction properties to set, shape (count, max_dofs, 3).
indices – Articulation indices to update.
indices_mask – Optional mask for indices.

set_dof_limits( data: Any, indices: Any, indices_mask: Any | None = None, )#

Set joint limits (lower and upper bounds).

Parameters:

data – Joint limits to set, shape (count, max_dofs, 2) where last dim is [lower, upper].
indices – Articulation indices to update.
indices_mask – Optional mask for indices.

set_dof_max_forces( data: Any, indices: Any, indices_mask: Any | None = None, )#

Set joint maximum forces/torques (effort limits).

Parameters:

data – Maximum forces to set, shape (count, max_dofs).
indices – Articulation indices to update.
indices_mask – Optional mask for indices.

set_dof_max_velocities( data: Any, indices: Any, indices_mask: Any | None = None, )#

Set joint maximum velocities.

Parameters:

data – Maximum velocities to set, shape (count, max_dofs).
indices – Articulation indices to update.
indices_mask – Optional mask for indices.

set_dof_position_targets( data: Any, indices: Any, indices_mask: Any | None = None, )#

Set joint position targets.

Parameters:

data – Position target values to set.
indices – Articulation indices.
indices_mask – Optional mask for indices.

set_dof_positions( data: Any, indices: Any, indices_mask: Any | None = None, )#

Set joint positions.

Parameters:

data – Position values to set.
indices – Articulation indices.
indices_mask – Optional mask for indices.

set_dof_stiffnesses( data: Any, indices: Any, indices_mask: Any | None = None, )#

Set joint stiffnesses.

Parameters:

data – Stiffness values to set.
indices – Articulation indices.
indices_mask – Optional mask for indices.

set_dof_velocities( data: Any, indices: Any, indices_mask: Any | None = None, )#

Set joint velocities.

Parameters:

data – Velocity values to set.
indices – Articulation indices.
indices_mask – Optional mask for indices.

set_dof_velocity_targets( data: Any, indices: Any, indices_mask: Any | None = None, )#

Set joint velocity targets.

Parameters:

data – Velocity target values to set.
indices – Articulation indices.
indices_mask – Optional mask for indices.

set_inertias( data: Any, indices: Any, indices_mask: Any | None = None, )#

Set link inertias.

Parameters:

data – Inertia values to set.
indices – Articulation indices.
indices_mask – Optional mask for indices.

set_masses( data: Any, indices: Any, indices_mask: Any | None = None, )#

Set link masses.

Parameters:

data – Mass values to set.
indices – Articulation indices.
indices_mask – Optional mask for indices.

set_root_transforms( data: Any, indices: Any, indices_mask: Any | None = None, )#

Set root body transforms.

Automatically detects whether each articulation is fixed-base or floating-base and handles them appropriately: - Fixed-base: Updates Model’s joint_X_p (parent transforms) - Floating-base: Updates State’s joint coordinates After setting transforms, forward kinematics is evaluated to update all link positions.

Parameters:

data – Root transforms to set (dtype=wp.transform).
indices – Indices of articulations to update.
indices_mask – Optional mask for the indices.

set_root_velocities( data: Any, indices: Any, indices_mask: Any | None = None, )#

Set root body velocities.

Automatically detects whether each articulation is fixed-base or floating-base: - Fixed-base: Sets body velocities directly (no joint coordinate updates needed) - Floating-base: Updates State’s joint velocity coordinates After setting velocities, forward kinematics may be evaluated if needed.

Parameters:

data – Root velocities to set (dtype=wp.spatial_vector).
indices – Indices of articulations to update.
indices_mask – Optional mask for the indices.

update(dt: float)#

Update simulation timestamp.

Parameters:: dt – Time delta.

update_joints( indices: Any, indices_mask: Any | None = None, )#

Update joint states after setting positions/velocities.

This evaluates forward kinematics to update body transforms from joint states.

Parameters:

indices – Articulation indices to update.
indices_mask – Optional mask for indices.

property count#

Number of articulations in this view.

Returns:: Number of articulations.

property dof_names: list[list[str]]#

Degree of freedom (DOF) names for all articulations in the view.

Returns:: List of DOF name lists, one per articulation.

property dof_paths#

DOF paths for all articulations in the view.

Returns:: List of DOF path lists, one per articulation.

property generalized_mass_matrix_shape: tuple[int, int]#

Generalized mass matrix shape for articulations.

Returns:

Fixed base: n = max_dofs
Floating base: n = max_dofs + 6

Return type:

Tuple (n, n) where

property is_homogeneous: bool#

Whether all articulations in the view have the same structure.

Returns:: True if all articulations have the same number of DOFs, links, and joints.

property jacobian_shape: tuple[int, int]#

Jacobian matrix shape for articulations.

Returns:

Fixed base: rows = (max_links - 1) * 6, cols = max_dofs
Floating base: rows = max_links * 6, cols = max_dofs + 6

Return type:

Tuple (rows, cols) where

property joint_names: list[list[str]]#

Joint names for all articulations in the view.

Returns:: List of joint name lists, one per articulation.

property joint_paths: list[list[str]]#

Joint paths for all articulations in the view.

Returns:: List of joint path lists, one per articulation.

property link_names: list[list[str]]#

Link names for all articulations in the view.

Returns:: List of link name lists, one per articulation.

property link_paths: list[list[str]]#

Link paths for all articulations in the view.

Returns:: List of link path lists, one per articulation.

property max_dofs#

Maximum number of DOFs across all articulations.

Returns:: Maximum DOF count.

property max_fixed_tendons#

Maximum number of fixed tendons across all articulations.

Returns:: Maximum fixed tendon count.

property max_links#

Maximum number of links across all articulations.

Returns:: Maximum link count.

property max_shapes#

Maximum number of shapes across all articulations.

Returns:: Maximum shape count.

property prim_paths: list[str]#

Articulation root prim paths.

Returns:: List of articulation root paths.

property shared_metatype: Any | None#

Shared metadata type for articulations (if all same type).

Returns:: ArticulationMetaType object if all articulations have the same structure, None if different types or no articulations.

class NewtonRigidBodyView(backend: Any, frontend: Any)#

Bases: object

View for rigid bodies in Newton physics simulation.

Provides tensor-based access to rigid body properties like transforms, velocities, masses, etc.

Parameters:

backend – RigidBodySet backend instance from NewtonSimView.
frontend – Tensor framework frontend.

apply_forces( force_data: Any, indices: Any | None = None, is_global: bool = True, indices_mask: Any | None = None, )#

Apply forces to rigid bodies (deprecated, use apply_forces_and_torques_at_position).

Parameters:

force_data – Forces to apply, shape (count, 3).
indices – Indices of bodies to apply forces to. If None, applies to all bodies.
is_global – If True, forces are in global frame. If False, in body local frame.
indices_mask – Optional mask for the indices.

apply_forces_and_torques_at_position( force_data: Any | None, torque_data: Any | None, position_data: Any | None, indices: Any, is_global: bool = True, indices_mask: Any | None = None, )#

Apply forces and torques to rigid bodies at specified positions.

This function provides flexible force application with the following capabilities: - Apply forces at body center or at specified positions - Apply torques directly - Work in global or local coordinate frames - When position is specified with force, automatically computes induced torque

Parameters:

force_data – Forces to apply, shape (count, 3). Can be None.
torque_data – Torques to apply, shape (count, 3). Can be None.
position_data – Positions where forces are applied, shape (count, 3). Can be None. If specified with force_data, the force is applied at this position relative to the body’s center of mass, generating additional torque.
indices – Indices of bodies to apply forces to.
is_global – If True, force/torque/position are in global frame. If False, in body local frame.
indices_mask – Optional mask for the indices.

check() → bool#

Check if the rigid body view is valid and has bodies.

Returns:: True if the view has a valid backend with at least one body.

get_accelerations( copy: bool = True, ) → Any#

Get body accelerations [linear(3) + angular(3)].

Parameters:: copy – Whether to return a copy.
Returns:: Tensor of shape (count, 6). Currently returns velocities (Newton doesn’t expose accelerations directly).

get_coms(copy: bool = True) → Any#

Get body centers of mass [position(3) + orientation(4)].

Parameters:: copy – Whether to return a copy.
Returns:: Tensor of shape (count, 7). Newton stores COM as offset in body frame. Position is read from Newton, orientation is cached.

get_disable_gravities( copy: bool = True, ) → Any#

Get disable gravity flags for bodies.

Parameters:: copy – Whether to return a copy.
Returns:: Tensor of shape (count, 1) with uint8 values (0=gravity enabled, 1=gravity disabled). Newton doesn’t have per-body gravity flags; returns zeros (all enabled).

get_disable_simulations( copy: bool = True, ) → Any#

Get disable simulation flags for bodies.

Parameters:: copy – Whether to return a copy.
Returns:: Tensor of shape (count, 1) with uint8 values (0=enabled, 1=disabled). Newton doesn’t have a direct equivalent; returns zeros (all enabled).

get_inertias(copy: bool = True) → Any#

Get body inertias as flattened 3x3 matrices.

Parameters:: copy – Whether to return a copy.
Returns:: Tensor of shape (count, 9).

get_inv_inertias(copy: bool = True) → Any#

Get body inverse inertias as flattened 3x3 matrices.

Parameters:: copy – Whether to return a copy.
Returns:: Tensor of shape (count, 9).

get_inv_masses(copy: bool = True) → Any#

Get body inverse masses.

Parameters:: copy – Whether to return a copy.
Returns:: Tensor of shape (count,).

get_masses(copy: bool = True) → Any#

Get body masses.

Parameters:: copy – Whether to return a copy.
Returns:: Tensor of shape (count,).

get_transforms(copy: bool = True) → Any#

Get body transforms [position(3) + quaternion(4)].

Parameters:: copy – Whether to return a copy.
Returns:: Tensor of shape (count, 7).

get_velocities(copy: bool = True) → Any#

Get body velocities [linear(3) + angular(3)].

Parameters:: copy – Whether to return a copy.
Returns:: Tensor of shape (count, 6).

set_coms( data: Any, indices: Any, indices_mask: Any | None = None, )#

Set body centers of mass.

Position is written to Newton’s body_com. Orientation is cached in _coms buffer since Newton doesn’t support COM orientation.

Parameters:

data – COM data to set.
indices – Body indices.
indices_mask – Optional mask for indices.

set_disable_gravities( data: Any, indices: Any, indices_mask: Any | None = None, )#

Set disable gravity flags for bodies.

Newton doesn’t support per-body gravity disabling; this is a no-op.

Parameters:

data – Disable gravity flags to set.
indices – Body indices.
indices_mask – Optional mask for indices.

set_disable_simulations( data: Any, indices: Any, indices_mask: Any | None = None, )#

Set disable simulation flags for bodies.

Newton doesn’t support disabling individual bodies; this is a no-op.

Parameters:

data – Disable simulation flags to set.
indices – Body indices.
indices_mask – Optional mask for indices.

set_inertias( data: Any, indices: Any, indices_mask: Any | None = None, )#

Set body inertias.

Parameters:

data – Inertia data to set.
indices – Body indices.
indices_mask – Optional mask for indices.

set_masses( data: Any, indices: Any, indices_mask: Any | None = None, )#

Set body masses.

Parameters:

data – Mass data to set.
indices – Body indices.
indices_mask – Optional mask for indices.

set_transforms( data: Any, indices: Any, indices_mask: Any | None = None, )#

Set body transforms.

For free rigid bodies, this also updates their FREE joint coordinates.

Parameters:

data – Transform data to set.
indices – Body indices.
indices_mask – Optional mask for indices.

set_velocities( data: Any, indices: Any, indices_mask: Any | None = None, )#

Set body velocities.

Parameters:

data – Velocity data to set.
indices – Body indices.
indices_mask – Optional mask for indices.

update(dt: float)#

Update simulation timestamp.

Parameters:: dt – Time delta.

property body_names: list[str]#

List of names for the bodies.

Returns:: The names for the bodies.

property body_paths: list[str]#

List of USD paths for the bodies.

Returns:: The USD paths for the bodies.

property count: int#

Number of rigid bodies in this view.

Returns:: The count of rigid bodies.

property max_shapes: int#

Maximum number of shapes across all bodies.

Returns:: The maximum number of shapes.

class NewtonRigidContactView( backend: RigidContactSet, frontend: NumpyFrontend | TorchFrontend | WarpFrontend, )#

Bases: object

View for contact sensors in Newton physics simulation.

Provides tensor-based access to contact forces and contact data, matching PhysX IRigidContactView interface.

Parameters:

backend – RigidContactSet backend instance from NewtonSimView.
frontend – Tensor framework frontend.

check() → bool#

Check if the view is valid and has sensors.

Returns:: True if view has a valid backend and at least one sensor.

get_contact_data( dt: float, max_contact_data_count: int = 1000, copy: bool = True, )#

Get detailed contact data (forces, points, normals, separations).

Parameters:

dt – Time step for force calculation.
max_contact_data_count – Maximum number of contact points to store.
copy – Whether to return copies.

Returns:

A tuple of (contact_forces, contact_points, contact_normals, contact_separations, contact_counts, contact_start_indices) where:

contact_forces: shape (max_contact_data_count, 1) - normal force magnitudes
contact_points: shape (max_contact_data_count, 3) - world space contact positions
contact_normals: shape (max_contact_data_count, 3) - contact normals
contact_separations: shape (max_contact_data_count, 1) - penetration depths
contact_counts: shape (sensor_count, filter_count) - number of contacts per pair
contact_start_indices: shape (sensor_count, filter_count) - buffer start indices

get_contact_force_matrix( dt: float, copy: bool = True, ) → warp.array#

Get contact force matrix (sensor x filter).

Parameters:

dt – Time step for force calculation.
copy – Whether to return a copy.

Returns:

A tensor of shape (sensor_count, filter_count, 3).

get_net_contact_forces( dt: float, copy: bool = True, )#

Get net contact forces for each sensor.

Parameters:

dt – Time step for force calculation.
copy – Whether to return a copy.

Returns:

A tensor of shape (sensor_count, 3) with net contact forces.

update(dt: float)#

Update simulation timestamp.

Parameters:: dt – Time delta.

property count: int#

Number of contact sensors in this view.

Returns:: Number of contact sensors.

property filter_count: int#

Maximum number of filter bodies per sensor.

Returns:: Maximum number of filter bodies per sensor.

property filter_names: list[list[str]]#

List of filter names.

Returns:: List of filter names.

property filter_paths: list[list[str]]#

List of filter paths (list of lists, one list per sensor).

Returns:: List of filter paths with nested lists for each sensor.

property sensor_count: int#

Number of contact sensors.

Returns:: Number of contact sensors.

property sensor_names: list[str]#

List of sensor names.

Returns:: List of sensor names.

property sensor_paths: list[str]#

List of USD paths for sensors.

Returns:: List of USD paths for sensors.

Settings#

Extension Settings#

The table list the extension-specific settings.

Setting name	Description	Type	Default value
`capture_graph_physics_step`	Enable CUDA graph capture for physics stepping to improve GPU performance.	`bool`	`True`
`auto_switch_on_startup`	Automatically switch to the Newton physics engine when the extension starts.	`bool`	`True`

The extension-specific settings can be either specified (set) or retrieved (get) in one of the following ways:

Set setting

Command-line interface

Define the key and value of the setting as an application argument from a terminal.

APP_SCRIPT.(sh|bat) --/exts/isaacsim.physics.newton/SETTING_NAME=SETTING_VALUE

Experience/extension configuration

Define the key and value of the setting under [settings] in an experience (.kit) file or an extension configuration (extension.toml) file.

[settings]
exts."isaacsim.physics.newton".SETTING_NAME = SETTING_VALUE

By programming

Define the key and value of the setting using the carb framework (in Python).

import carb

settings = carb.settings.get_settings()
settings.set("/exts/isaacsim.physics.newton/SETTING_NAME", SETTING_VALUE)

Get setting

By programming

Define the key to query the value of the setting using the carb framework (in Python).

import carb

settings = carb.settings.get_settings()
value = settings.get("/exts/isaacsim.physics.newton/SETTING_NAME")