Reviewing files that changed from the base of the PR and between 4949d3c and 90c32bf.

• newton/_src/utils/__init__.py (3 hunks)
• newton/examples/__init__.py (5 hunks)
• newton/examples/__main__.py (1 hunks)
• newton/examples/basic/example_basic_joints.py (5 hunks)
• newton/examples/basic/example_basic_pendulum.py (3 hunks)
• newton/examples/basic/example_basic_shapes.py (5 hunks)
• newton/examples/basic/example_basic_urdf.py (3 hunks)
• newton/examples/basic/example_basic_viewer.py (1 hunks)
• newton/examples/cloth/example_cloth_bending.py (2 hunks)
• newton/examples/cloth/example_cloth_franka.py (3 hunks)
• newton/examples/cloth/example_cloth_hanging.py (4 hunks)
• newton/examples/cloth/example_cloth_style3d.py (2 hunks)
• newton/examples/cloth/example_cloth_twist.py (3 hunks)
• newton/examples/diffsim/example_diffsim_ball.py (1 hunks)
• newton/examples/diffsim/example_diffsim_cloth.py (1 hunks)
• newton/examples/diffsim/example_diffsim_drone.py (1 hunks)
• newton/examples/diffsim/example_diffsim_soft_body.py (1 hunks)
• newton/examples/diffsim/example_diffsim_spring_cage.py (1 hunks)
• newton/examples/example_replay_viewer.py (1 hunks)
• newton/examples/ik/example_ik_franka.py (1 hunks)
• newton/examples/ik/example_ik_h1.py (1 hunks)
• newton/examples/mpm/example_mpm_anymal.py (1 hunks)
• newton/examples/mpm/example_mpm_grain_rendering.py (1 hunks)
• newton/examples/mpm/example_mpm_granular.py (1 hunks)
• newton/examples/mpm/example_mpm_multi_material.py (1 hunks)
• newton/examples/robot/example_robot_allegro_hand.py (1 hunks)
• newton/examples/robot/example_robot_anymal_c_walk.py (1 hunks)
• newton/examples/robot/example_robot_anymal_d.py (2 hunks)
• newton/examples/robot/example_robot_cartpole.py (2 hunks)
• newton/examples/robot/example_robot_g1.py (2 hunks)
• newton/examples/robot/example_robot_h1.py (2 hunks)
• newton/examples/robot/example_robot_humanoid.py (1 hunks)
• newton/examples/robot/example_robot_policy.py (1 hunks)
• newton/examples/robot/example_robot_ur10.py (1 hunks)
• newton/examples/selection/example_selection_articulations.py (1 hunks)
• newton/examples/selection/example_selection_cartpole.py (1 hunks)
• newton/examples/selection/example_selection_materials.py (1 hunks)
• newton/examples/sensors/example_sensor_contact.py (1 hunks)
• newton/tests/test_examples.py (9 hunks)
• newton/utils.py (2 hunks)

• GitHub Check: Run GPU Benchmarks (Pull Request)

newton/examples/diffsim/example_diffsim_spring_cage.py (1)

253-253: Pass args to runner: LGTM

Matches the updated run(example, args) API in newton.examples.

newton/examples/robot/example_robot_ur10.py (1)

218-218: Args forwarding: LGTM

Correctly updates to run(example, args).

newton/examples/diffsim/example_diffsim_cloth.py (1)

227-227: Args forwarding: LGTM

Consistent with the new runner signature.

newton/examples/robot/example_robot_anymal_d.py (1)

164-164: Args forwarding: LGTM

Runner call now matches run(example, args).

newton/examples/selection/example_selection_articulations.py (1)

301-301: Args forwarding: LGTM

Correctly updates to run(example, args).

newton/examples/basic/example_basic_viewer.py (1)

194-194: Args forwarding: LGTM

Consistent with newton.examples.run(example, args).

newton/examples/example_replay_viewer.py (1)

252-252: Args forwarding: LGTM

Matches the updated run API.

newton/examples/robot/example_robot_h1.py (1)

147-147: Args forwarding: LGTM

Updated to run(example, args).

newton/examples/robot/example_robot_g1.py (1)

132-143: Fix Warp test function so it actually runs.
The test callbacks get JIT-compiled into Warp kernels. Indexing a wp.transform (q[2]) and calling Python’s max(abs(qd)) are not Warp-compatible, so the kernel compilation will raise at runtime when args.test triggers example.test(). Use Warp utilities to read the translation and velocity norm.

         newton.examples.test_body_state(
             self.model,
             self.state_0,
             "all bodies are above the ground",
-            lambda q, qd: q[2] > 0.0,
+            lambda q, qd: wp.transform_get_translation(q).z > 0.0,
         )
         newton.examples.test_body_state(
             self.model,
             self.state_0,
             "all body velocities are small",
-            lambda q, qd: max(abs(qd)) < 0.001,
+            lambda q, qd: wp.length(qd) < 0.001,
         )

⛔ Skipped due to learnings

Learnt from: nvlukasz
PR: newton-physics/newton#519
File: newton/_src/solvers/featherstone/kernels.py:75-75
Timestamp: 2025-08-12T18:04:06.577Z
Learning: The Newton physics framework requires nightly Warp builds, which means compatibility concerns with older stable Warp versions (like missing functions such as wp.spatial_adjoint) are not relevant for this project.

Learnt from: dylanturpin
PR: newton-physics/newton#806
File: newton/_src/sim/ik/ik_objectives.py:0-0
Timestamp: 2025-09-25T16:14:22.002Z
Learning: In NVIDIA Warp's Newton physics library, wp.transform supports direct numerical indexing (e.g., body_tf[0], body_tf[1], body_tf[2] for position and body_tf[3], body_tf[4], body_tf[5], body_tf[6] for quaternion components) to access its elements. This is the standard API used throughout the codebase.

Learnt from: dylanturpin
PR: newton-physics/newton#806
File: newton/_src/sim/ik/ik_objectives.py:0-0
Timestamp: 2025-09-25T16:14:22.002Z
Learning: wp.transform in NVIDIA Warp supports indexing using numerical indices (e.g., body_tf[0], body_tf[3], etc.) to access translation and rotation components. The indexing approach used in the Newton codebase is valid and compiles correctly.

Learnt from: dylanturpin
PR: newton-physics/newton#806
File: newton/examples/ik/example_ik_franka.py:121-123
Timestamp: 2025-09-22T21:08:31.901Z
Learning: In the newton physics framework, when creating warp arrays for IK solver joint variables using wp.array(self.model.joint_q, shape=(1, coord_count)), the resulting array acts as a reference/pointer to the original model's joint coordinates, so updates from the IK solver automatically reflect in the model's joint_q buffer used for rendering, despite the general warp documentation suggesting copies are made by default.

newton/examples/diffsim/example_diffsim_drone.py (1)

821-821: LGTM! API update correctly implemented.

The invocation has been properly updated to pass the parsed arguments to the run function, aligning with the new run(example, args) signature.

newton/utils.py (1)

91-92: LGTM! New utility functions correctly exposed.

The vec_allclose and vec_inside_limits functions are properly imported and exported through the public API. These utilities provide essential vector comparison capabilities for state validation in testing.

Also applies to: 106-107

newton/examples/robot/example_robot_policy.py (1)

472-472: LGTM! API update correctly implemented.

The invocation has been properly updated to pass the parsed arguments to the run function, aligning with the new run(example, args) signature. Based on learnings from previous reviews, this robot policy example is correctly registered as "robot_policy" in the system.

newton/examples/basic/example_basic_urdf.py (2)

30-30: LGTM! Import addition is appropriate.

The import of warp as wp is correctly added to support the test functions that use wp module functionality.

---

164-164: LGTM! API update correctly implemented.

The invocation has been properly updated to pass the parsed arguments to the run function, aligning with the new run(example, args) signature.

newton/examples/diffsim/example_diffsim_soft_body.py (1)

377-377: LGTM! API update correctly implemented.

The invocation has been properly updated to pass the parsed arguments to the run function, aligning with the new run(example, args) signature.

newton/examples/basic/example_basic_joints.py (3)

87-88: LGTM! Initial joint angle configuration is correct.

Setting the revolute joint to π/2 radians provides a meaningful initial configuration for the joint demonstration.

---

137-151: LGTM! Ball joint configuration is properly implemented.

The addition of rigid body configuration with zero density for the kinematic sphere parent and the RPY quaternion initialization for the ball joint provide good demonstration of the ball joint capabilities.

---

243-243: LGTM! API update correctly implemented.

The invocation has been properly updated to pass the parsed arguments to the run function, aligning with the new run(example, args) signature.

newton/examples/basic/example_basic_pendulum.py (2)

59-65: LGTM! Pendulum orientation enhancement improves visualization.

The addition of the rotation quaternion to orient the pendulum sideways provides better visual presentation for viewers, making the pendulum motion more apparent.

---

164-164: LGTM! API update correctly implemented.

The invocation has been properly updated to pass the parsed arguments to the run function, aligning with the new run(example, args) signature.

newton/examples/robot/example_robot_anymal_c_walk.py (1)

231-246: Fix unused lambda parameters

-            lambda q, qd: q[2] > 0.2,
+            lambda q, _qd: q[2] > 0.2,

-            lambda q, qd: newton.utils.vec_allclose(
+            lambda _q, qd: newton.utils.vec_allclose(

Verify that the height threshold (0.2 m) and forward‐velocity expectation (≈1 m/s) align with the simulated gait before merging.

newton/examples/cloth/example_cloth_twist.py (1)

315-315: Run signature update looks good.

Forwarding args to run() matches the updated runner API.

newton/examples/robot/example_robot_cartpole.py (1)

189-189: Run signature update looks good.

Using run(example, args) aligns with the new runner API.

newton/examples/cloth/example_cloth_hanging.py (2)

62-64: Correct builder class for Style3D.

Switch to newton.Style3DModelBuilder() is appropriate for the style3d path.

---

235-235: Run signature update looks good.

Passing args to run() is consistent with the new API.

newton/_src/utils/__init__.py (1)

246-247: Export additions look correct.

Including vec_allclose and vec_inside_limits in __all__ is consistent with their use in examples.

newton/examples/cloth/example_cloth_franka.py (2)

24-24: Command comment update looks fine.

No issues.

---

583-583: Run signature update looks good.

Consistent with the new run(example, args) API.

newton/tests/test_examples.py (5)

87-91: LGTM: Module existence verification.

The runtime verification to ensure the test module exists is a good defensive programming practice. The ImportError handling provides clear error messages when a referenced example module is missing.

---

147-147: Add --test flag to example execution.

The command construction properly appends the --test flag, which aligns with the PR's objective to enable test mode for examples. This ensures examples can be invoked in test mode to run their validation routines.

---

234-240: LGTM: New basic shapes test added.

The addition of basic.example_basic_shapes test with appropriate frame count is well-structured and consistent with the existing pattern.

---

261-271: LGTM: Multiple test configurations for cloth hanging.

The addition of two test variants for cloth.example_cloth_hanging with different test suffixes ("vbd" and "style3d") and corresponding solver options provides good coverage of different solver backends.

---

314-314: Device assignment optimization for GPU-intensive examples.

Moving specific robot examples (anymal_c_walk, g1, h1) from test_devices to cuda_test_devices is a sensible optimization, as these examples likely require GPU acceleration for reasonable performance and may have PyTorch dependencies that benefit from CUDA.

Also applies to: 329-329, 336-336

newton/examples/basic/example_basic_shapes.py (5)

54-56: LGTM: Consistent body key assignments.

The addition of key parameters to add_body() calls provides meaningful identifiers for each body (sphere, capsule, box, mesh), which will be useful for debugging and the new test functionality. The implementation is consistent and follows a clear naming pattern.

Also applies to: 60-62, 70-70, 87-87

---

94-94: LGTM: XPBD solver configuration with explicit iterations.

The explicit iterations=10 parameter for the SolverXPBD constructor improves clarity and aligns with the updated API. This provides better control over solver convergence behavior.

---

103-103: LGTM: Updated documentation comment.

The comment correctly reflects that the forward kinematics step is required for maximal-coordinate solvers like XPBD, providing better context than the previous generic note.

---

138-169: LGTM: Comprehensive rest pose testing.

The test implementation effectively validates that bodies settle into expected rest positions after simulation. The tests cover all major shapes and use appropriate tolerance values. The bunny test reasonably checks for basic physics constraints (staying above ground, minimal drift) rather than exact positioning due to its complex geometry.

---

185-185: LGTM: Updated run signature.

The change to newton.examples.run(example, args) correctly passes the parsed arguments, enabling the new test functionality and other argument-driven behavior.

newton/examples/__init__.py (8)

17-17: LGTM: Import for Callable type annotation.

The import of Callable from collections.abc is appropriate for the new type annotations in the test functions.

---

37-46: LGTM: Non-finite value detection helper.

The _find_nonfinite function provides a robust way to detect problematic numerical values in Newton objects. The implementation correctly handles None objects and uses numpy's isfinite function for reliable detection.

---

49-103: LGTM: Comprehensive body state testing utility.

The test_body_state function provides a well-designed testing framework that:

• Supports both Warp functions and Python callables via wp.utils.create_warp_function
• Uses GPU kernels for efficient batch testing
• Provides detailed error reporting with body keys
• Handles optional indices for selective testing

The implementation is robust and will be valuable for example validation.

---

106-158: LGTM: Particle state testing utility.

The test_particle_state function mirrors the design of test_body_state but for particle systems. The implementation is consistent and provides appropriate error reporting, though it could benefit from particle identifiers similar to how body keys are used.

---

161-161: LGTM: Updated run function signature.

The change to accept both example and args parameters enables the new testing functionality and argument-driven behavior across examples.

---

173-174: LGTM: Example-specific test execution.

The conditional execution of example.test() when both args.test is enabled and the method exists provides a clean way for examples to implement custom validation logic.

---

178-199: LGTM: Generic finiteness validation.

The comprehensive validation of Newton objects (state_0, state_1, contacts, model, control) for non-finite values provides excellent runtime verification. This will help catch numerical issues early in the testing process.

---

285-290: LGTM: Test mode argument addition.

The addition of the --test flag with BooleanOptionalAction follows argparse best practices and integrates cleanly with the existing argument parser.

newton/examples/__main__.py (1)

3-14: License header matches our standard.
Template aligns with the rest of the repo’s Apache-2.0 headers.

newton/examples/robot/example_robot_humanoid.py (1)

127-127: Passing args into run keeps this example compatible.
This forwards the parsed CLI/test options so the updated runner can perform its validations.

newton/examples/mpm/example_mpm_anymal.py (1)

433-433: Runner invocation now matches the updated API.
args is propagated, so test-mode hooks and nonfinite checks will run as intended.

newton/examples/mpm/example_mpm_grain_rendering.py (1)

160-160: Args forwarding confirmed.
Keeps this grain-rendering example in sync with the new run(example, args) signature.

newton/examples/diffsim/example_diffsim_ball.py (1)

261-261: run call updated appropriately.
Ensures the diffsim example participates in the shared args/test flow.

newton/examples/selection/example_selection_cartpole.py (1)

199-199: Cartpole example now conforms to the new runner signature.
CLI/test arguments will flow into the shared runner just like the other examples.

newton/examples/mpm/example_mpm_multi_material.py (1)

219-219: Updated runner call looks good.
Multi-material example also passes args, enabling the shared validation logic.

newton/examples/selection/example_selection_materials.py (1)

277-277: Args now forwarded to the runner.
Keeps the selection materials example compatible with the enhanced run flow.

newton/examples/mpm/example_mpm_granular.py (1)

229-229: Forward args into run.

Good catch updating this call to satisfy the new run(example, args) signature so tests get the CLI context they expect.

newton/examples/ik/example_ik_franka.py (1)

177-177: run invocation matches updated signature.

Passing args through keeps the IK example wired into the shared test/CLI pipeline after the API change.

newton/examples/robot/example_robot_allegro_hand.py (1)

210-210: Propagate parsed args to the runner.

Thanks for updating the Allegro example to pass args; this keeps its test path consistent with the revised harness.

newton/examples/sensors/example_sensor_contact.py (1)

354-354: Runner call now forwards CLI args.

This change ensures the sensor example benefits from the new test hooks and arg-driven behaviors.

newton/examples/ik/example_ik_h1.py (1)

193-193: Align run call with new API.

Forwarding args here keeps the H1 IK example compatible with the shared runner logic.

Reviewing files that changed from the base of the PR and between 4949d3c and 90c32bf.

• newton/_src/utils/__init__.py (3 hunks)
• newton/examples/__init__.py (5 hunks)
• newton/examples/__main__.py (1 hunks)
• newton/examples/basic/example_basic_joints.py (5 hunks)
• newton/examples/basic/example_basic_pendulum.py (3 hunks)
• newton/examples/basic/example_basic_shapes.py (5 hunks)
• newton/examples/basic/example_basic_urdf.py (3 hunks)
• newton/examples/basic/example_basic_viewer.py (1 hunks)
• newton/examples/cloth/example_cloth_bending.py (2 hunks)
• newton/examples/cloth/example_cloth_franka.py (3 hunks)
• newton/examples/cloth/example_cloth_hanging.py (4 hunks)
• newton/examples/cloth/example_cloth_style3d.py (2 hunks)
• newton/examples/cloth/example_cloth_twist.py (3 hunks)
• newton/examples/diffsim/example_diffsim_ball.py (1 hunks)
• newton/examples/diffsim/example_diffsim_cloth.py (1 hunks)
• newton/examples/diffsim/example_diffsim_drone.py (1 hunks)
• newton/examples/diffsim/example_diffsim_soft_body.py (1 hunks)
• newton/examples/diffsim/example_diffsim_spring_cage.py (1 hunks)
• newton/examples/example_replay_viewer.py (1 hunks)
• newton/examples/ik/example_ik_franka.py (1 hunks)
• newton/examples/ik/example_ik_h1.py (1 hunks)
• newton/examples/mpm/example_mpm_anymal.py (1 hunks)
• newton/examples/mpm/example_mpm_grain_rendering.py (1 hunks)
• newton/examples/mpm/example_mpm_granular.py (1 hunks)
• newton/examples/mpm/example_mpm_multi_material.py (1 hunks)
• newton/examples/robot/example_robot_allegro_hand.py (1 hunks)
• newton/examples/robot/example_robot_anymal_c_walk.py (1 hunks)
• newton/examples/robot/example_robot_anymal_d.py (2 hunks)
• newton/examples/robot/example_robot_cartpole.py (2 hunks)
• newton/examples/robot/example_robot_g1.py (2 hunks)
• newton/examples/robot/example_robot_h1.py (2 hunks)
• newton/examples/robot/example_robot_humanoid.py (1 hunks)
• newton/examples/robot/example_robot_policy.py (1 hunks)
• newton/examples/robot/example_robot_ur10.py (1 hunks)
• newton/examples/selection/example_selection_articulations.py (1 hunks)
• newton/examples/selection/example_selection_cartpole.py (1 hunks)
• newton/examples/selection/example_selection_materials.py (1 hunks)
• newton/examples/sensors/example_sensor_contact.py (1 hunks)
• newton/tests/test_examples.py (9 hunks)
• newton/utils.py (2 hunks)

• newton/examples/mpm/example_mpm_anymal.py
• newton/examples/ik/example_ik_franka.py
• newton/examples/diffsim/example_diffsim_soft_body.py
• newton/examples/sensors/example_sensor_contact.py
• newton/examples/diffsim/example_diffsim_cloth.py
• newton/examples/diffsim/example_diffsim_ball.py
• newton/examples/mpm/example_mpm_grain_rendering.py

newton/examples/basic/example_basic_urdf.py (3)

29-31: Import of warp is correct and necessary.

Required for device functions used in tests below.

---

164-164: Passing args into run() is correct.

Matches newton.examples.run(example, args) behavior where args.test triggers example.test() and finiteness checks.

Ensure the tests invoke this example with --test to exercise the new checks.

---

136-144: Transform indexing bug and unused arg in lambda.

q is a wp.transform; use q.p[2] for height. Also avoid Python lambda; pass a wp.func. This also resolves Ruff ARG005 for the unused qd.

Apply this diff:

-        bodies_per_env = self.model.body_count // self.num_envs
+        bodies_per_env = self.model.body_count // self.num_envs
         newton.examples.test_body_state(
             self.model,
             self.state_0,
             "quadrupeds have reached the terminal height",
-            lambda q, qd: wp.abs(q[2] - 0.48) < 0.01,
+            at_terminal_height,
             # only select the root body of each environment
             indices=[i * bodies_per_env for i in range(self.num_envs)],
         )

Add this device function near the imports:

@wp.func
def at_terminal_height(q: wp.transform, _qd: wp.spatial_vector) -> bool:
    return wp.abs(q.p[2] - 0.48) < 0.01

Please verify body_count % num_envs == 0 at runtime; if not, root-body indexing will be off. Based on relevant_code_snippets

newton/examples/__main__.py (1)

3-14: License header addition: LGTM.

Matches Apache 2.0 template; no functional impact.

newton/_src/utils/__init__.py (3)

199-207: vec_allclose: Correct tolerance semantics; LGTM.

Matches numpy’s abs(a-b) <= atol + rtol*abs(b); works with fixed-size Warp vectors.

---

210-218: vec_inside_limits: Straightforward and clear; LGTM.

Loop unrolled via wp.static(len(a)) for fixed-size vectors.

---

246-248: Verify public re-export is wired up.

Ensure newton/utils.py re-exports these for public access as documented.

Run:

newton/examples/example_replay_viewer.py (1)

252-252: API alignment: passing args into run() is correct.

Keeps this entry point consistent with the updated runner signature.

newton/examples/selection/example_selection_materials.py (1)

277-277: API alignment: LGTM.

Forwarding args to run() matches the new examples runner.

newton/examples/mpm/example_mpm_granular.py (1)

229-229: API alignment: LGTM.

Args are now forwarded to the runner as expected.

newton/examples/robot/example_robot_ur10.py (1)

218-218: API alignment: LGTM. Also check for any remaining legacy call sites.

This adopts run(example, args). Verify no other examples still call run(example) without args.

Run:

newton/examples/diffsim/example_diffsim_drone.py (1)

821-821: Forwarding args keeps the example aligned with the updated runner API.

Looks good—this ensures the CLI/test flags propagate into newton.examples.run.

newton/examples/robot/example_robot_allegro_hand.py (1)

210-210: Run invocation now matches the new run(example, args) contract.

No issues spotted; the example will honor --test and other parsed flags.

newton/examples/diffsim/example_diffsim_spring_cage.py (1)

253-253: Args passthrough to run looks correct.

This keeps the diff-sim example compatible with the updated runner.

newton/examples/robot/example_robot_policy.py (1)

472-472: Runner call updated appropriately.

Passing args here ensures policy selection honors CLI/test flags.

newton/examples/robot/example_robot_humanoid.py (1)

127-127: args forwarding confirmed.

The humanoid example now complies with the revised newton.examples.run signature.

newton/examples/mpm/example_mpm_multi_material.py (1)

219-219: Runner call aligns with new signature.

No problems here—args reaches the test harness as expected.

newton/examples/selection/example_selection_articulations.py (1)

301-301: Updated runner invocation is correct.

args is now propagated to handle --test and related options.

newton/examples/selection/example_selection_cartpole.py (1)

199-199: Args propagation LGTM.

This keeps the cartpole selection example compatible with the shared runner.

newton/examples/basic/example_basic_viewer.py (1)

194-194: Run signature update looks good

Passing args into run aligns with newton.examples.run(example, args).

newton/examples/cloth/example_cloth_style3d.py (1)

194-194: Run signature update looks good

Consistent with updated run(example, args).

newton/examples/ik/example_ik_h1.py (1)

193-193: Run signature update looks good

Switch to run(example, args) is correct.

newton/examples/robot/example_robot_anymal_c_walk.py (2)

255-255: Run signature update looks good

run(example, args) matches the new API.

---

26-57: Fix: guard optional torch dependency to prevent import-time failure

Tests fail importing this module when torch isn’t installed. Guard the import and the JIT-decorated function so the module can be imported, and short-circuit in main if torch is unavailable.

-import torch
+try:
+    import torch
+    TORCH_AVAILABLE = True
+except Exception:
+    TORCH_AVAILABLE = False

-@torch.jit.script
-def quat_rotate_inverse(q: torch.Tensor, v: torch.Tensor) -> torch.Tensor:
+if TORCH_AVAILABLE:
+    @torch.jit.script
+    def quat_rotate_inverse(q: torch.Tensor, v: torch.Tensor) -> torch.Tensor:
+        # ... (body unchanged)
+        q_w = q[..., 3]
+        q_vec = q[..., :3]
+        a = v * (2.0 * q_w**2 - 1.0).unsqueeze(-1)
+        b = torch.cross(q_vec, v, dim=-1) * q_w.unsqueeze(-1) * 2.0
+        if q_vec.dim() == 2:
+            c = q_vec * torch.bmm(q_vec.view(q.shape[0], 1, 3), v.view(q.shape[0], 3, 1)).squeeze(-1) * 2.0
+        else:
+            c = q_vec * torch.einsum("...i,...i->...", q_vec, v).unsqueeze(-1) * 2.0
+        return a - b + c
+else:
+    def quat_rotate_inverse(q, v):
+        raise RuntimeError("Torch not available")

Additionally, exit early in main if torch is missing to make the subprocess return 0 cleanly when the dependency isn’t present:

 if __name__ == "__main__":
-    # Parse arguments and initialize viewer
-    viewer, args = newton.examples.init()
+    # Parse arguments and initialize viewer
+    import sys
+    if not TORCH_AVAILABLE:
+        print("Torch not available; skipping example_robot_anymal_c_walk")
+        sys.exit(0)
+    viewer, args = newton.examples.init()

To ensure CI skips this example when torch is missing, please also verify test_examples marks it torch_required.

Run to confirm mapping:

newton/utils.py (1)

91-93: Re-exporting vec_allclose and vec_inside_limits is correct

Public surface now matches usage across examples/tests. Incremental all style is consistent.

Also applies to: 106-108

newton/examples/basic/example_basic_joints.py (3)

87-89: Initializing joint angle is fine

Setting builder.joint_q[-1] to pi/2 is reasonable for a visible hinge pose.

---

151-152: Quaternion init for BALL joint looks good

Using quat_rpy to seed initial orientation is appropriate.

---

243-244: Run signature update looks good

Correctly updated to run(example, args).

newton/examples/cloth/example_cloth_franka.py (1)

583-584: Run signature update looks good

Switch to run(example, args) is correct.

newton/examples/cloth/example_cloth_bending.py (1)

160-160: Run signature update looks good

run(example, args) matches the new API.

newton/examples/basic/example_basic_shapes.py (1)

138-169: Fix transform handling in example tests

test_body_state passes each body's wp.transform into your lambda. newton.utils.vec_allclose expects vector-like inputs, and the lambdas use direct indexing (q[2], etc.). Running the example with --test will make Warp compile this kernel and it aborts because wp.transform isn’t subscriptable and vec_allclose can’t iterate it. Compare the transform’s translation and rotation explicitly instead.

         sphere_q = wp.transform(0.0, -2.0, 0.5, 0.0, 0.0, 0.0, 1.0)
         newton.examples.test_body_state(
             self.model,
             self.state_0,
             "sphere at rest pose",
-            lambda q, qd: newton.utils.vec_allclose(q, sphere_q, atol=1e-4),
+            lambda q, qd: newton.utils.vec_allclose(q.p, sphere_q.p, atol=1e-4)
+            and newton.utils.vec_allclose(q.q, sphere_q.q, atol=1e-4),
             [0],
         )
         capsule_q = wp.transform(0.0, 0.0, 1.0, 0.0, 0.0, 0.0, 1.0)
         newton.examples.test_body_state(
             self.model,
             self.state_0,
             "capsule at rest pose",
-            lambda q, qd: newton.utils.vec_allclose(q, capsule_q, atol=1e-4),
+            lambda q, qd: newton.utils.vec_allclose(q.p, capsule_q.p, atol=1e-4)
+            and newton.utils.vec_allclose(q.q, capsule_q.q, atol=1e-4),
             [1],
         )
         box_q = wp.transform(0.0, 2.0, 0.25, 0.0, 0.0, 0.0, 1.0)
         newton.examples.test_body_state(
             self.model,
             self.state_0,
             "box at rest pose",
-            lambda q, qd: newton.utils.vec_allclose(q, box_q, atol=0.1),
+            lambda q, qd: newton.utils.vec_allclose(q.p, box_q.p, atol=0.1)
+            and newton.utils.vec_allclose(q.q, box_q.q, atol=0.1),
             [2],
         )
         # we only test that the bunny didn't fall through the ground and didn't slide too far
         newton.examples.test_body_state(
             self.model,
             self.state_0,
             "bunny at rest pose",
-            lambda q, qd: q[2] > 0.01 and abs(q[0]) < 0.1 and abs(q[1] - 4.0) < 0.1,
+            lambda q, qd: q.p[2] > 0.01 and abs(q.p[0]) < 0.1 and abs(q.p[1] - 4.0) < 0.1,
             [3],
         )

⛔ Skipped due to learnings

Learnt from: dylanturpin
PR: newton-physics/newton#806
File: newton/_src/sim/ik/ik_objectives.py:0-0
Timestamp: 2025-09-25T16:14:22.002Z
Learning: wp.transform in NVIDIA Warp supports indexing using numerical indices (e.g., body_tf[0], body_tf[3], etc.) to access translation and rotation components. The indexing approach used in the Newton codebase is valid and compiles correctly.

Learnt from: dylanturpin
PR: newton-physics/newton#806
File: newton/_src/sim/ik/ik_objectives.py:0-0
Timestamp: 2025-09-25T16:14:22.002Z
Learning: In NVIDIA Warp's Newton physics library, wp.transform supports direct numerical indexing (e.g., body_tf[0], body_tf[1], body_tf[2] for position and body_tf[3], body_tf[4], body_tf[5], body_tf[6] for quaternion components) to access its elements. This is the standard API used throughout the codebase.

Learnt from: adenzler-nvidia
PR: newton-physics/newton#552
File: newton/_src/solvers/mujoco/solver_mujoco.py:0-0
Timestamp: 2025-08-18T15:56:26.587Z
Learning: In Newton's MuJoCo solver, when transforming joint axes from Newton's internal frame to MuJoCo's expected frame, use wp.quat_rotate(joint_rot, axis) not wp.quat_rotate_inv(joint_rot, axis). The joint_rot represents rotation from joint-local to body frame, so forward rotation is correct.

Reviewing files that changed from the base of the PR and between 90c32bf and caee6c5.

• newton/examples/__init__.py (5 hunks)
• newton/examples/basic/example_basic_joints.py (5 hunks)
• newton/examples/cloth/example_cloth_bending.py (2 hunks)
• newton/examples/cloth/example_cloth_franka.py (3 hunks)
• newton/examples/cloth/example_cloth_hanging.py (4 hunks)
• newton/examples/cloth/example_cloth_style3d.py (2 hunks)
• newton/examples/cloth/example_cloth_twist.py (3 hunks)
• newton/examples/mpm/example_mpm_anymal.py (5 hunks)
• newton/examples/robot/example_robot_allegro_hand.py (2 hunks)
• newton/examples/robot/example_robot_anymal_c_walk.py (1 hunks)
• newton/examples/robot/example_robot_humanoid.py (3 hunks)
• newton/examples/robot/example_robot_policy.py (2 hunks)
• newton/examples/selection/example_selection_articulations.py (2 hunks)
• newton/examples/selection/example_selection_cartpole.py (2 hunks)
• newton/examples/selection/example_selection_materials.py (2 hunks)
• newton/tests/test_examples.py (15 hunks)

• GitHub Check: Run GPU Benchmarks (Pull Request)
• GitHub Check: Run GPU Unit Tests on AWS EC2 (Pull Request)

newton/examples/basic/example_basic_joints.py (1)

199-226: Rename unused lambda parameters to satisfy lint

Ruff is still flagging the unused q parameters (ARG005), so CI will keep failing. Please rename the unused arguments to _q across these lambdas; this is the same lint issue that was called out earlier.

             newton.examples.test_body_state(
                 self.model,
                 self.state_0,
                 "static bodies are not moving",
-                lambda q, qd: max(abs(qd)) == 0.0,
+                lambda _q, qd: max(abs(qd)) == 0.0,
                 indices=[2, 4],
             )
             newton.examples.test_body_state(
                 self.model,
                 self.state_0,
                 "fixed link body has come to a rest",
-                lambda q, qd: max(abs(qd)) < 1e-2,
+                lambda _q, qd: max(abs(qd)) < 1e-2,
                 indices=[0],
             )
             newton.examples.test_body_state(
                 self.model,
                 self.state_0,
                 "slider link body has come to a rest",
-                lambda q, qd: max(abs(qd)) < 1e-5,
+                lambda _q, qd: max(abs(qd)) < 1e-5,
                 indices=[3],
             )
             newton.examples.test_body_state(
                 self.model,
                 self.state_0,
                 "movable links are not moving too fast",
-                lambda q, qd: max(abs(qd)) < 3.0,
+                lambda _q, qd: max(abs(qd)) < 3.0,
                 indices=[1, 5],
             )

newton/examples/cloth/example_cloth_style3d.py (1)

175-181: Rename unused lambda parameter to satisfy lint

Ruff (ARG005) complains about the unused qd argument, which will block pre-commit. Rename it to _qd (or _) so CI passes.

         newton.examples.test_particle_state(
             self.state_0,
             "particles are within a reasonable volume",
-            lambda q, qd: newton.utils.vec_inside_limits(q, p_lower, p_upper),
+            lambda q, _qd: newton.utils.vec_inside_limits(q, p_lower, p_upper),
         )

newton/examples/robot/example_robot_allegro_hand.py (1)

199-204: Correct transform access in Allegro hand test

Here too, q is a wp.transform, so q[2] will throw once the Warp kernel runs. Access the position via q.p[2], and mark the unused velocity argument to clear Ruff.

         newton.examples.test_body_state(
             self.model,
             self.state_0,
             "all bodies are above the ground",
-            lambda q, qd: q[2] > 0.9,
+            lambda q, _qd: q.p[2] > 0.9,
         )

⛔ Skipped due to learnings

Learnt from: dylanturpin
PR: newton-physics/newton#806
File: newton/_src/sim/ik/ik_objectives.py:0-0
Timestamp: 2025-09-25T16:14:22.002Z
Learning: In NVIDIA Warp's Newton physics library, wp.transform supports direct numerical indexing (e.g., body_tf[0], body_tf[1], body_tf[2] for position and body_tf[3], body_tf[4], body_tf[5], body_tf[6] for quaternion components) to access its elements. This is the standard API used throughout the codebase.

Learnt from: dylanturpin
PR: newton-physics/newton#806
File: newton/_src/sim/ik/ik_objectives.py:0-0
Timestamp: 2025-09-25T16:14:22.002Z
Learning: wp.transform in NVIDIA Warp supports indexing using numerical indices (e.g., body_tf[0], body_tf[3], etc.) to access translation and rotation components. The indexing approach used in the Newton codebase is valid and compiles correctly.

Learnt from: dylanturpin
PR: newton-physics/newton#806
File: newton/examples/ik/example_ik_franka.py:121-123
Timestamp: 2025-09-22T21:08:31.901Z
Learning: In the newton physics framework, when creating warp arrays for IK solver joint variables using wp.array(self.model.joint_q, shape=(1, coord_count)), the resulting array acts as a reference/pointer to the original model's joint coordinates, so updates from the IK solver automatically reflect in the model's joint_q buffer used for rendering, despite the general warp documentation suggesting copies are made by default.

Learnt from: dylanturpin
PR: newton-physics/newton#806
File: newton/examples/ik/example_ik_franka.py:121-123
Timestamp: 2025-09-22T21:08:31.901Z
Learning: In the newton physics framework, when creating warp arrays for IK solver joint variables using wp.array(self.model.joint_q, shape=(1, coord_count)), the resulting array acts as a reference/pointer to the original model's joint coordinates, so updates from the IK solver automatically reflect in the model's joint_q buffer used for rendering.

Learnt from: adenzler-nvidia
PR: newton-physics/newton#552
File: newton/_src/solvers/mujoco/solver_mujoco.py:0-0
Timestamp: 2025-08-18T15:56:26.587Z
Learning: In Newton's MuJoCo solver, when transforming joint axes from Newton's internal frame to MuJoCo's expected frame, use wp.quat_rotate(joint_rot, axis) not wp.quat_rotate_inv(joint_rot, axis). The joint_rot represents rotation from joint-local to body frame, so forward rotation is correct.

newton/examples/selection/example_selection_cartpole.py (2)

176-218: Confirm body index layout assumption

Assumes per-env bodies are contiguous and ordered [cart, pole1, pole2]. If asset order changes, indices will mismatch. Consider deriving indices from model.body_key names or ArticulationView metadata.

---

239-239: LGTM: updated runner signature

Switched to run(example, args), aligned with the new API.

newton/examples/robot/example_robot_anymal_c_walk.py (2)

254-254: LGTM: updated runner signature

Switched to run(example, args), aligned with the new API.

---

231-246: Fix CI import failure: gate top-level torch dependency

Module-level import torch breaks import in environments without PyTorch (see pipeline error). Defer/guard torch imports and JIT decorations so the module can be imported even when torch isn’t installed; raise a clear error only when executing this example.

Suggested approach (changes outside this hunk):

• Replace top-level import torch with a guarded import and flag:
  try:
  import torch # type: ignore
  TORCH_AVAILABLE = True
  except Exception:
  torch = None # type: ignore
  TORCH_AVAILABLE = False
• Define quat_rotate_inverse conditionally:
  if TORCH_AVAILABLE:
  @torch.jit.script
  def quat_rotate_inverse(...): ...
  else:
  def quat_rotate_inverse(*_args, **_kwargs):
  raise RuntimeError("This example requires PyTorch; install torch or skip it.")
• Delay from warp.torch import device_to_torch until inside Example.init and only if TORCH_AVAILABLE; otherwise raise a friendly error there.

Alternatively, install torch in CI for this test matrix.

newton/examples/selection/example_selection_materials.py (1)

282-282: LGTM: updated runner signature

Switched to run(example, args), aligned with the new API.

newton/examples/selection/example_selection_articulations.py (1)

309-309: LGTM: updated runner signature

Switched to run(example, args), aligned with the new API.

newton/examples/cloth/example_cloth_bending.py (3)

162-162: LGTM: updated runner signature

Switched to run(example, args), aligned with the new API.

---

132-138: Fix Warp lambda: Python max/abs breaks codegen

max(abs(qd)) is not Warp-friendly and causes kernel generation errors. Use wp.length(qd) (or squared length) instead.

-            "particles have come close to a rest",
-            lambda q, qd: max(abs(qd)) < 0.1,
+            "particles have come close to a rest",
+            lambda _q, qd: wp.length(qd) < 0.1,

---

139-145: Avoid complex multi-arg lambdas for Warp; use a named @wp.func

create_warp_function can fail to extract complex lambdas. Define a small Warp function and pass it instead.

-        p_lower = wp.vec3(-3.0, -3.0, 0.0)
-        p_upper = wp.vec3(3.0, 3.0, 2.0)
-        newton.examples.test_particle_state(
-            self.state_0,
-            "particles are within a reasonable volume",
-            lambda q, qd: newton.utils.vec_inside_limits(q, p_lower, p_upper),
-        )
+        p_lower = wp.vec3(-3.0, -3.0, 0.0)
+        p_upper = wp.vec3(3.0, 3.0, 2.0)
+
+        @wp.func
+        def _within_bounds(q: wp.vec3, _qd: wp.vec3) -> bool:
+            return newton.utils.vec_inside_limits(q, p_lower, p_upper)
+
+        newton.examples.test_particle_state(
+            self.state_0,
+            "particles are within a reasonable volume",
+            _within_bounds,
+        )

newton/tests/test_examples.py (2)

224-224: Normalize option keys to underscores for consistency.

use num_frames not num-frames; the builder will hyphenate automatically. Keeps style consistent and avoids mixed conventions.

Example fix (apply similarly across occurrences):

-    test_options={"num-frames": 200},
+    test_options={"num_frames": 200},

-    test_options_cpu={"width": 32, "height": 16, "num-frames": 10},
+    test_options_cpu={"width": 32, "height": 16, "num_frames": 10},

Based on learnings

Also applies to: 235-240, 251-251, 259-271, 277-279, 285-287, 293-295, 307-309, 315-316, 322-324, 331-331, 337-337, 344-346, 352-354, 360-360, 373-375, 382-382, 391-391, 398-398, 406-406, 415-416, 438-439, 469-470, 477-478, 485-486, 499-500, 508-509, 517-518, 526-527, 535-536, 549-550, 562-562, 570-570, 578-578

---

87-92: Don’t fail the whole suite on missing example modules; skip gracefully.

Current import check raises ImportError and aborts CI. Skip the test when a module is absent.

Apply this diff:

-    # verify the module exists
-    try:
-        importlib.import_module(f"newton.examples.{name}")
-    except ImportError as e:
-        raise ImportError(f"Test module {name} not found") from e
+    # verify the module exists; if missing, register a skipped test
+    try:
+        importlib.import_module(f"newton.examples.{name}")
+    except ImportError as e:
+        def _skipped(test, device):
+            test.skipTest(f"Example module newton.examples.{name} not found: {e}")
+        test_name = f"test_{name}_{test_suffix}" if test_suffix else f"test_{name}"
+        add_function_test(cls, test_name, _skipped, devices=devices, check_output=False)
+        return

As per pipeline failures

newton/examples/cloth/example_cloth_franka.py (1)

555-573: Make test lambdas Warp-safe and silence unused-arg lint (ARG005).

• max(abs(qd)) won’t compile inside a Warp-created function.
• Rename unused lambda params to _ to satisfy Ruff.

Apply this diff:

     newton.examples.test_particle_state(
         self.state_0,
         "particles are within a reasonable volume",
-        lambda q, qd: newton.utils.vec_inside_limits(q, p_lower, p_upper),
+        lambda q, _: newton.utils.vec_inside_limits(q, p_lower, p_upper),
     )
     newton.examples.test_particle_state(
         self.state_0,
         "particle velocities are within a reasonable range",
-        lambda q, qd: max(abs(qd)) < 2.0,
+        lambda _, qd: wp.length(qd) < 2.0,
     )
     newton.examples.test_body_state(
         self.model,
         self.state_0,
         "body velocities are within a reasonable range",
-        lambda q, qd: max(abs(qd)) < 0.7,
+        lambda _, qd: wp.length(qd) < 0.7,
     )

As per coding guidelines and static analysis hints. Based on learnings

newton/examples/cloth/example_cloth_twist.py (1)

292-305: Use Warp intrinsics in test lambdas; fix unused params.

Replace Python builtins and rename unused args to _.

Apply this diff:

     newton.examples.test_particle_state(
         self.state_0,
         "particles are within a reasonable volume",
-        lambda q, qd: newton.utils.vec_inside_limits(q, p_lower, p_upper),
+        lambda q, _: newton.utils.vec_inside_limits(q, p_lower, p_upper),
     )
     newton.examples.test_particle_state(
         self.state_0,
         "particle velocities are within a reasonable range",
-        lambda q, qd: max(abs(qd)) < 0.7,
+        lambda _, qd: wp.length(qd) < 0.7,
     )

As per coding guidelines and static analysis hints. Based on learnings

newton/examples/cloth/example_cloth_hanging.py (1)

187-204: Silence unused-arg lint and keep Warp-compiled lambdas minimal.

qd isn’t used; rename to _ to pass Ruff and keep the Warp-compiled callable clean.

Apply this diff:

     if self.solver_type != "style3d":
         # TODO(Style3D): handle ground collisions
         newton.examples.test_particle_state(
             self.state_0,
             "particles are above the ground",
-            lambda q, qd: q[2] > 0.0,
+            lambda q, _: q[2] > 0.0,
         )

     min_x = -float(self.sim_width) * 0.11
     p_lower = wp.vec3(min_x, -4.0, -1.8)
     p_upper = wp.vec3(0.1, 7.0, 4.0)
     newton.examples.test_particle_state(
         self.state_0,
         "particles are within a reasonable volume",
-        lambda q, qd: newton.utils.vec_inside_limits(q, p_lower, p_upper),
+        lambda q, _: newton.utils.vec_inside_limits(q, p_lower, p_upper),
     )

As per static analysis hints

newton/examples/__init__.py (2)

42-45: Handle Warp extension types without __dict__.

Core Newton types such as newton.Model, State, Control, and Contacts are Warp extension classes that don’t expose a Python __dict__. Hitting _find_nonfinite(model) therefore raises AttributeError, so the new --test flow exits before reporting non-finite buffers. Add a hasattr(obj, "__dict__") guard with a safe fallback iteration (e.g., dir() + getattr()) to keep the helper working across all Newton objects.

-    for key, attr in obj.__dict__.items():
+    if hasattr(obj, "__dict__"):
+        members = obj.__dict__.items()
+    else:
+        members = ((name, getattr(obj, name)) for name in dir(obj) if not name.startswith("_"))
+    for key, attr in members:

---

103-105: Coerce body keys to strings before joining.

model.body_key can contain NumPy/warp integers, so ", ".join(failed_bodies) throws TypeError when the failure path triggers. Convert each identifier to str() first so the error message is always constructed.

-        failed_bodies = body_key[np.where(failures_np)[0]]
-        raise ValueError(f'Test "{test_name}" failed for the following bodies: [{", ".join(failed_bodies)}]')
+        failed_bodies = body_key[np.where(failures_np)[0]]
+        failed_labels = ", ".join(str(key) for key in np.atleast_1d(failed_bodies))
+        raise ValueError(f'Test "{test_name}" failed for the following bodies: [{failed_labels}]')

Reviewing files that changed from the base of the PR and between caee6c5 and d5f4c5d.

• asv/benchmarks/simulation/bench_cloth.py (1 hunks)
• newton/examples/__init__.py (5 hunks)
• newton/examples/mpm/example_mpm_grain_rendering.py (2 hunks)
• newton/examples/mpm/example_mpm_granular.py (2 hunks)
• newton/examples/mpm/example_mpm_multi_material.py (2 hunks)
• newton/tests/test_examples.py (15 hunks)

• GitHub Check: Run GPU Unit Tests on AWS EC2 (Pull Request)
• GitHub Check: Run GPU Benchmarks (Pull Request)

asv/benchmarks/simulation/bench_cloth.py (1)

38-38: Update to new run() signature looks good

Passing args=None is appropriate for benchmarks so the test-only paths in run() remain disabled.

newton/tests/test_examples.py (2)

224-224: Use underscore option keys for consistency (auto-converted to hyphens).

Prefer num_frames (and other underscored keys) so _build_command_line_options consistently emits the correct CLI flags.

-    test_options={"num-frames": 200},
+    test_options={"num_frames": 200},

Repeat similarly for other "num-frames" occurrences in this file.

Also applies to: 239-240, 251-251, 260-260, 269-271, 278-278, 285-285, 291-291, 305-306, 320-321, 342-343, 350-351, 466-467, 474-475, 482-483, 495-497, 505-506, 514-515, 523-524, 532-533, 546-547, 559-560, 567-568, 575-576

---

87-92: Don’t abort suite on missing example; register a skipped test instead.

Gracefully handle ImportError by registering a test that calls skip at runtime.

-    # verify the module exists
-    try:
-        importlib.import_module(f"newton.examples.{name}")
-    except ImportError as e:
-        raise ImportError(f"Test module {name} not found") from e
+    # verify the module exists; if missing, register a skipped test
+    try:
+        importlib.import_module(f"newton.examples.{name}")
+    except ImportError:
+        def _skip_missing(test, device):
+            test.skipTest(f"Test module {name} not found")
+        test_name = f"test_{name}_{test_suffix}" if test_suffix else f"test_{name}"
+        add_function_test(cls, test_name, _skip_missing, devices=devices, check_output=False)
+        return

newton/examples/__init__.py (2)

37-46: Make _find_nonfinite robust for objects without dict.

Some Newton/Warp types don’t expose __dict__; fall back to iterating attributes via dir(...).

-    for key, attr in obj.__dict__.items():
+    if hasattr(obj, "__dict__"):
+        members = obj.__dict__.items()
+    else:
+        members = ((name, getattr(obj, name)) for name in dir(obj) if not name.startswith("_"))
+    for key, attr in members:
         if isinstance(attr, wp.array):
             if not np.isfinite(attr.numpy()).all():
                 nonfinite_members.append(key)

---

103-106: Join failure labels as strings to avoid TypeError.

failed_bodies may contain non-strings (e.g., NumPy ints). Convert before joining.

-            raise ValueError(f'Test "{test_name}" failed for the following bodies: [{", ".join(failed_bodies)}]')
+            failed_labels = ", ".join(str(k) for k in failed_bodies.tolist())
+            raise ValueError(f'Test "{test_name}" failed for the following bodies: [{failed_labels}]')

Reviewing files that changed from the base of the PR and between d5f4c5d and 27849be.

• asv/benchmarks/simulation/bench_cloth.py (2 hunks)

• GitHub Check: Run GPU Unit Tests on AWS EC2 (Pull Request)
• GitHub Check: Run GPU Benchmarks (Pull Request)