[isaacsim.core.simulation_manager] Isaac Sim Core Simulation Manager#

Version: 1.12.0

The Core Simulation Manager extension provides a set of APIs to control and query the simulation’s state and the different callbacks available.

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.core.simulation_manager

Experience/extension configuration

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

[dependencies]
"isaacsim.core.simulation_manager" = {}

Extension Manager UI

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

Usage#

Simulation Lifecycle#

The following diagram illustrates the simulation lifecycle and the events taking place within it. Refer to the SimulationEvent enum for more details.

These events can be triggered/operated from:

The application window, via the Play, Pause, and Stop buttons.
The Core Experimental API play(), pause(), and stop() utils functions, which are a thin and convenient wrapper around the omni.timeline API.

sequenceDiagram participant Timeline as Omniverse<br/>Timeline participant SimulationManager participant Consumers as Consumers<br/>(Extensions / Users) %% play Timeline->>+SimulationManager: PLAY Note over SimulationManager: Initialize Physics SimulationManager->>+Consumers: SIMULATION_SETUP #185; Consumers-->-SimulationManager: #160 SimulationManager->>+Consumers: SIMULATION_STARTED #178; Consumers-->-SimulationManager: #160 SimulationManager-->-Timeline: #160 %% pause opt Timeline->>+SimulationManager: PAUSE SimulationManager->>+Consumers: SIMULATION_PAUSED Consumers-->-SimulationManager: #160 SimulationManager-->-Timeline: #160 end %% resume opt Timeline->>+SimulationManager: PLAY SimulationManager->>+Consumers: SIMULATION_RESUMED Consumers-->-SimulationManager: #160 SimulationManager-->-Timeline: #160 end %% stop opt Timeline->>+SimulationManager: STOP Note over SimulationManager: Invalidate Physics SimulationManager->>+Consumers: SIMULATION_STOPPED Consumers-->-SimulationManager: #160 SimulationManager-->-Timeline: #160 end

Notes:

[1,2] When the application is played for the first time (or after being stopped), the SIMULATION_SETUP and the SIMULATION_STARTED events are triggered one after the other. The SIMULATION_SETUP event is used by the Isaac Sim Core extensions, among other extensions, to prepare the physics tensor entities, for example.

Therefore, from the user perspective and to avoid conflicts, it is recommended that the SIMULATION_STARTED event be used to carry out custom preparatory procedures just before the simulation progresses rather than the SIMULATION_SETUP.

API#

Python API#

`PhysicsScene`	Base class for manipulating a USD Physics Scene prim and its attributes.
`PhysxGpuCfg`	Configuration dataclass for PhysX GPU settings.
`PhysxScene`	PhysX-specific wrapper for manipulating a USD Physics Scene prim with PhysX attributes.
`SimulationEvent`	Simulation event types.
`SimulationManager`	This class provide functions that take care of many time-related events such as warm starting simulation in order for the physics data to be retrievable.
`IsaacEvents`	Isaac events types.

class PhysicsScene(prim: str | Usd.Prim)#

Bases: object

Base class for manipulating a USD Physics Scene prim and its attributes.

This class provides common functionality for working with USD Physics Scene prims, including Newton-common attributes that are applied by default to all physics scenes.

Parameters:: prim – USD Physics Scene prim path or prim instance. If the input is a path, a new USD Physics Scene prim is created if it does not exist.
Raises:: ValueError – If the input prim exists and is not a USD Physics Scene prim.

get_dt() → float#

Get the Physics Scene’s delta time (DT).

Returns:: Physics Scene’s delta time (DT).

Example:

>>> physics_scene.get_dt()
0.001

get_enabled_gravity() → bool#

Get whether gravity is enabled for the Physics Scene.

Returns:: True if gravity is enabled, False otherwise.

Example:

>>> physics_scene.get_enabled_gravity()
True

get_gravity() → pxr.Gf.Vec3f#

Get the Physics Scene’s gravity vector.

Returns:: Gravity vector in world units per second squared.

Example:

>>> physics_scene.get_gravity()
Gf.Vec3f(0.0, 0.0, -9.81)

get_max_solver_iterations() → int#

Get the maximum number of solver iterations for the Physics Scene.

Returns:: Maximum number of solver iterations. -1 means the solver chooses the default.

Example:

>>> physics_scene.get_max_solver_iterations()
-1

static get_physics_scene_paths( stage: Usd.Stage | None = None, ) → list[str]#

Get the paths of all USD Physics Scene prims in the stage.

Parameters:: stage – USD stage to search for Physics Scene prims. If None, the current stage is used.
Returns:: List of USD Physics Scene prim paths.

Example:

>>> from isaacsim.core.simulation_manager import PhysicsScene
>>>
>>> PhysicsScene.get_physics_scene_paths()
['/World/physicsScene']

set_dt(dt: float) → None#

Set the Physics Scene’s delta time (DT).

Parameters:: dt – Physics Scene’s delta time (DT).
Raises:: ValueError – If the delta time (DT) is less than 0 or greater than 1.0.

Example:

>>> physics_scene.set_dt(0.001)

set_enabled_gravity(enabled: bool) → None#

Enable or disable gravity for the Physics Scene.

Parameters:: enabled – True to enable gravity, False to disable.

Example:

>>> physics_scene.set_enabled_gravity(False)

set_gravity( gravity: Gf.Vec3f | tuple[float, float, float] | list[float], ) → None#

Set the Physics Scene’s gravity vector.

Parameters:: gravity – Gravity vector in world units per second squared.

Example:

>>> physics_scene.set_gravity(Gf.Vec3f(0.0, 0.0, -9.81))

set_max_solver_iterations(iterations: int) → None#

Set the maximum number of solver iterations for the Physics Scene.

Parameters:: iterations – Maximum number of solver iterations. Set to -1 to use solver default.
Raises:: ValueError – If the iterations is less than -1.

Example:

>>> physics_scene.set_max_solver_iterations(100)

property path: str#

USD Physics Scene prim path.

Returns:: Prim path encapsulated by the wrapper.

Example:

>>> physics_scene.path
'/World/physicsScene'

property physics_scene: pxr.UsdPhysics.Scene#

USD Physics Scene instance.

Returns:: Physics Scene instance encapsulated by the wrapper.

Example:

>>> physics_scene.physics_scene
UsdPhysics.Scene(Usd.Prim(</World/physicsScene>))

property prim: pxr.Usd.Prim#

USD Physics Scene prim instance.

Returns:: Prim instance encapsulated by the wrapper.

Example:

>>> physics_scene.prim
Usd.Prim(</World/physicsScene>)

class PhysxGpuCfg( *, gpu_collision_stack_size: int | None = None, gpu_found_lost_aggregate_pairs_capacity: int | None = None, gpu_found_lost_pairs_capacity: int | None = None, gpu_heap_capacity: int | None = None, gpu_max_deformable_surface_contacts: int | None = None, gpu_max_num_partitions: int | None = None, gpu_max_particle_contacts: int | None = None, gpu_max_rigid_contact_count: int | None = None, gpu_max_rigid_patch_count: int | None = None, gpu_max_soft_body_contacts: int | None = None, gpu_temp_buffer_capacity: int | None = None, gpu_total_aggregate_pairs_capacity: int | None = None, )#

Bases: object

Configuration dataclass for PhysX GPU settings.

All fields are optional. When set to None, the corresponding setting is not modified.

gpu_collision_stack_size: int | None = None#

gpu_found_lost_aggregate_pairs_capacity: int | None = None#

gpu_found_lost_pairs_capacity: int | None = None#

gpu_heap_capacity: int | None = None#

gpu_max_deformable_surface_contacts: int | None = None#

gpu_max_num_partitions: int | None = None#

gpu_max_particle_contacts: int | None = None#

gpu_max_rigid_contact_count: int | None = None#

gpu_max_rigid_patch_count: int | None = None#

gpu_max_soft_body_contacts: int | None = None#

gpu_temp_buffer_capacity: int | None = None#

gpu_total_aggregate_pairs_capacity: int | None = None#

class PhysxScene(prim: str | Usd.Prim)#

Bases: PhysicsScene

PhysX-specific wrapper for manipulating a USD Physics Scene prim with PhysX attributes.

This class extends PhysicsScene to provide PhysX-specific functionality including solver configuration, GPU dynamics, CCD, and other PhysX-specific settings.

Parameters:: prim – USD Physics Scene prim path or prim instance. If the input is a path, a new USD Physics Scene prim is created if it does not exist.
Raises:: ValueError – If the input prim exists and is not a USD Physics Scene prim.

Example:

>>> from isaacsim.core.simulation_manager import PhysxScene
>>>
>>> physx_scene = PhysxScene("/World/physicsScene")

get_broadphase_type() → Literal['MBP', 'GPU', 'SAP']#

Get the PhysX Scene’s broadphase type.

Returns:: PhysX Scene’s broadphase type.
Raises:: RuntimeError – If the Physics Scene has no ‘PhysxSceneAPI’ applied.

Example:

>>> physx_scene.get_broadphase_type()
'GPU'

get_dt() → float#

Get the PhysX Scene’s delta time (DT).

This method is a convenience method to get the delta time (DT) from the steps per second returned by the get_steps_per_second() method.

Warning

Due to truncation of values in the steps-per-second (int) – delta-time (float) conversion process, the delta time returned by this method might not be exactly the same as that established via the set_dt() method.

Returns:: PhysX Scene’s delta time (DT).
Raises:: RuntimeError – If the Physics Scene has no ‘PhysxSceneAPI’ applied.

Example:

>>> physx_scene.get_dt()
0.01666666...

get_enabled_ccd() → bool#

Get the enabled state of the PhysX Scene’s Continuous Collision Detection (CCD).

Returns:: Boolean flag indicating if the PhysX Scene’s CCD is enabled.
Raises:: RuntimeError – If the Physics Scene has no ‘PhysxSceneAPI’ applied.

Example:

>>> physx_scene.get_enabled_ccd()
False

get_enabled_gpu_dynamics() → bool#

Get the enabled state of the PhysX Scene’s GPU dynamics.

Returns:: Boolean flag indicating if the PhysX Scene’s GPU dynamics is enabled.
Raises:: RuntimeError – If the Physics Scene has no ‘PhysxSceneAPI’ applied.

Example:

>>> physx_scene.get_enabled_gpu_dynamics()
True

get_enabled_gravity() → bool#

Get whether gravity is enabled for the Physics Scene.

Returns:: True if gravity is enabled, False otherwise.

Example:

>>> physics_scene.get_enabled_gravity()
True

get_enabled_stabilization() → bool#

Get the enabled state of the PhysX Scene’s stabilization.

Returns:: Boolean flag indicating if the PhysX Scene’s stabilization is enabled.
Raises:: RuntimeError – If the Physics Scene has no ‘PhysxSceneAPI’ applied.

Example:

>>> physx_scene.get_enabled_stabilization()
False

get_gpu_configuration() → PhysxGpuCfg#

Get the PhysX Scene’s GPU configuration.

Returns:: PhysX Scene’s GPU configuration.
Raises:: RuntimeError – If the Physics Scene has no ‘PhysxSceneAPI’ applied.

Example:

>>> physx_scene.get_gpu_configuration()
PhysxGpuCfg(gpu_collision_stack_size=67108864,
    gpu_found_lost_aggregate_pairs_capacity=1024, gpu_found_lost_pairs_capacity=262144,
    gpu_heap_capacity=67108864, gpu_max_deformable_surface_contacts=1048576,
    gpu_max_num_partitions=8, gpu_max_particle_contacts=1048576,
    gpu_max_rigid_contact_count=524288, gpu_max_rigid_patch_count=81920,
    gpu_max_soft_body_contacts=1048576, gpu_temp_buffer_capacity=16777216,
    gpu_total_aggregate_pairs_capacity=1024)

get_gravity() → pxr.Gf.Vec3f#

Get the Physics Scene’s gravity vector.

Returns:: Gravity vector in world units per second squared.

Example:

>>> physics_scene.get_gravity()
Gf.Vec3f(0.0, 0.0, -9.81)

get_max_solver_iterations() → int#

Get the maximum number of solver iterations for the Physics Scene.

Returns:: Maximum number of solver iterations. -1 means the solver chooses the default.

Example:

>>> physics_scene.get_max_solver_iterations()
-1

static get_physics_scene_paths( stage: Usd.Stage | None = None, ) → list[str]#

Get the paths of all USD Physics Scene prims in the stage.

Parameters:: stage – USD stage to search for Physics Scene prims. If None, the current stage is used.
Returns:: List of USD Physics Scene prim paths.

Example:

>>> from isaacsim.core.simulation_manager import PhysicsScene
>>>
>>> PhysicsScene.get_physics_scene_paths()
['/World/physicsScene']

get_solver_type() → Literal['TGS', 'PGS']#

Get the PhysX Scene’s solver type.

Returns:: PhysX Scene’s solver type.
Raises:: RuntimeError – If the Physics Scene has no ‘PhysxSceneAPI’ applied.

Example:

>>> physx_scene.get_solver_type()
'TGS'

get_steps_per_second() → int#

Get the PhysX Scene’s steps per second.

Returns:: PhysX Scene’s steps per second.
Raises:: RuntimeError – If the Physics Scene has no ‘PhysxSceneAPI’ applied.

Example:

>>> physx_scene.get_steps_per_second()
60

set_broadphase_type( broadphase_type: Literal['MBP', 'GPU', 'SAP'], ) → None#

Set the PhysX Scene’s broadphase type.

Parameters:

broadphase_type – PhysX Scene’s broadphase type.

Raises:

RuntimeError – If the Physics Scene has no ‘PhysxSceneAPI’ applied.
ValueError – If the broadphase type is not a supported value.

Example:

>>> physx_scene.set_broadphase_type('MBP')

set_dt(dt: float) → None#

Set the PhysX Scene’s delta time (DT).

This method is a convenience method to set the delta time (DT) by computing the steps per second and setting it via the set_steps_per_second() method.

Warning

Due to truncation of values in the steps-per-second (int) – delta-time (float) conversion process, the delta time set by this method might not be exactly the same as that returned by the get_dt() method.

Parameters:

dt – PhysX Scene’s delta time (DT).

Raises:

RuntimeError – If the Physics Scene has no ‘PhysxSceneAPI’ applied.
ValueError – If the delta time (DT) is less than 0 or greater than 1.0.

Example:

>>> physx_scene.set_dt(0.00833333)

set_enabled_ccd(enabled: bool) → None#

Enable or disable the PhysX Scene’s Continuous Collision Detection (CCD).

Parameters:: enabled – Boolean flag to enable/disable the PhysX Scene’s CCD.
Raises:: RuntimeError – If the Physics Scene has no ‘PhysxSceneAPI’ applied.

Example:

>>> physx_scene.set_enabled_ccd(True)

set_enabled_gpu_dynamics(enabled: bool) → None#

Enable or disable the PhysX Scene’s GPU dynamics.

Note

If GPU dynamics is enabled, the Continuous Collision Detection (CCD) will be automatically disabled as it is not supported.

Parameters:: enabled – Boolean flag to enable/disable the PhysX Scene’s GPU dynamics.
Raises:: RuntimeError – If the Physics Scene has no ‘PhysxSceneAPI’ applied.

Example:

>>> physx_scene.set_enabled_gpu_dynamics(False)

set_enabled_gravity(enabled: bool) → None#

Enable or disable gravity for the Physics Scene.

Parameters:: enabled – True to enable gravity, False to disable.

Example:

>>> physics_scene.set_enabled_gravity(False)

set_enabled_stabilization(enabled: bool) → None#

Enable or disable the PhysX Scene’s stabilization.

Parameters:: enabled – Boolean flag to enable/disable the PhysX Scene’s stabilization.
Raises:: RuntimeError – If the Physics Scene has no ‘PhysxSceneAPI’ applied.

Example:

>>> physx_scene.set_enabled_stabilization(True)

set_gpu_configuration( cfg: PhysxGpuCfg | dict, ) → None#

Set the PhysX Scene’s GPU configuration.

Parameters:: cfg – PhysX Scene’s GPU configuration.
Raises:: RuntimeError – If the Physics Scene has no ‘PhysxSceneAPI’ applied.

Example:

>>> from isaacsim.core.simulation_manager import PhysxGpuCfg
>>>
>>> physx_scene.set_gpu_configuration(PhysxGpuCfg(gpu_max_num_partitions=16))

set_gravity( gravity: Gf.Vec3f | tuple[float, float, float] | list[float], ) → None#

Set the Physics Scene’s gravity vector.

Parameters:: gravity – Gravity vector in world units per second squared.

Example:

>>> physics_scene.set_gravity(Gf.Vec3f(0.0, 0.0, -9.81))

set_max_solver_iterations(iterations: int) → None#

Set the maximum number of solver iterations for the Physics Scene.

Parameters:: iterations – Maximum number of solver iterations. Set to -1 to use solver default.
Raises:: ValueError – If the iterations is less than -1.

Example:

>>> physics_scene.set_max_solver_iterations(100)

set_solver_type( solver_type: Literal['TGS', 'PGS'], ) → None#

Set the PhysX Scene’s solver type.

Parameters:

solver_type – PhysX Scene’s solver type.

Raises:

RuntimeError – If the Physics Scene has no ‘PhysxSceneAPI’ applied.
ValueError – If the solver type is not a supported value.

Example:

>>> physx_scene.set_solver_type('PGS')

set_steps_per_second(steps_per_second: int) → None#

Set the PhysX Scene’s steps per second.

Parameters:

steps_per_second – PhysX Scene’s steps per second.

Raises:

RuntimeError – If the Physics Scene has no ‘PhysxSceneAPI’ applied.
ValueError – If the steps per second is less than 0.

Example:

>>> physx_scene.set_steps_per_second(120)

property path: str#

USD Physics Scene prim path.

Returns:: Prim path encapsulated by the wrapper.

Example:

>>> physics_scene.path
'/World/physicsScene'

property physics_scene: pxr.UsdPhysics.Scene#

USD Physics Scene instance.

Returns:: Physics Scene instance encapsulated by the wrapper.

Example:

>>> physics_scene.physics_scene
UsdPhysics.Scene(Usd.Prim(</World/physicsScene>))

property prim: pxr.Usd.Prim#

USD Physics Scene prim instance.

Returns:: Prim instance encapsulated by the wrapper.

Example:

>>> physics_scene.prim
Usd.Prim(</World/physicsScene>)

class SimulationEvent( value, names=<not given>, *values, module=None, qualname=None, type=None, start=1, boundary=None, )#

Simulation event types.

PHYSICS_POST_STEP = 'isaacsim.simulation.physics_post_step'#: Event triggered after a physics step is performed.

PHYSICS_PRE_STEP = 'isaacsim.simulation.physics_pre_step'#: Event triggered before a physics step is performed.

PRIM_DELETED = 'isaacsim.simulation.prim_deleted'#: Event triggered when a prim is deleted from the stage.

SIMULATION_PAUSED = 'isaacsim.simulation.paused'#: Event triggered when the simulation is paused.

SIMULATION_RESUMED = 'isaacsim.simulation.resumed'#

Event triggered when the simulation is resumed.

The simulation is resumed when the application is played again after being paused.

SIMULATION_SETUP = 'isaacsim.simulation.simulation_setup'#

Event triggered when the simulation setup is complete.

The simulation setup is complete once 1) the application has been played and 2) a warm-up step has been performed. The warm-up step ensures that:

The physics engine creates and initializes its internal state for the attached stage.
An entry point to the physics engine is created through omni.physics.tensors.

At that point, the simulation is ready to advance.

SIMULATION_STARTED = 'isaacsim.simulation.started'#: Event triggered when the simulation setup is complete and the simulation is ready to advance.

SIMULATION_STOPPED = 'isaacsim.simulation.stopped'#: Event triggered when the simulation is stopped.

class SimulationManager#

Bases: object

This class provide functions that take care of many time-related events such as warm starting simulation in order for the physics data to be retrievable. Adding/ removing callback functions that gets triggered with certain events such as a physics step, on post reset, on physics ready..etc.

classmethod assets_loading() → bool#

Check if the textures of the assets are being loaded.

Returns:: True if the textures of the assets are loading and have not finished yet, otherwise False.

Example:

>>> from isaacsim.core.simulation_manager import SimulationManager
>>>
>>> SimulationManager.assets_loading()
False

classmethod deregister_all_callbacks() → None#

Deregister all callbacks registered via register_callback().

Example:

>>> from isaacsim.core.simulation_manager import SimulationManager
>>>
>>> SimulationManager.deregister_all_callbacks()

classmethod deregister_callback(uid: int) → bool#

Deregister a callback registered via register_callback().

Parameters:: uid – The unique identifier of the callback to deregister. If the unique identifier does not exist or has already been deregistered, a warning is logged and the method does nothing.
Returns:: True if the callback was successfully deregistered, False otherwise.

Example:

>>> from isaacsim.core.simulation_manager import SimulationManager
>>>
>>> # deregister the callback with the unique identifier 0
>>> SimulationManager.deregister_callback(0)
True

classmethod enable_all_default_callbacks( enable: bool = True, ) → None#

Enable or disable all default callbacks.

Parameters:: enable – Whether to enable/disable all default callbacks.

classmethod enable_ccd( flag: bool, physics_scene: str = None, ) → None#

Enables Continuous Collision Detection (CCD).

Deprecated since version 1.8.0:
Use the set_enabled_ccd() method instead for each targeted Physics Scene.

Parameters:

flag (bool) – enables or disables CCD on the PhysicsScene.
physics_scene (str, optional) – physics scene prim path.

Raises:

Exception – If the prim path registered in context doesn’t correspond to a valid prim path currently.

classmethod enable_default_callbacks( *, enable_warm_start: bool | None = None, enable_on_stop: bool | None = None, enable_stage_open: bool | None = None, enable_stage_close: bool | None = None, ) → None#

Enable or disable the default callbacks.

Parameters:

enable_warm_start – Whether to enable/disable the warm start callback.
enable_on_stop – Whether to enable/disable the on stop callback.
enable_stage_open – Whether to enable/disable the stage open callback.
enable_stage_close – Whether to enable/disable the stage close callback.

classmethod enable_fabric(enable: bool) → None#

Enable or disable physics fabric integration and associated settings.

Note

This only applies to PhysX. For other physics engines (like Newton), this is a no-op since they handle fabric/USD updates differently.

Parameters:: enable – Whether to enable or disable fabric.

Example:

>>> from isaacsim.core.simulation_manager import SimulationManager
>>>
>>> SimulationManager.enable_fabric(True)

classmethod enable_fabric_usd_notice_handler( stage_id, enable: bool, ) → None#

Enable or disable the fabric USD notice handler.

Parameters:

stage_id – The stage ID to enable or disable the handler for.
enable – Whether to enable or disable the fabric USD notice handler.

Example:

>>> import isaacsim.core.experimental.utils.stage as stage_utils
>>> from isaacsim.core.simulation_manager import SimulationManager
>>>
>>> stage_id = stage_utils.get_stage_id(stage_utils.get_current_stage())
>>> SimulationManager.enable_fabric_usd_notice_handler(stage_id, True)

classmethod enable_gpu_dynamics( flag: bool, physics_scene: str = None, ) → None#

Enables gpu dynamics pipeline, required for deformables for instance.

Deprecated since version 1.8.0:
Use the set_enabled_gpu_dynamics() method instead for each targeted Physics Scene.

Parameters:

flag (bool) – enables or disables gpu dynamics on the PhysicsScene. If flag is true, CCD is disabled.
physics_scene (str, optional) – physics scene prim path.

Raises:

Exception – If the prim path registered in context doesn’t correspond to a valid prim path currently.

classmethod enable_on_stop_callback(enable: bool = True) → None#

Enable or disable the on stop callback.

Deprecated since version 1.8.0:
Use the enable_default_callbacks() method instead.

Parameters:: enable – Whether to enable the callback.

classmethod enable_post_warm_start_callback( enable: bool = True, ) → None#

Enable or disable the post warm start callback.

Deprecated since version 1.8.0:
The PHYSICS_WARMUP event is deprecated. Calling this method will have no effect.

Parameters:: enable – Whether to enable the callback.

classmethod enable_stablization( flag: bool, physics_scene: str = None, ) → None#

Enables additional stabilization pass in the solver.

Deprecated since version 1.8.0:
Use the set_enabled_stabilization() method instead for each targeted Physics Scene.

Parameters:

flag (bool) – enables or disables stabilization on the PhysicsScene
physics_scene (str, optional) – physics scene prim path.

Raises:

Exception – If the prim path registered in context doesn’t correspond to a valid prim path currently.

classmethod enable_stage_open_callback( enable: bool = True, ) → None#

Enable or disable the stage open callback.

Deprecated since version 1.8.0:
Use the enable_default_callbacks() method instead.

Note: This also enables/disables the assets loading and loaded callbacks. If disabled, assets_loading() will always return True.

Parameters:: enable – Whether to enable the callback.

classmethod enable_usd_notice_handler(enable: bool) → None#

Enable or disable the USD notice handler.

If the USD notice handler is disabled, the simulation manager will not receive USD notice events when a new Physics Scene is added/removed or when a prim is deleted (in such case, the simulation manager will not trigger the PRIM_DELETED event).

Parameters:: enable – Whether to enable or disable the USD notice handler.

Example:

>>> from isaacsim.core.simulation_manager import SimulationManager
>>>
>>> SimulationManager.enable_usd_notice_handler(True)

classmethod enable_warm_start_callback( enable: bool = True, ) → None#

Enable or disable the warm start callback.

Deprecated since version 1.8.0:
Use the enable_default_callbacks() method instead.

Parameters:: enable – Whether to enable the callback.

classmethod get_active_physics_engine() → Literal['physx']#

Get the currently active physics engine.

Returns:: Currently active engine name.

classmethod 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. Defaults to False.
Returns:: List of tuples (engine_name, is_active) for all registered engines.

classmethod get_backend() → str#: Get the backend used by the simulation manager.

Deprecated since version 1.8.0:
No replacement is provided, as the core experimental API relies solely on Warp.

classmethod get_broadphase_type( physics_scene: str = None, ) → str#

Gets current broadcast phase algorithm type.

Deprecated since version 1.8.0:
Use the get_broadphase_type() method instead for each targeted Physics Scene.

Parameters:: physics_scene (str, optional) – physics scene prim path.
Raises:: Exception – If the prim path registered in context doesn’t correspond to a valid prim path currently.
Returns:: Broadcast phase algorithm used.
Return type:: str

classmethod get_default_callback_status() → dict#

Get the status of all default callbacks.

Default callbacks names are: warm_start, on_stop, stage_open, stage_close.

Returns:: Dictionary with callback names and their enabled status.

classmethod get_default_engine() → str#

Get the default physics engine from settings.

Returns:: Default engine name from settings, or empty string if not set.

classmethod get_default_physics_scene() → str#

Get the default physics scene.

Deprecated since version 1.8.0:
No replacement is provided, as there is no default physics scene.

Returns:: The path to the default physics scene.

classmethod get_device() → warp.Device#

Get the simulation device.

Returns:: Simulation device.

Example:

>>> from isaacsim.core.simulation_manager import SimulationManager
>>>
>>> device = SimulationManager.get_device()
>>> print(type(device), device)
<class 'warp._src.context.Device'> cpu

classmethod get_num_physics_steps() → int#

Get the current number of physics steps performed.

Returns:: The current number of physics steps.

Example:

>>> from isaacsim.core.simulation_manager import SimulationManager
>>>
>>> SimulationManager.get_num_physics_steps()
2

classmethod get_physics_dt(physics_scene: str = None) → float#

Returns the current physics dt.

Deprecated since version 1.8.0:
Use the get_dt() method or the get_steps_per_second() method instead for each targeted Physics Scene.

Parameters:: physics_scene (str, optional) – physics scene prim path.
Raises:: Exception – If the prim path registered in context doesn’t correspond to a valid prim path currently.
Returns:: physics dt.
Return type:: float

classmethod get_physics_scenes() → list[PhysicsScene]#

Get the available physics scenes.

Returns:: List of physics scenes.

Example:

>>> from isaacsim.core.simulation_manager import SimulationManager, PhysicsScene
>>>
>>> SimulationManager.get_physics_scenes()
[<isaacsim.core.simulation_manager.impl.physx_scene.PhysxScene object at 0x...>]

classmethod get_physics_sim_device() → str#: Get the physics simulation device.

Deprecated since version 1.8.0:
Use the get_device() method instead.

classmethod get_physics_sim_view()#

Get the physics simulation view.

Deprecated since version 1.8.0:
Use the get_physics_simulation_view() method instead.

Returns:: Physics simulation view.

classmethod get_physics_simulation_view() → 'SimulationView' | None#

Get the physics (tensor API) simulation view.

Returns:: Physics (tensor API) simulation view, or None if the physics is not initialized.

Example:

>>> from isaacsim.core.simulation_manager import SimulationManager
>>>
>>> SimulationManager.get_physics_simulation_view()
<omni.physics.tensors.impl.api.SimulationView object at 0x...>

classmethod get_simulation_time() → float#

Get the current simulation time.

Returns:: The current simulation time.

Example:

>>> from isaacsim.core.simulation_manager import SimulationManager
>>>
>>> SimulationManager.get_simulation_time()
0.0333...

classmethod get_solver_type(physics_scene: str = None) → str#

Gets current solver type.

Deprecated since version 1.8.0:
Use the get_solver_type() method instead for each targeted Physics Scene.

Parameters:: physics_scene (str, optional) – physics scene prim path.
Raises:: Exception – If the prim path registered in context doesn’t correspond to a valid prim path currently.
Returns:: solver used for simulation.
Return type:: str

classmethod initialize_physics() → None#

Initialize Physics.

Important

This method is called automatically when the simulation runs (i.e., when the timeline is played). Therefore, it is not intended to be called directly unless a manual initialization is desired/required.

This method initializes the physics engine by loading physics from USD and starting the engine simulation. It also creates the physics simulation view required by the Isaac Sim Core extensions. After initializing physics, the SIMULATION_SETUP event is dispatched.

classmethod invalidate_physics() → None#

Invalidate Physics.

Important

This method is called automatically when the simulation stops (i.e., when the timeline is stopped). Therefore, it is not intended to be called directly unless a manual invalidation is desired/required.

This method invalidates the physics simulation view and resets the internal state in preparation for a new simulation cycle.

classmethod is_ccd_enabled(physics_scene: str = None) → bool#

Checks if Continuous Collision Detection (CCD) is enabled.

Deprecated since version 1.8.0:
Use the get_enabled_ccd() method instead for each targeted Physics Scene.

Parameters:: physics_scene (str, optional) – physics scene prim path.
Raises:: Exception – If the prim path registered in context doesn’t correspond to a valid prim path currently.
Returns:: True if CCD is enabled, otherwise False.
Return type:: bool

classmethod is_default_callback_enabled( callback_name: str, ) → bool#

Check if a specific default callback is enabled.

Default callbacks names are: warm_start, on_stop, stage_open, stage_close.

Parameters:: callback_name – Name of the callback to check.
Returns:: Whether the callback is enabled.

classmethod is_fabric_enabled() → bool#

Check if fabric is enabled.

Returns:: True if fabric is enabled, otherwise False.
Return type:: bool

Example:

>>> from isaacsim.core.simulation_manager import SimulationManager
>>>
>>> SimulationManager.is_fabric_enabled()
True

classmethod is_fabric_usd_notice_handler_enabled(stage_id)#

Check if the fabric USD notice handler is enabled.

Parameters:: stage_id – The stage ID to check for.
Returns:: True if the fabric USD notice handler is enabled, otherwise False.

Example:

>>> import isaacsim.core.experimental.utils.stage as stage_utils
>>> from isaacsim.core.simulation_manager import SimulationManager
>>>
>>> stage_id = stage_utils.get_stage_id(stage_utils.get_current_stage())
>>> SimulationManager.is_fabric_usd_notice_handler_enabled(stage_id)
True

classmethod is_gpu_dynamics_enabled( physics_scene: str = None, ) → bool#

Checks if Gpu Dynamics is enabled.

Deprecated since version 1.8.0:
Use the get_enabled_gpu_dynamics() method instead for each targeted Physics Scene.

Parameters:: physics_scene (str, optional) – physics scene prim path.
Raises:: Exception – If the prim path registered in context doesn’t correspond to a valid prim path currently.
Returns:: True if Gpu Dynamics is enabled, otherwise False.
Return type:: bool

classmethod is_paused() → bool#

Check if the simulation is currently paused.

Returns:: True if the simulation is paused, False otherwise.

Example:

>>> from isaacsim.core.simulation_manager import SimulationManager
>>>
>>> SimulationManager.is_paused()
False

classmethod is_simulating() → bool#

Check if the simulation is currently running.

Returns:: True if the simulation is running, False otherwise.

Example:

>>> from isaacsim.core.simulation_manager import SimulationManager
>>>
>>> SimulationManager.is_simulating()
True

classmethod is_stablization_enabled( physics_scene: str = None, ) → bool#

Checks if stabilization is enabled.

Deprecated since version 1.8.0:
Use the get_enabled_stabilization() method instead for each targeted Physics Scene.

Parameters:: physics_scene (str, optional) – physics scene prim path.
Raises:: Exception – If the prim path registered in context doesn’t correspond to a valid prim path currently.
Returns:: True if stabilization is enabled, otherwise False.
Return type:: bool

classmethod register_callback(

callback: Callable,

event: SimulationEvent | IsaacEvents,

*,

order: int = 0,

**kwargs,

) → int#

Register/subscribe a callback to be triggered when a specific simulation event occurs.

Warning

The parameter name is not longer supported. A warning message will be logged if it is defined. Future versions will completely remove it. At that time, defining it will result in an exception.

Parameters:

callback – The callback function.
event – The simulation event to subscribe to.
order – The subscription order. Callbacks registered within the same order will be triggered in the order they were registered.

Returns:

The unique identifier of the callback subscription.

Raises:

ValueError – If event is invalid.

Example:

>>> from isaacsim.core.simulation_manager import SimulationEvent, SimulationManager
>>>
>>> def callback(dt, context):
...     print(dt, context)
...
>>> # subscribe to the PHYSICS_POST_STEP event
>>> callback_id = SimulationManager.register_callback(callback, event=SimulationEvent.PHYSICS_POST_STEP)
>>> callback_id
2
>>> # perform a physics step in order to trigger the callback and print the event
>>> SimulationManager.step()
0.01666... <omni.physics.core.bindings._physics.PhysicsStepContext object at 0x...>
>>>
>>> # deregister all callbacks
>>> SimulationManager.deregister_all_callbacks()

classmethod set_backend(val: str) → None#: Set the backend used by the simulation manager.

Deprecated since version 1.8.0:
No replacement is provided, as the core experimental API relies solely on Warp.

classmethod set_broadphase_type( val: str, physics_scene: str = None, ) → None#

Broadcast phase algorithm used in simulation.

Deprecated since version 1.8.0:
Use the set_broadphase_type() method instead for each targeted Physics Scene.

Parameters:

val (str) – type of broadcasting to be used, can be “MBP”.
physics_scene (str, optional) – physics scene prim path.

Raises:

Exception – If the prim path registered in context doesn’t correspond to a valid prim path currently.

classmethod set_default_physics_scene( physics_scene_prim_path: str, )#

Set the default physics scene.

Deprecated since version 1.8.0:
No replacement is provided, as there is no default physics scene.

Parameters:: physics_scene_prim_path – The path to the physics scene prim.

classmethod set_device(device: str | wp.Device) → None#

Set the simulation device.

Parameters:: device – Simulation device.
Raises:: ValueError – If the device is invalid.

Example:

>>> from isaacsim.core.simulation_manager import SimulationManager
>>>
>>> SimulationManager.set_device("cuda:0")

classmethod set_physics_dt( dt: float = 0.016666666666666666, physics_scene: str = None, ) → None#

Sets the physics dt on the physics scene provided.

Deprecated since version 1.8.0:
Use the set_dt() method or the set_steps_per_second() method instead for each targeted Physics Scene.

Parameters:

dt (float, optional) – physics dt. Defaults to 1.0/60.0.
physics_scene (str, optional) – physics scene prim path. Defaults to first physics scene found in the stage.

Raises:

RuntimeError – If the simulation is running/playing and dt is being set.
Exception – If the prim path registered in context doesn’t correspond to a valid prim path currently.
ValueError – If the dt is not in the range [0.0, 1.0].

classmethod set_physics_sim_device(val) → None#

Set the physics simulation device.

Deprecated since version 1.8.0:
Use the set_device() method instead.

Parameters:: val – Physics simulation device.

classmethod set_solver_type( solver_type: str, physics_scene: str = None, ) → None#

solver used for simulation.

Deprecated since version 1.8.0:
Use the set_solver_type() method instead for each targeted Physics Scene.

Parameters:

solver_type (str) – can be “TGS” or “PGS”.
physics_scene (str, optional) – physics scene prim path.

Raises:

Exception – If the prim path registered in context doesn’t correspond to a valid prim path currently.

classmethod setup_simulation( dt: float | None = None, device: str | wp.Device | None = None, ) → None#

Setup the (physics) simulation.

Hint

This method is a convenient implementation that allows for quick configuration of the simulation in one go. Same behavior can be achieved by calling other individual methods in sequence.

Parameters:

dt – Physics delta time (DT).
device – Physics simulation device.

Example:

>>> from isaacsim.core.simulation_manager import SimulationManager
>>>
>>> SimulationManager.setup_simulation(dt=1.0 / 60.0, device="cuda:0")

classmethod step( *, steps: int = 1, callback: Callable[[int, int], bool | None] | None = None, update_fabric: bool = False, ) → None#

Step the physics simulation.

Parameters:

steps – Number of steps to perform.
callback – Optional callback function to call after each step. The function should take two arguments: the current step number and the total number of steps. If no return value is provided, the internal loop will run for the specified number of steps. However, if the function returns False, no more steps will be performed.
update_fabric – Whether to update fabric with the latest physics results after each step.

Raises:

ValueError – If the fabric is not enabled and update_fabric is set to True.

Example:

>>> from isaacsim.core.simulation_manager import SimulationManager
>>>
>>> # perform one physics step
>>> SimulationManager.step(steps=1)
>>>
>>> # perform 10 physics steps
>>> SimulationManager.step(steps=10)
>>>
>>> # perform 10 physics steps with a callback
>>> def callback(step, steps):
...     print(f"physics step {step}/{steps}")
...     return step < 3  # stop after 3 steps (return False to break the loop)
...
>>> SimulationManager.step(steps=10, callback=callback)
physics step 1/10
physics step 2/10
physics step 3/10

classmethod switch_physics_engine( engine_name: Literal['physx', 'newton'], verbose: bool = False, ) → bool#

Switch to a specific physics engine.

Parameters:

engine_name – Name of the engine to switch to.
verbose – If True, log switch details to console. Defaults to False.

Returns:

True if switch was successful, False otherwise.

class IsaacEvents( value, names=<not given>, *values, module=None, qualname=None, type=None, start=1, boundary=None, )#

Bases: Enum

Isaac events types.

Deprecated since version 1.7.0: Use SimulationEvent enum instead.

PHYSICS_READY = 'isaac.physics_ready'#: Physics ready.

Deprecated since version 1.7.0: Use SimulationEvent’s SIMULATION_STARTED instead.

PHYSICS_WARMUP = 'isaac.physics_warmup'#: Physics warm-up.

Deprecated since version 1.7.0: Use SimulationEvent’s SIMULATION_SETUP instead.

POST_PHYSICS_STEP = 'isaac.post_physics_step'#: Post physics step.

Deprecated since version 1.7.0: Use SimulationEvent’s PHYSICS_POST_STEP instead.

POST_RESET = 'isaac.post_reset'#: Post reset.

Deprecated since version 1.7.0:
No replacement is provided, as the core experimental API does not use such event.

PRE_PHYSICS_STEP = 'isaac.pre_physics_step'#: Pre physics step.

Deprecated since version 1.7.0: Use SimulationEvent’s PHYSICS_PRE_STEP instead.

PRIM_DELETION = 'isaac.prim_deletion'#: Prim deletion.

Deprecated since version 1.7.0: Use SimulationEvent’s PRIM_DELETED instead.

SIMULATION_VIEW_CREATED = 'isaac.simulation_view_created'#: Simulation view created.

Deprecated since version 1.7.0: Use SimulationEvent’s SIMULATION_SETUP instead.

TIMELINE_STOP = 'isaac.timeline_stop'#: Timeline stop.

Deprecated since version 1.7.0: Use SimulationEvent’s SIMULATION_STOPPED instead.

Settings#

Extension Settings#

The table list the extension-specific settings.

Setting name	Description	Type	Default value
`default_engine`	Default physics engine to use (physx or newton).	`str`	`'physx'`

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.core.simulation_manager/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.core.simulation_manager".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.core.simulation_manager/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.core.simulation_manager/SETTING_NAME")