[Fix] Make --deterministic reproduce training runs by configuring the physics backend (#7334)

# Description

`--deterministic` configured PyTorch and the Isaac RTX renderer but
never reached the physics solver, so training on Newton backends was not
reproducible even with the flag passed. Two defaults moved out from
under the flag between 3.0beta2 and GA:

| Default | v3.0.0-beta2 | GA |
|---|---|---|
| `CartpolePhysicsCfg.default` | `PhysxCfg()` | `NewtonCfg` MJWarp,
`deterministic_mode="not_guaranteed"` |
| `MultiBackendRendererCfg.default` | `IsaacRtxRendererCfg()` |
`NewtonWarpRendererCfg()` |

The physics switch landed in `0caae64dc7c` (#7066), absent from all
three `v3.0.0-beta*` tags. At beta2 the flag worked because PhysX is
run-to-run deterministic for rigid bodies **and** Isaac RTX was the
default renderer; both premises were removed without re-wiring the flag.

`--deterministic` now sets `PhysicsCfg.deterministic` on the resolved
physics config, in `apply_env_overrides()` — the existing CLI-to-cfg
seam, after `scan()` resolves the backend and before the solver is
built. That field is the backend-agnostic request; each physics manager
translates it when the simulation starts:

- **Newton** derives `deterministic_mode="run_to_run"`, applies the
MJWarp `disable_sensors` prerequisite on the GPU path, and leaves
MuJoCo-CPU alone. An explicitly set `deterministic_mode` wins.
- **PhysX / OvPhysX** enable `enable_enhanced_determinism`. OvPhysX is
best-effort and not verified end to end.

Validation stays with the backend:
`NewtonManager._validate_deterministic_solver_cfg()` rejects an
unsupported solver at solver initialization, so there is one policy and
one set of error messages rather than a copy in the RL layer. Adding a
backend no longer means editing `isaaclab_rl`.

**A determinism request that would starve a sensor is now refused.**
Disabling MuJoCo Warp's sensors also skips its `rne_postconstraint`
stage, which fills Newton's `body_qdd` / `body_parent_f`. The IMU, PVA
and joint-wrench sensors read that state, so `Isaac-Ant`,
`Isaac-Humanoid` and `Isaac-Repose-Cube-Shadow` — all defaulting to
`newton_mjwarp` and feeding `joint_wrench` into their policy
observations — would have trained on values that are never refreshed,
with no error. `NewtonManager` raises at solver initialization, the only
point where both the solver config and the registered sensors are
visible.

The guard restates `{"body_qdd", "body_parent_f"}`, which Newton also
states internally (`solver_mujoco.py:4360` as a set, `:5179` as an
equivalent `or`-chain). That duplication is tracked upstream in
newton-physics/newton#4109, which asks for two
things: Newton refusing the combination at the source, and exporting the
field set as a public constant. Either lets this guard shrink — the
constant and its sensor-tracking delete entirely once Isaac Lab pins a
Newton that raises. Until then the guard is what prevents the silent
case, so it stays.

Fixes NVBug 6658578 (P0, Isaac Lab 3.0 GA).

## Type of change

- Bug fix (non-breaking change which fixes an issue)

## Validation

Three `--deterministic` runs of `Isaac-Cartpole-Camera` (50 epochs, task
defaults) on one L40, each in its own container:

```
det1 vs det2   55/55 checkpoint tensors bitwise identical
det1 vs det3   55/55 checkpoint tensors bitwise identical
ctrl1 vs ctrl2 41/55 differ          <- same task, no flag
```

The unflagged controls diverge, so the agreement above is the flag's
doing rather than a task that is trivially reproducible. `Isaac-Ant
--deterministic` fails at startup with the sensor message. MuJoCo-CPU
could not be exercised: `SolverMuJoCo.get_max_contact_count()` raises
`NotImplementedError` on that path, so it is unreachable in Isaac Lab
today.

8 unit tests added; 200 pass across `test_entrypoints_common.py` and
`test_newton_manager_abstraction.py`.

## Release backport

- [x] <!-- backport-active-release --> Backport this pull request to the
active release branch after it merges into `develop`

## Checklist

- [x] I have read and understood the [contribution
guidelines](https://isaac-sim.github.io/IsaacLab/main/source/refs/contributing.html)
- [x] I have run the [`pre-commit` checks](https://pre-commit.com/) with
`./isaaclab.sh --format`
- [x] I have made corresponding changes to the documentation
- [x] My changes generate no new warnings
- [x] I have added tests that prove my fix is effective or that my
feature works
- [x] I have added a changelog fragment under
`source/<pkg>/changelog.d/` for every touched package
- [x] I have added my name to the `CONTRIBUTORS.md` or my name already
exists there

Author: hujc7

docs/source/features/reproducibility.rst

@@ -20,8 +20,8 @@ simulation results are reproducible across different runs. The seed is set into
 parameters :attr:`isaaclab.envs.ManagerBasedEnvCfg.seed` or :attr:`isaaclab.envs.DirectRLEnvCfg.seed`
 depending on the manager-based or direct environment implementation respectively.
 
-App-level deterministic rendering via ``AppLauncher``
-^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+The ``--deterministic`` flag
+^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 
 The ``--deterministic`` flag is provided by :meth:`isaaclab.app.AppLauncher.add_app_launcher_args`.
 :class:`~isaaclab.app.app_launcher.AppLauncher` publishes ``/isaaclab/render/deterministic``.
@@ -33,11 +33,19 @@ The Isaac RTX backend reads it on init and applies
 for **RL-Games**, **skrl**, **RSL-RL**, and **Stable-Baselines3**: each calls
 :meth:`~isaaclab.utils.seed.configure_seed` after constructing its framework runner or agent object
 so library initialization is not disturbed, then training proceeds with the requested global RNG and
-optional PyTorch deterministic algorithms. Whether you need ``--deterministic`` at the app level
-depends on the workload: **physics-only** simulation does not require it; **RTX** rendering
-(non-minimal mode) does require it for reproducible imagery; **Newton** rendering does not require it.
-
-Pass ``--deterministic`` to enable reproducible rendering from the app launcher. (Isaac RTX only)
+optional PyTorch deterministic algorithms. Whether the **rendering** half of the flag matters depends
+on the workload: **physics-only** simulation does not render at all; **RTX** rendering (non-minimal
+mode) needs it for reproducible imagery; **Newton** rendering is already deterministic.
+
+**Physics determinism** comes from the same flag in the Isaac Lab RL training entrypoints, which
+set :attr:`~isaaclab.physics.PhysicsCfg.deterministic` on the backend resolved by presets. That
+field is the backend-agnostic request: each physics manager translates it into its own settings
+when the simulation starts, and raises when its configuration cannot provide the guarantee. Newton
+selects ``deterministic_mode="run_to_run"`` and applies the MJWarp prerequisite; PhysX and OvPhysX
+enable enhanced determinism, which is best-effort on OvPhysX and not verified end to end. Set
+:attr:`~isaaclab.physics.PhysicsCfg.deterministic` directly to get the same behavior from a script
+that does not use the RL entrypoints; ``--deterministic`` alone configures Torch and rendering
+only.
 
 .. tab-set::
 
@@ -66,7 +74,26 @@ ordering in its collision pipeline. Deterministic execution can increase
 memory use and reduce simulation performance. MJWarp on the GPU with
 :attr:`isaaclab_newton.physics.MJWarpSolverCfg.disable_sensors` set to ``True``,
 XPBD, and Featherstone are supported; selecting an unsupported solver raises
-an error.
+an error. MuJoCo on the CPU
+(:attr:`isaaclab_newton.physics.MJWarpSolverCfg.use_mujoco_cpu`) is already
+reproducible and is left unchanged. Set this attribute directly to request the
+stronger ``"gpu_to_gpu"`` guarantee, which takes precedence over
+:attr:`isaaclab.physics.PhysicsCfg.deterministic`. Setting it to
+``"not_guaranteed"`` does not opt out, because that is indistinguishable from
+the default; clear :attr:`isaaclab.physics.PhysicsCfg.deterministic` instead.
+
+.. note::
+
+   ``disable_sensors`` is required rather than optional: MuJoCo Warp's tactile
+   sensor kernel applies two atomic reduction families to one output array, which
+   Warp's deterministic code generation cannot lower, so the sensor module fails
+   to compile under a determinism guarantee. Disabling it also skips the
+   ``rne_postconstraint`` stage, which fills the Newton ``body_qdd`` and
+   ``body_parent_f`` state. The IMU, PVA, and joint-wrench sensors read that
+   state, so Newton raises rather than let them report stale values: remove those
+   sensors, or drop the determinism request. Integrations
+   that consume native MJWarp sensor outputs directly are affected too, and are
+   not detected.
 
 .. warning::
 

source/isaaclab/changelog.d/physics-cfg-deterministic.rst

@@ -0,0 +1,7 @@
+Added
+^^^^^
+
+* Added :attr:`~isaaclab.physics.PhysicsCfg.deterministic`, a backend-agnostic request for
+  reproducible physics. Each physics manager translates it into its own settings when the
+  simulation starts and raises when its configuration cannot provide the guarantee. A
+  backend-specific determinism attribute set explicitly takes precedence.

source/isaaclab/isaaclab/physics/physics_manager_cfg.py

@@ -34,6 +34,19 @@ class PhysicsCfg:
     class_type: type[PhysicsManager] | Any = MISSING
     """The physics manager class to use. Must be set by subclasses."""
 
+    deterministic: bool = False
+    """Whether to request reproducible physics from the backend. Defaults to False.
+
+    This is the backend-agnostic form of the request, set by the ``--deterministic`` command-line
+    flag. Each physics manager translates it into its own settings when the simulation starts, and
+    raises when its configuration cannot provide the guarantee. A backend-specific determinism
+    attribute set explicitly, such as
+    :attr:`~isaaclab_newton.physics.NewtonCfg.deterministic_mode`, is the more specific instruction
+    and takes precedence.
+
+    Deterministic execution can increase memory use and reduce simulation performance.
+    """
+
 
 @configclass
 class PhysxAutoCfg(PhysicsCfg):

source/isaaclab_newton/changelog.d/newton-deterministic-request.rst

@@ -0,0 +1,16 @@
+Added
+^^^^^
+
+* Added translation of :attr:`~isaaclab.physics.PhysicsCfg.deterministic` in ``NewtonManager``.
+  The request selects ``deterministic_mode="run_to_run"`` and sets ``MJWarpSolverCfg.disable_sensors``
+  on the MJWarp GPU path. An explicitly set ``deterministic_mode`` takes precedence. MuJoCo on the
+  CPU is left unchanged: Warp's deterministic mode does not reach that path, and the request is
+  logged instead of applied.
+
+Fixed
+^^^^^
+
+* Fixed a determinism request silently starving the IMU, PVA, and joint-wrench sensors. Disabling
+  MuJoCo Warp's sensors also skips the ``rne_postconstraint`` stage that fills ``body_qdd`` and
+  ``body_parent_f``, so those sensors reported stale values. ``NewtonManager`` now raises at solver
+  initialization when a scene requests both.

source/isaaclab_newton/isaaclab_newton/physics/newton_manager.py

@@ -121,6 +121,16 @@ def _paused_gc():
     from isaaclab_newton.physics.newton_collision_cfg import NewtonCollisionPipelineCfg
 
 
+_SENSORS_BY_STATE_ATTRIBUTE = {
+    "body_qdd": "the IMU or PVA sensor",
+    "body_parent_f": "the joint-wrench sensor",
+}
+"""Which Isaac Lab sensors read each state attribute that MuJoCo's sensor stage fills."""
+
+_SENSOR_STAGE_STATE_ATTRIBUTES = frozenset(_SENSORS_BY_STATE_ATTRIBUTE)
+"""Extended state attributes that MuJoCo Warp's sensor stage fills via ``rne_postconstraint``."""
+
+
 def _compile_label_pattern(expr: str | list[str] | None) -> re.Pattern[str] | None:
     """Compile selector expressions for Newton's full label matching."""
     if not expr:
@@ -433,6 +443,7 @@ class NewtonManager(PhysicsManager):
     _newton_frame_transform_sensors: list = []  # List of SensorFrameTransform
     _newton_imu_sensors: list = []  # List of NewtonSensorIMU
     _pending_extended_state_attributes: set[str] = set()
+    _active_extended_state_attributes: set[str] = set()
     _pending_extended_contact_attributes: set[str] = set()
     _report_contacts: bool = False
     _supports_contact_sensors: bool = True
@@ -1188,6 +1199,7 @@ def clear(cls):
         NewtonManager._world_xforms = None
         NewtonManager._cl_protos = {}
         NewtonManager._pending_extended_state_attributes = set()
+        NewtonManager._active_extended_state_attributes = set()
         NewtonManager._pending_extended_contact_attributes = set()
         for key in [key for key in NewtonManager.views if key[0] is NewtonManager]:
             del NewtonManager.views[key]
@@ -1589,9 +1601,12 @@ def start_simulation(cls) -> None:
         device = PhysicsManager._device
         logger.info(f"Finalizing model on device: {device}")
         cls._builder.up_axis = Axis.from_string(cls._up_axis)
-        # Forward pending extended attribute requests to builder and clear them
+        # Forward pending extended attribute requests to builder and clear them. The requests are
+        # retained because initialize_solver() runs afterwards and must know which sensors depend
+        # on state that MuJoCo's sensor stage fills.
         if cls._pending_extended_state_attributes:
             cls._builder.request_state_attributes(*cls._pending_extended_state_attributes)
+            NewtonManager._active_extended_state_attributes |= cls._pending_extended_state_attributes
             NewtonManager._pending_extended_state_attributes = set()
         cls._prepare_builder_for_finalize(cls._builder)
         with Timer(name="newton_finalize_builder", msg="Finalize builder took:", activity="Finalizing physics model"):
@@ -2111,9 +2126,9 @@ def _filter_solver_kwargs(solver_cls: type, solver_cfg) -> dict:
             kwargs["deterministic"] = NewtonManager._deterministic_mode
         return kwargs
 
-    @staticmethod
+    @classmethod
     def _validate_deterministic_solver_cfg(
-        solver_cfg: NewtonSolverCfg, deterministic_mode: wp.DeterministicMode
+        cls, solver_cfg: NewtonSolverCfg, deterministic_mode: wp.DeterministicMode
     ) -> None:
         """Validate that a solver can provide the requested determinism guarantee."""
         if deterministic_mode == wp.DeterministicMode.NOT_GUARANTEED:
@@ -2135,6 +2150,51 @@ def _validate_deterministic_solver_cfg(
                 "internal sensor computation is enabled. Set MJWarpSolverCfg.disable_sensors=True or disable "
                 "deterministic mode."
             )
+        blocked = cls._active_extended_state_attributes & _SENSOR_STAGE_STATE_ATTRIBUTES
+        if isinstance(solver_cfg, MJWarpSolverCfg) and blocked:
+            sensors = sorted({_SENSORS_BY_STATE_ATTRIBUTE[attr] for attr in blocked})
+            raise ValueError(
+                f"This task does not support deterministic physics: it uses {' and '.join(sensors)},"
+                f" reading {sorted(blocked)}. Those attributes come from MuJoCo's post-constraint pass,"
+                " which runs inside the sensor stage that a determinism guarantee must disable, so the"
+                " values would never be refreshed. Remove the sensors, or drop the determinism request"
+                f" (deterministic_mode={deterministic_mode.name})."
+            )
+
+    @classmethod
+    def _apply_deterministic_request(cls, cfg: NewtonCfg) -> wp.DeterministicMode:
+        """Translate the backend-agnostic determinism request into Newton settings.
+
+        :attr:`~isaaclab.physics.PhysicsCfg.deterministic` is the generic request. An explicitly
+        set :attr:`~isaaclab_newton.physics.NewtonCfg.deterministic_mode` is the more specific
+        instruction and wins. MuJoCo on the CPU is already reproducible and Warp's deterministic
+        mode does not reach it, so no mode is applied there and the request is logged instead.
+
+        Args:
+            cfg: Resolved Newton configuration.
+
+        Returns:
+            The deterministic mode to apply to the solver.
+        """
+        solver_cfg = cfg.solver_cfg
+        # MuJoCo-C is reproducible on its own and Warp's deterministic mode never reaches it, so
+        # no Newton setting applies -- report the request rather than dropping it silently.
+        if getattr(solver_cfg, "use_mujoco_cpu", False):
+            if cfg.deterministic or cfg.deterministic_mode != "not_guaranteed":
+                logger.info("MuJoCo CPU backend is already reproducible; Newton's deterministic mode is not applied.")
+            return wp.DeterministicMode.NOT_GUARANTEED
+
+        # Precedence: an explicit mode, then the generic request, then no guarantee. An explicit
+        # mode's prerequisites stay the caller's responsibility, so it is returned untouched.
+        if cfg.deterministic_mode != "not_guaranteed":
+            return cls._resolve_deterministic_mode(cfg.deterministic_mode)
+        if not cfg.deterministic:
+            return wp.DeterministicMode.NOT_GUARANTEED
+        # MuJoCo Warp cannot honour a guarantee while its internal sensor kernels run, so the
+        # generic request implies the prerequisite rather than failing on it.
+        if isinstance(solver_cfg, MJWarpSolverCfg):
+            solver_cfg.disable_sensors = True
+        return wp.DeterministicMode.RUN_TO_RUN
 
     @staticmethod
     def _resolve_deterministic_mode(deterministic_mode: str) -> wp.DeterministicMode:
@@ -2224,7 +2284,7 @@ def initialize_solver(cls) -> None:
         with Timer(name="newton_initialize_solver", msg="Initialize solver took:", activity="Initializing solver"):
             NewtonManager._num_substeps = cfg.num_substeps  # type: ignore[union-attr]
             NewtonManager._collision_decimation = cfg.collision_decimation  # type: ignore[union-attr]
-            deterministic_mode = cls._resolve_deterministic_mode(cfg.deterministic_mode)  # type: ignore[union-attr]
+            deterministic_mode = cls._apply_deterministic_request(cfg)  # type: ignore[arg-type]
             cls._validate_deterministic_solver_cfg(cfg.solver_cfg, deterministic_mode)  # type: ignore[union-attr]
             NewtonManager._deterministic_mode = deterministic_mode
             NewtonManager._solver_dt = cls.get_physics_dt() / cls._num_substeps

source/isaaclab_newton/test/physics/test_newton_manager_abstraction.py

@@ -25,6 +25,7 @@
 
 from __future__ import annotations
 
+import logging
 from inspect import signature
 from types import SimpleNamespace
 
@@ -1592,3 +1593,86 @@ def test_hard_reset_then_step_runs(use_cuda_graph):
         # A hard device sync surfaces any deferred illegal access as an exception.
         sim.step(render=False)
         wp.synchronize_device("cuda:0")
+
+
+@pytest.fixture
+def clean_extended_state_attributes():
+    """Isolate the class-level record of sensor-requested state attributes."""
+    previous = NewtonManager._active_extended_state_attributes
+    NewtonManager._active_extended_state_attributes = set()
+    yield
+    NewtonManager._active_extended_state_attributes = previous
+
+
+@pytest.mark.parametrize(
+    "solver_cfg, deterministic, expected",
+    [
+        pytest.param(XPBDSolverCfg(), False, wp.DeterministicMode.NOT_GUARANTEED, id="no_request"),
+        pytest.param(XPBDSolverCfg(), True, wp.DeterministicMode.RUN_TO_RUN, id="request_xpbd"),
+        pytest.param(MJWarpSolverCfg(), True, wp.DeterministicMode.RUN_TO_RUN, id="request_mjwarp_gpu"),
+        # MuJoCo on the CPU is already reproducible; Warp's mode does not reach it.
+        pytest.param(
+            MJWarpSolverCfg(use_mujoco_cpu=True), True, wp.DeterministicMode.NOT_GUARANTEED, id="request_mujoco_cpu"
+        ),
+    ],
+)
+def test_apply_deterministic_request_translates_the_generic_flag(
+    solver_cfg, deterministic, expected, clean_extended_state_attributes
+) -> None:
+    """The backend owns translation of :attr:`PhysicsCfg.deterministic` into Newton settings."""
+    cfg = NewtonCfg(solver_cfg=solver_cfg, deterministic=deterministic)
+
+    assert NewtonManager._apply_deterministic_request(cfg) == expected
+
+
+@pytest.mark.parametrize("mode", ["run_to_run", "gpu_to_gpu"])
+def test_apply_deterministic_request_skips_an_explicit_mode_on_mujoco_cpu(
+    mode, clean_extended_state_attributes, caplog
+) -> None:
+    """MuJoCo-C is reproducible on its own, so an explicit mode is reported rather than enforced."""
+    cfg = NewtonCfg(solver_cfg=MJWarpSolverCfg(use_mujoco_cpu=True), deterministic_mode=mode)
+
+    with caplog.at_level(logging.INFO, logger="isaaclab_newton.physics.newton_manager"):
+        assert NewtonManager._apply_deterministic_request(cfg) == wp.DeterministicMode.NOT_GUARANTEED
+
+    assert any("already reproducible" in r.getMessage() for r in caplog.records)
+
+
+def test_apply_deterministic_request_sets_the_mjwarp_sensor_prerequisite(clean_extended_state_attributes) -> None:
+    """MJWarp on the GPU needs its internal sensors off, so the request implies it."""
+    # NewtonCfg copies the nested solver config, so assert on the instance it actually holds.
+    cfg = NewtonCfg(solver_cfg=MJWarpSolverCfg(), deterministic=True)
+    assert cfg.solver_cfg.disable_sensors is False
+
+    NewtonManager._apply_deterministic_request(cfg)
+
+    assert cfg.solver_cfg.disable_sensors is True
+
+
+def test_apply_deterministic_request_keeps_an_explicit_mode(clean_extended_state_attributes) -> None:
+    """An explicitly requested mode is the more specific instruction and wins."""
+    cfg = NewtonCfg(solver_cfg=MJWarpSolverCfg(), deterministic=True, deterministic_mode="gpu_to_gpu")
+
+    assert NewtonManager._apply_deterministic_request(cfg) == wp.DeterministicMode.GPU_TO_GPU
+
+
+@pytest.mark.parametrize("attr", ["body_qdd", "body_parent_f"])
+def test_deterministic_mode_rejects_sensors_that_need_the_sensor_stage(attr, clean_extended_state_attributes) -> None:
+    """Disabling MJWarp sensors starves IMU/PVA/joint-wrench, so the request is refused."""
+    NewtonManager._active_extended_state_attributes = {attr}
+
+    with pytest.raises(ValueError, match="does not support deterministic physics"):
+        NewtonManager._validate_deterministic_solver_cfg(
+            MJWarpSolverCfg(disable_sensors=True), wp.DeterministicMode.RUN_TO_RUN
+        )
+
+
+def test_deterministic_mode_allows_those_sensors_without_a_guarantee(
+    clean_extended_state_attributes,
+) -> None:
+    """The sensors are only incompatible with the guarantee, not with MJWarp itself."""
+    NewtonManager._active_extended_state_attributes = {"body_qdd"}
+
+    NewtonManager._validate_deterministic_solver_cfg(
+        MJWarpSolverCfg(disable_sensors=True), wp.DeterministicMode.NOT_GUARANTEED
+    )

source/isaaclab_ov/changelog.d/ovphysx-deterministic-request.rst

@@ -0,0 +1,6 @@
+Added
+^^^^^
+
+* Added translation of :attr:`~isaaclab.physics.PhysicsCfg.deterministic` in ``OvPhysxManager``, which
+  enables ``physxScene:enableEnhancedDeterminism``. Reproducibility on OvPhysX is best-effort and is
+  not verified end to end.

source/isaaclab_ov/isaaclab_ov/physics/ovphysx_manager.py

@@ -1120,8 +1120,10 @@ def _configure_physx_scene_prim(scene_prim, cfg, device: str) -> None:
         scene_prim.CreateAttribute("physxScene:enableSceneQuerySupport", Sdf.ValueTypeNames.Bool).Set(enable_sq)
 
         if cfg is not None:
+            # OvPhysX answers the backend-agnostic determinism request with enhanced determinism.
+            # This is best-effort: reproducibility is not verified end to end.
             scene_prim.CreateAttribute("physxScene:enableEnhancedDeterminism", Sdf.ValueTypeNames.Bool).Set(
-                cfg.enable_enhanced_determinism
+                cfg.enable_enhanced_determinism or cfg.deterministic
             )
             scene_prim.CreateAttribute("physxScene:enableExternalForcesEveryIteration", Sdf.ValueTypeNames.Bool).Set(
                 cfg.enable_external_forces_every_iteration

source/isaaclab_physx/changelog.d/physx-deterministic-request.rst

@@ -0,0 +1,5 @@
+Added
+^^^^^
+
+* Added translation of :attr:`~isaaclab.physics.PhysicsCfg.deterministic` in ``PhysxManager``, which
+  enables :attr:`~isaaclab_physx.physics.PhysxCfg.enable_enhanced_determinism`.

source/isaaclab_physx/isaaclab_physx/physics/physx_manager.py

@@ -797,8 +797,15 @@ def _configure_physics(cls) -> None:
         if bool(sim.get_setting("/isaaclab/has_gui")):
             cfg.enable_scene_query_support = True
 
+        # PhysX answers the backend-agnostic determinism request with enhanced determinism. An
+        # explicitly enabled flag stays enabled.
+        if cfg.deterministic:
+            cfg.enable_enhanced_determinism = True
+
         # apply remaining cfg attributes to scene (physxScene:*)
         skip = {
+            # generic request, translated above; PhysX has no physxScene:deterministic attribute
+            "deterministic",
             "solver_type",
             "enable_ccd",
             "solve_articulation_contact_last",