From 749b0e0abeb2260ca1f7d2858ee308a4659d59b7 Mon Sep 17 00:00:00 2001
From: twidmer <twidmer@nvidia.com>
Date: Thu, 2 Apr 2026 11:33:38 +0200
Subject: [PATCH 01/10] First attempt to bring support for speculative contacts
 into the collision pipeline

---
 newton/__init__.py                   |   2 +
 newton/_src/geometry/narrow_phase.py |  64 ++++-
 newton/_src/sim/__init__.py          |   3 +-
 newton/_src/sim/collide.py           | 354 ++++++++++++++++++++-------
 newton/_src/sim/model.py             |   6 +-
 5 files changed, 339 insertions(+), 90 deletions(-)

diff --git a/newton/__init__.py b/newton/__init__.py
index 6b1517e1b1..fa3f07f7f8 100644
--- a/newton/__init__.py
+++ b/newton/__init__.py
@@ -56,6 +56,7 @@
     JointType,
     Model,
     ModelBuilder,
+    SpeculativeContactConfig,
     State,
     eval_fk,
     eval_ik,
@@ -73,6 +74,7 @@
     "JointType",
     "Model",
     "ModelBuilder",
+    "SpeculativeContactConfig",
     "State",
     "eval_fk",
     "eval_ik",
diff --git a/newton/_src/geometry/narrow_phase.py b/newton/_src/geometry/narrow_phase.py
index bf070428ca..e43cdd5e76 100644
--- a/newton/_src/geometry/narrow_phase.py
+++ b/newton/_src/geometry/narrow_phase.py
@@ -125,7 +125,7 @@ def write_contact_simple(
         writer_data.contact_tangent[index] = wp.normalize(world_x - wp.dot(world_x, normal) * normal)
 
 
-def create_narrow_phase_primitive_kernel(writer_func: Any):
+def create_narrow_phase_primitive_kernel(writer_func: Any, speculative: bool = False):
     """
     Create a kernel for fast analytical collision detection of primitive shapes.
 
@@ -136,6 +136,8 @@ def create_narrow_phase_primitive_kernel(writer_func: Any):
 
     Args:
         writer_func: Contact writer function (e.g., write_contact_simple)
+        speculative: When True, the kernel reads per-shape velocity arrays and
+            extends ``gap_sum`` by a scalar speculative margin.
 
     Returns:
         A warp kernel for primitive collision detection
@@ -153,6 +155,10 @@ def narrow_phase_primitive_kernel(
         shape_flags: wp.array[wp.int32],
         writer_data: Any,
         total_num_threads: int,
+        shape_lin_vel: wp.array[wp.vec3],
+        shape_ang_speed_bound: wp.array[float],
+        speculative_dt: float,
+        max_speculative_extension: float,
         # Output: pairs that need GJK/MPR processing
         gjk_candidate_pairs: wp.array[wp.vec2i],
         gjk_candidate_pairs_count: wp.array[int],
@@ -233,6 +239,11 @@ def narrow_phase_primitive_kernel(
             gap_b = shape_gap[shape_b]
             gap_sum = gap_a + gap_b
 
+            if wp.static(speculative):
+                vel_rel = shape_lin_vel[shape_b] - shape_lin_vel[shape_a]
+                rel_speed = wp.length(vel_rel) + shape_ang_speed_bound[shape_a] + shape_ang_speed_bound[shape_b]
+                gap_sum = gap_sum + wp.min(rel_speed * speculative_dt, max_speculative_extension)
+
             # =====================================================================
             # Route heightfield pairs.
             # Heightfield-vs-mesh and heightfield-vs-heightfield go through the
@@ -593,7 +604,11 @@ def narrow_phase_primitive_kernel(
 
 
 def create_narrow_phase_kernel_gjk_mpr(
-    external_aabb: bool, writer_func: Any, support_func: Any = None, post_process_contact: Any = None
+    external_aabb: bool,
+    writer_func: Any,
+    support_func: Any = None,
+    post_process_contact: Any = None,
+    speculative: bool = False,
 ):
     """
     Create a GJK/MPR narrow phase kernel for complex convex shape collisions.
@@ -606,6 +621,10 @@ def create_narrow_phase_kernel_gjk_mpr(
 
     The remaining pairs are complex convex-convex (plane-box, plane-cylinder,
     plane-cone, box-box, cylinder-cylinder, etc.) that need GJK/MPR.
+
+    Args:
+        speculative: When True, extends ``gap_sum`` by a scalar speculative
+            margin derived from per-shape velocity arrays.
     """
 
     @wp.kernel(enable_backward=False, module="unique")
@@ -622,6 +641,10 @@ def narrow_phase_kernel_gjk_mpr(
         shape_aabb_upper: wp.array[wp.vec3],
         writer_data: Any,
         total_num_threads: int,
+        shape_lin_vel: wp.array[wp.vec3],
+        shape_ang_speed_bound: wp.array[float],
+        speculative_dt: float,
+        max_speculative_extension: float,
     ):
         """
         GJK/MPR collision detection for complex convex pairs.
@@ -737,6 +760,11 @@ def narrow_phase_kernel_gjk_mpr(
             gap_b = shape_gap[shape_b]
             gap_sum = gap_a + gap_b
 
+            if wp.static(speculative):
+                vel_rel = shape_lin_vel[shape_b] - shape_lin_vel[shape_a]
+                rel_speed = wp.length(vel_rel) + shape_ang_speed_bound[shape_a] + shape_ang_speed_bound[shape_b]
+                gap_sum = gap_sum + wp.min(rel_speed * speculative_dt, max_speculative_extension)
+
             # Find and write contacts using GJK/MPR
             wp.static(
                 create_find_contacts(writer_func, support_func=support_func, post_process_contact=post_process_contact)
@@ -1390,6 +1418,7 @@ def __init__(
         has_meshes: bool = True,
         has_heightfields: bool = False,
         use_lean_gjk_mpr: bool = False,
+        speculative: bool = False,
     ) -> None:
         """
         Initialize NarrowPhase with pre-allocated buffers.
@@ -1413,6 +1442,10 @@ def __init__(
                 Defaults to True for safety. Set to False when constructing from a model with no meshes.
             has_heightfields: Whether the scene contains any heightfield shapes (GeoType.HFIELD). When True,
                 heightfield collision buffers and kernels are allocated. Defaults to False.
+            speculative: Enable speculative contact support in narrow-phase kernels.
+                When True, kernel variants that read per-shape velocity arrays and
+                extend gap thresholds are compiled. When False (default), the
+                speculative code paths are eliminated at compile time.
         """
         self.max_candidate_pairs = max_candidate_pairs
         self.max_triangle_pairs = max_triangle_pairs
@@ -1460,9 +1493,11 @@ def __init__(
         self.tile_size_mesh_plane = 512
         self.block_dim = 128
 
+        self.speculative = speculative
+
         # Create the appropriate kernel variants
         # Primitive kernel handles lightweight primitives and routes remaining pairs
-        self.primitive_kernel = create_narrow_phase_primitive_kernel(writer_func)
+        self.primitive_kernel = create_narrow_phase_primitive_kernel(writer_func, speculative=speculative)
         # GJK/MPR kernel handles remaining convex-convex pairs
         if use_lean_gjk_mpr:
             # Use lean support function (CONVEX_MESH, BOX, SPHERE only) and lean post-processing
@@ -1472,9 +1507,12 @@ def __init__(
                 writer_func,
                 support_func=support_map_lean,
                 post_process_contact=post_process_minkowski_only,
+                speculative=speculative,
             )
         else:
-            self.narrow_phase_kernel = create_narrow_phase_kernel_gjk_mpr(self.external_aabb, writer_func)
+            self.narrow_phase_kernel = create_narrow_phase_kernel_gjk_mpr(
+                self.external_aabb, writer_func, speculative=speculative
+            )
         # Create triangle contacts kernel when meshes or heightfields are present
         if has_meshes or has_heightfields:
             self.mesh_triangle_contacts_kernel = create_narrow_phase_process_mesh_triangle_contacts_kernel(writer_func)
@@ -1649,6 +1687,10 @@ def launch_custom_write(
         heightfield_elevations: wp.array[wp.float32] | None = None,
         writer_data: Any,
         device: Devicelike | None = None,  # Device to launch on
+        shape_lin_vel: wp.array[wp.vec3] | None = None,
+        shape_ang_speed_bound: wp.array[wp.float32] | None = None,
+        speculative_dt: float = 0.0,
+        max_speculative_extension: float = 0.0,
     ) -> None:
         """
         Launch narrow phase collision detection with a custom contact writer struct.
@@ -1680,6 +1722,12 @@ def launch_custom_write(
         # Clear all counters with a single kernel launch (consolidated counter array)
         self._counter_array.zero_()
 
+        # Resolve speculative velocity arrays (empty when disabled)
+        _empty_vec3 = wp.empty(0, dtype=wp.vec3, device=device)
+        _empty_float = wp.empty(0, dtype=wp.float32, device=device)
+        _slv = shape_lin_vel if shape_lin_vel is not None else _empty_vec3
+        _sasb = shape_ang_speed_bound if shape_ang_speed_bound is not None else _empty_float
+
         # Stage 1: Launch primitive kernel for fast analytical collisions
         # This handles sphere-sphere, sphere-capsule, capsule-capsule, plane-sphere, plane-capsule
         # and routes remaining pairs to gjk_candidate_pairs and mesh buffers
@@ -1697,6 +1745,10 @@ def launch_custom_write(
                 shape_flags,
                 writer_data,
                 self.total_num_threads,
+                _slv,
+                _sasb,
+                speculative_dt,
+                max_speculative_extension,
             ],
             outputs=[
                 self.gjk_candidate_pairs,
@@ -1736,6 +1788,10 @@ def launch_custom_write(
                 self.shape_aabb_upper,
                 writer_data,
                 self.total_num_threads,
+                _slv,
+                _sasb,
+                speculative_dt,
+                max_speculative_extension,
             ],
             device=device,
             block_dim=self.block_dim,
diff --git a/newton/_src/sim/__init__.py b/newton/_src/sim/__init__.py
index bd68e0a42f..1bca490976 100644
--- a/newton/_src/sim/__init__.py
+++ b/newton/_src/sim/__init__.py
@@ -3,7 +3,7 @@
 
 from .articulation import eval_fk, eval_ik, eval_jacobian, eval_mass_matrix
 from .builder import ModelBuilder
-from .collide import CollisionPipeline
+from .collide import CollisionPipeline, SpeculativeContactConfig
 from .contacts import Contacts
 from .control import Control
 from .enums import (
@@ -25,6 +25,7 @@
     "JointType",
     "Model",
     "ModelBuilder",
+    "SpeculativeContactConfig",
     "State",
     "eval_fk",
     "eval_ik",
diff --git a/newton/_src/sim/collide.py b/newton/_src/sim/collide.py
index 49cc22bba9..6a0cbead6f 100644
--- a/newton/_src/sim/collide.py
+++ b/newton/_src/sim/collide.py
@@ -3,6 +3,7 @@
 
 from __future__ import annotations
 
+import dataclasses
 from typing import Literal
 
 import numpy as np
@@ -27,6 +28,25 @@
 from ..sim.state import State
 
 
+@dataclasses.dataclass
+class SpeculativeContactConfig:
+    """Configuration for speculative contact detection.
+
+    When passed to :class:`CollisionPipeline`, AABBs and gap thresholds are
+    expanded based on per-shape velocity so that contacts which will occur
+    within the next collision update interval are detected early.
+
+    Attributes:
+        max_speculative_extension: Maximum speculative gap extension [m].
+            Clamps ``vel * dt`` to prevent excessively large AABBs.
+        collision_update_dt: Default time interval between collision updates [s].
+            Can be overridden per-call via ``CollisionPipeline.collide(dt=...)``.
+    """
+
+    max_speculative_extension: float = 0.1
+    collision_update_dt: float = 1.0 / 60.0
+
+
 @wp.struct
 class ContactWriterData:
     """Contact writer data for collide write_contact function."""
@@ -53,6 +73,11 @@ class ContactWriterData:
     out_stiffness: wp.array[float]
     out_damping: wp.array[float]
     out_friction: wp.array[float]
+    # Speculative contact fields (empty arrays / 0.0 when disabled)
+    shape_lin_vel: wp.array[wp.vec3]
+    shape_ang_speed_bound: wp.array[float]
+    speculative_dt: float
+    max_speculative_extension: float
 
 
 @wp.func
@@ -95,6 +120,21 @@ def write_contact(
     gap_b = writer_data.shape_gap[contact_data.shape_b]
     contact_gap = gap_a + gap_b
 
+    # Directed speculative gap extension: only extend for approaching pairs
+    if writer_data.speculative_dt > 0.0:
+        vel_a = writer_data.shape_lin_vel[contact_data.shape_a]
+        vel_b = writer_data.shape_lin_vel[contact_data.shape_b]
+        v_approach = (
+            wp.dot(vel_b - vel_a, contact_normal_a_to_b)
+            + writer_data.shape_ang_speed_bound[contact_data.shape_a]
+            + writer_data.shape_ang_speed_bound[contact_data.shape_b]
+        )
+        spec_gap = wp.min(
+            wp.max(v_approach * writer_data.speculative_dt, 0.0),
+            writer_data.max_speculative_extension,
+        )
+        contact_gap = contact_gap + spec_gap
+
     index = output_index
 
     if index < 0:
@@ -138,105 +178,186 @@ def write_contact(
         writer_data.out_friction[index] = contact_data.contact_friction_scale
 
 
+def _create_compute_shape_aabbs(speculative: bool):
+    """Factory for the AABB kernel. When *speculative* is True the kernel reads
+    per-shape velocity arrays and applies directed linear + isotropic angular
+    expansion.  When False the extra code is eliminated at compile time via
+    ``wp.static``."""
+
+    @wp.kernel(enable_backward=False)
+    def compute_shape_aabbs(
+        body_q: wp.array[wp.transform],
+        shape_transform: wp.array[wp.transform],
+        shape_body: wp.array[int],
+        shape_type: wp.array[int],
+        shape_scale: wp.array[wp.vec3],
+        shape_collision_radius: wp.array[float],
+        shape_source_ptr: wp.array[wp.uint64],
+        shape_margin: wp.array[float],
+        shape_gap: wp.array[float],
+        shape_collision_aabb_lower: wp.array[wp.vec3],
+        shape_collision_aabb_upper: wp.array[wp.vec3],
+        shape_lin_vel: wp.array[wp.vec3],
+        shape_ang_speed_bound: wp.array[float],
+        speculative_dt: float,
+        # outputs
+        aabb_lower: wp.array[wp.vec3],
+        aabb_upper: wp.array[wp.vec3],
+    ):
+        """Compute axis-aligned bounding boxes for each shape in world space.
+
+        Uses support function for most shapes. Meshes and heightfields use the
+        pre-computed local AABB transformed to world frame. Infinite planes use
+        bounding sphere fallback. AABBs are enlarged by per-shape effective gap
+        for contact detection (``shape_margin + shape_gap``), and optionally by
+        speculative velocity expansion when enabled.
+        """
+        shape_id = wp.tid()
+
+        rigid_id = shape_body[shape_id]
+        geo_type = shape_type[shape_id]
+
+        # Compute world transform
+        if rigid_id == -1:
+            X_ws = shape_transform[shape_id]
+        else:
+            X_ws = wp.transform_multiply(body_q[rigid_id], shape_transform[shape_id])
+
+        pos = wp.transform_get_translation(X_ws)
+        orientation = wp.transform_get_rotation(X_ws)
+
+        # Enlarge AABB by per-shape effective gap for contact detection
+        effective_gap = shape_margin[shape_id] + shape_gap[shape_id]
+        margin_vec = wp.vec3(effective_gap, effective_gap, effective_gap)
+
+        # Check if this is an infinite plane, mesh, or heightfield
+        scale = shape_scale[shape_id]
+        is_infinite_plane = (geo_type == GeoType.PLANE) and (scale[0] == 0.0 and scale[1] == 0.0)
+        is_mesh = geo_type == GeoType.MESH
+        is_hfield = geo_type == GeoType.HFIELD
+
+        if is_infinite_plane:
+            # Bounding sphere fallback for infinite planes
+            radius = shape_collision_radius[shape_id]
+            half_extents = wp.vec3(radius, radius, radius)
+            aabb_lower[shape_id] = pos - half_extents - margin_vec
+            aabb_upper[shape_id] = pos + half_extents + margin_vec
+        elif is_mesh or is_hfield:
+            # Tight local AABB transformed to world space.
+            # Scale is already baked into shape_collision_aabb by the builder,
+            # so we only need to handle the rotation here.
+            local_lo = shape_collision_aabb_lower[shape_id]
+            local_hi = shape_collision_aabb_upper[shape_id]
+
+            center = (local_lo + local_hi) * 0.5
+            half = (local_hi - local_lo) * 0.5
+
+            # Rotate center to world frame
+            world_center = wp.quat_rotate(orientation, center) + pos
+
+            # Rotated AABB half-extents via abs of rotation matrix columns
+            r0 = wp.quat_rotate(orientation, wp.vec3(1.0, 0.0, 0.0))
+            r1 = wp.quat_rotate(orientation, wp.vec3(0.0, 1.0, 0.0))
+            r2 = wp.quat_rotate(orientation, wp.vec3(0.0, 0.0, 1.0))
+
+            world_half = wp.vec3(
+                wp.abs(r0[0]) * half[0] + wp.abs(r1[0]) * half[1] + wp.abs(r2[0]) * half[2],
+                wp.abs(r0[1]) * half[0] + wp.abs(r1[1]) * half[1] + wp.abs(r2[1]) * half[2],
+                wp.abs(r0[2]) * half[0] + wp.abs(r1[2]) * half[1] + wp.abs(r2[2]) * half[2],
+            )
+
+            lo = world_center - world_half - margin_vec
+            hi = world_center + world_half + margin_vec
+
+            if wp.static(speculative):
+                v = shape_lin_vel[shape_id]
+                vel_dt = v * speculative_dt
+                ang_ext = shape_ang_speed_bound[shape_id] * speculative_dt
+                ang_vec = wp.vec3(ang_ext, ang_ext, ang_ext)
+                lo = lo - wp.max(-vel_dt, wp.vec3(0.0, 0.0, 0.0)) - ang_vec
+                hi = hi + wp.max(vel_dt, wp.vec3(0.0, 0.0, 0.0)) + ang_vec
+
+            aabb_lower[shape_id] = lo
+            aabb_upper[shape_id] = hi
+        else:
+            # Use support function to compute tight AABB
+            shape_data = GenericShapeData()
+            shape_data.shape_type = geo_type
+            shape_data.scale = scale
+            shape_data.auxiliary = wp.vec3(0.0, 0.0, 0.0)
+
+            if geo_type == GeoType.CONVEX_MESH:
+                shape_data.auxiliary = pack_mesh_ptr(shape_source_ptr[shape_id])
+
+            data_provider = SupportMapDataProvider()
+
+            aabb_min_world, aabb_max_world = compute_tight_aabb_from_support(
+                shape_data, orientation, pos, data_provider
+            )
+
+            lo = aabb_min_world - margin_vec
+            hi = aabb_max_world + margin_vec
+
+            if wp.static(speculative):
+                v = shape_lin_vel[shape_id]
+                vel_dt = v * speculative_dt
+                ang_ext = shape_ang_speed_bound[shape_id] * speculative_dt
+                ang_vec = wp.vec3(ang_ext, ang_ext, ang_ext)
+                lo = lo - wp.max(-vel_dt, wp.vec3(0.0, 0.0, 0.0)) - ang_vec
+                hi = hi + wp.max(vel_dt, wp.vec3(0.0, 0.0, 0.0)) + ang_vec
+
+            aabb_lower[shape_id] = lo
+            aabb_upper[shape_id] = hi
+
+    return compute_shape_aabbs
+
+
+_compute_shape_aabbs = _create_compute_shape_aabbs(speculative=False)
+_compute_shape_aabbs_speculative = _create_compute_shape_aabbs(speculative=True)
+
+
 @wp.kernel(enable_backward=False)
-def compute_shape_aabbs(
-    body_q: wp.array[wp.transform],
-    shape_transform: wp.array[wp.transform],
+def compute_shape_vel(
+    body_qd: wp.array[wp.spatial_vector],
     shape_body: wp.array[int],
-    shape_type: wp.array[int],
-    shape_scale: wp.array[wp.vec3],
-    shape_collision_radius: wp.array[float],
-    shape_source_ptr: wp.array[wp.uint64],
-    shape_margin: wp.array[float],
-    shape_gap: wp.array[float],
+    shape_transform: wp.array[wp.transform],
     shape_collision_aabb_lower: wp.array[wp.vec3],
     shape_collision_aabb_upper: wp.array[wp.vec3],
     # outputs
-    aabb_lower: wp.array[wp.vec3],
-    aabb_upper: wp.array[wp.vec3],
+    shape_lin_vel: wp.array[wp.vec3],
+    shape_ang_speed_bound: wp.array[float],
 ):
-    """Compute axis-aligned bounding boxes for each shape in world space.
+    """Compute per-shape linear velocity and angular speed bound for speculative contacts.
 
-    Uses support function for most shapes. Meshes and heightfields use the pre-computed
-    local AABB transformed to world frame. Infinite planes use bounding sphere fallback.
-    AABBs are enlarged by per-shape effective gap for contact detection.
-    Effective expansion is ``shape_margin + shape_gap``.
+    Linear velocity is the body COM velocity. The angular speed bound is
+    ``|omega| * r_max`` where ``r_max`` is the distance from the body COM to the
+    farthest point of the shape, estimated as
+    ``|shape_offset| + local_aabb_half_diagonal``.
     """
     shape_id = wp.tid()
-
     rigid_id = shape_body[shape_id]
-    geo_type = shape_type[shape_id]
 
-    # Compute world transform
     if rigid_id == -1:
-        X_ws = shape_transform[shape_id]
-    else:
-        X_ws = wp.transform_multiply(body_q[rigid_id], shape_transform[shape_id])
-
-    pos = wp.transform_get_translation(X_ws)
-    orientation = wp.transform_get_rotation(X_ws)
-
-    # Enlarge AABB by per-shape effective gap for contact detection
-    effective_gap = shape_margin[shape_id] + shape_gap[shape_id]
-    margin_vec = wp.vec3(effective_gap, effective_gap, effective_gap)
-
-    # Check if this is an infinite plane, mesh, or heightfield
-    scale = shape_scale[shape_id]
-    is_infinite_plane = (geo_type == GeoType.PLANE) and (scale[0] == 0.0 and scale[1] == 0.0)
-    is_mesh = geo_type == GeoType.MESH
-    is_hfield = geo_type == GeoType.HFIELD
-
-    if is_infinite_plane:
-        # Bounding sphere fallback for infinite planes
-        radius = shape_collision_radius[shape_id]
-        half_extents = wp.vec3(radius, radius, radius)
-        aabb_lower[shape_id] = pos - half_extents - margin_vec
-        aabb_upper[shape_id] = pos + half_extents + margin_vec
-    elif is_mesh or is_hfield:
-        # Tight local AABB transformed to world space.
-        # Scale is already baked into shape_collision_aabb by the builder,
-        # so we only need to handle the rotation here.
-        local_lo = shape_collision_aabb_lower[shape_id]
-        local_hi = shape_collision_aabb_upper[shape_id]
-
-        center = (local_lo + local_hi) * 0.5
-        half = (local_hi - local_lo) * 0.5
-
-        # Rotate center to world frame
-        world_center = wp.quat_rotate(orientation, center) + pos
+        shape_lin_vel[shape_id] = wp.vec3(0.0, 0.0, 0.0)
+        shape_ang_speed_bound[shape_id] = 0.0
+        return
 
-        # Rotated AABB half-extents via abs of rotation matrix columns
-        r0 = wp.quat_rotate(orientation, wp.vec3(1.0, 0.0, 0.0))
-        r1 = wp.quat_rotate(orientation, wp.vec3(0.0, 1.0, 0.0))
-        r2 = wp.quat_rotate(orientation, wp.vec3(0.0, 0.0, 1.0))
+    qd = body_qd[rigid_id]
+    v_lin = wp.vec3(qd[0], qd[1], qd[2])
+    omega = wp.vec3(qd[3], qd[4], qd[5])
 
-        world_half = wp.vec3(
-            wp.abs(r0[0]) * half[0] + wp.abs(r1[0]) * half[1] + wp.abs(r2[0]) * half[2],
-            wp.abs(r0[1]) * half[0] + wp.abs(r1[1]) * half[1] + wp.abs(r2[1]) * half[2],
-            wp.abs(r0[2]) * half[0] + wp.abs(r1[2]) * half[1] + wp.abs(r2[2]) * half[2],
-        )
+    shape_lin_vel[shape_id] = v_lin
 
-        aabb_lower[shape_id] = world_center - world_half - margin_vec
-        aabb_upper[shape_id] = world_center + world_half + margin_vec
+    omega_mag = wp.length(omega)
+    if omega_mag > 0.0:
+        shape_offset = wp.transform_get_translation(shape_transform[shape_id])
+        local_lo = shape_collision_aabb_lower[shape_id]
+        local_hi = shape_collision_aabb_upper[shape_id]
+        half_diag = wp.length((local_hi - local_lo) * 0.5)
+        r_max = wp.length(shape_offset) + half_diag
+        shape_ang_speed_bound[shape_id] = omega_mag * r_max
     else:
-        # Use support function to compute tight AABB
-        # Create generic shape data
-        shape_data = GenericShapeData()
-        shape_data.shape_type = geo_type
-        shape_data.scale = scale
-        shape_data.auxiliary = wp.vec3(0.0, 0.0, 0.0)
-
-        # For CONVEX_MESH, pack the mesh pointer
-        if geo_type == GeoType.CONVEX_MESH:
-            shape_data.auxiliary = pack_mesh_ptr(shape_source_ptr[shape_id])
-
-        data_provider = SupportMapDataProvider()
-
-        # Compute tight AABB using helper function
-        aabb_min_world, aabb_max_world = compute_tight_aabb_from_support(shape_data, orientation, pos, data_provider)
-
-        aabb_lower[shape_id] = aabb_min_world - margin_vec
-        aabb_upper[shape_id] = aabb_max_world + margin_vec
+        shape_ang_speed_bound[shape_id] = 0.0
 
 
 @wp.kernel(enable_backward=False)
@@ -428,6 +549,7 @@ def __init__(
         | None = None,
         narrow_phase: NarrowPhase | None = None,
         sdf_hydroelastic_config: HydroelasticSDF.Config | None = None,
+        speculative_config: SpeculativeContactConfig | None = None,
     ):
         """
         Initialize the CollisionPipeline (expert API).
@@ -459,6 +581,12 @@ def __init__(
                 "nxn"/"sap" modes, ignored.
             sdf_hydroelastic_config: Configuration for
                 hydroelastic collision handling. Defaults to None.
+            speculative_config: Configuration for speculative contact detection.
+                When provided, AABBs and gap thresholds are expanded based on
+                per-shape velocity (linear + angular) so that contacts expected
+                within the next collision update interval are detected early.
+                ``None`` (default) disables speculative contacts with zero
+                runtime overhead via compile-time elimination.
 
         .. note::
             When ``requires_grad`` is true (explicitly or via ``model.requires_grad``),
@@ -477,6 +605,9 @@ def __init__(
         particle_count = model.particle_count
         device = model.device
 
+        self.speculative_config = speculative_config
+        self._speculative_enabled = speculative_config is not None
+
         # Resolve rigid contact capacity with explicit > model > estimated precedence.
         if rigid_contact_max is None:
             model_rigid_contact_max = int(getattr(model, "rigid_contact_max", 0) or 0)
@@ -627,6 +758,7 @@ def __init__(
                 has_meshes=has_meshes,
                 has_heightfields=has_heightfields,
                 use_lean_gjk_mpr=use_lean_gjk_mpr,
+                speculative=self._speculative_enabled,
             )
             self.hydroelastic_sdf = self.narrow_phase.hydroelastic_sdf
 
@@ -659,6 +791,14 @@ def __init__(
         self._soft_contact_max = soft_contact_max
         self.requires_grad = requires_grad
 
+        if self._speculative_enabled:
+            with wp.ScopedDevice(device):
+                self._shape_lin_vel = wp.zeros(shape_count, dtype=wp.vec3, device=device)
+                self._shape_ang_speed_bound = wp.zeros(shape_count, dtype=wp.float32, device=device)
+        else:
+            self._shape_lin_vel = wp.empty(0, dtype=wp.vec3, device=device)
+            self._shape_ang_speed_bound = wp.empty(0, dtype=wp.float32, device=device)
+
     @property
     def rigid_contact_max(self) -> int:
         """Maximum rigid contact buffer capacity used by this pipeline."""
@@ -717,6 +857,7 @@ def collide(
         contacts: Contacts,
         *,
         soft_contact_margin: float | None = None,
+        dt: float | None = None,
     ):
         """Run the collision pipeline using NarrowPhase.
 
@@ -741,6 +882,9 @@ def collide(
             contacts: The contacts buffer to populate (will be cleared first).
             soft_contact_margin: Margin for soft contact generation.
                 If ``None``, uses the value from construction.
+            dt: Override for the speculative collision update interval [s].
+                When ``None``, uses ``speculative_config.collision_update_dt``.
+                Ignored when speculative contacts are disabled.
         """
 
         contacts.clear()
@@ -753,15 +897,45 @@ def collide(
         # update any additional parameters
         soft_contact_margin = soft_contact_margin if soft_contact_margin is not None else self.soft_contact_margin
 
+        # Resolve speculative dt and max extension
+        if self._speculative_enabled:
+            cfg = self.speculative_config
+            speculative_dt = dt if dt is not None else cfg.collision_update_dt
+            max_speculative_extension = cfg.max_speculative_extension
+        else:
+            speculative_dt = 0.0
+            max_speculative_extension = 0.0
+
         # Rigid contact detection -- broad phase + narrow phase.
         # These kernels hardcode record_tape=False internally so they are
         # never captured on an active wp.Tape.  The differentiable
         # augmentation and soft-contact kernels that follow are tape-safe
         # and recorded normally.
 
+        # Compute per-shape velocity for speculative AABB expansion
+        if self._speculative_enabled:
+            wp.launch(
+                kernel=compute_shape_vel,
+                dim=model.shape_count,
+                inputs=[
+                    state.body_qd,
+                    model.shape_body,
+                    model.shape_transform,
+                    model.shape_collision_aabb_lower,
+                    model.shape_collision_aabb_upper,
+                ],
+                outputs=[
+                    self._shape_lin_vel,
+                    self._shape_ang_speed_bound,
+                ],
+                device=self.device,
+                record_tape=False,
+            )
+
         # Compute AABBs for all shapes (already expanded by per-shape effective gaps)
+        aabb_kernel = _compute_shape_aabbs_speculative if self._speculative_enabled else _compute_shape_aabbs
         wp.launch(
-            kernel=compute_shape_aabbs,
+            kernel=aabb_kernel,
             dim=model.shape_count,
             inputs=[
                 state.body_q,
@@ -775,6 +949,9 @@ def collide(
                 model.shape_gap,
                 model.shape_collision_aabb_lower,
                 model.shape_collision_aabb_upper,
+                self._shape_lin_vel,
+                self._shape_ang_speed_bound,
+                speculative_dt,
             ],
             outputs=[
                 self.narrow_phase.shape_aabb_lower,
@@ -867,6 +1044,11 @@ def collide(
         writer_data.out_damping = contacts.rigid_contact_damping
         writer_data.out_friction = contacts.rigid_contact_friction
 
+        writer_data.shape_lin_vel = self._shape_lin_vel
+        writer_data.shape_ang_speed_bound = self._shape_ang_speed_bound
+        writer_data.speculative_dt = speculative_dt
+        writer_data.max_speculative_extension = max_speculative_extension
+
         # Run narrow phase with custom contact writer (writes directly to Contacts format)
         self.narrow_phase.launch_custom_write(
             candidate_pair=self.broad_phase_shape_pairs,
@@ -888,6 +1070,10 @@ def collide(
             heightfield_elevations=model.heightfield_elevations,
             writer_data=writer_data,
             device=self.device,
+            shape_lin_vel=self._shape_lin_vel if self._speculative_enabled else None,
+            shape_ang_speed_bound=self._shape_ang_speed_bound if self._speculative_enabled else None,
+            speculative_dt=speculative_dt,
+            max_speculative_extension=max_speculative_extension,
         )
 
         # Differentiable contact augmentation: reconstruct world-space contact
diff --git a/newton/_src/sim/model.py b/newton/_src/sim/model.py
index a7539c66fb..f39017a7df 100644
--- a/newton/_src/sim/model.py
+++ b/newton/_src/sim/model.py
@@ -971,6 +971,7 @@ def collide(
         contacts: Contacts | None = None,
         *,
         collision_pipeline: CollisionPipeline | None = None,
+        dt: float | None = None,
     ) -> Contacts:
         """
         Generate contact points for the particles and rigid bodies in the model using the default collision
@@ -981,6 +982,9 @@ def collide(
             contacts: The contacts buffer to populate (will be cleared first). If None, a new
                 contacts buffer is allocated via :meth:`contacts`.
             collision_pipeline: Optional collision pipeline override.
+            dt: Override for the speculative collision update interval [s].
+                Forwarded to :meth:`CollisionPipeline.collide`. Ignored when
+                speculative contacts are disabled.
         """
         if collision_pipeline is not None:
             self._collision_pipeline = collision_pipeline
@@ -990,7 +994,7 @@ def collide(
         if contacts is None:
             contacts = self._collision_pipeline.contacts()
 
-        self._collision_pipeline.collide(state, contacts)
+        self._collision_pipeline.collide(state, contacts, dt=dt)
         return contacts
 
     def request_state_attributes(self, *attributes: str) -> None:

From 41ca9d79d07d4d6c7d48a3dcfed199b095d9579b Mon Sep 17 00:00:00 2001
From: twidmer <twidmer@nvidia.com>
Date: Thu, 2 Apr 2026 11:55:06 +0200
Subject: [PATCH 02/10] Add more unit tests for speculative contacts

---
 newton/tests/test_speculative_contacts.py | 265 ++++++++++++++++++++++
 1 file changed, 265 insertions(+)
 create mode 100644 newton/tests/test_speculative_contacts.py

diff --git a/newton/tests/test_speculative_contacts.py b/newton/tests/test_speculative_contacts.py
new file mode 100644
index 0000000000..315700b62a
--- /dev/null
+++ b/newton/tests/test_speculative_contacts.py
@@ -0,0 +1,265 @@
+# SPDX-FileCopyrightText: Copyright (c) 2025 The Newton Developers
+# SPDX-License-Identifier: Apache-2.0
+
+"""Tests for speculative contact support in the collision pipeline."""
+
+import unittest
+
+import numpy as np
+import warp as wp
+
+import newton
+from newton.tests.unittest_utils import add_function_test, get_cuda_test_devices
+
+
+def _build_two_sphere_model(
+    device,
+    gap: float = 3.0,
+    velocity: float = 0.0,
+    speculative_config: newton.SpeculativeContactConfig | None = None,
+):
+    """Build a simple scene with two spheres separated along the X axis.
+
+    Body A is at ``(-gap/2, 0, 0)`` moving with ``+velocity`` in X.
+    Body B is at ``(+gap/2, 0, 0)`` and is static (body index -1 via ground plane trick
+    is avoided; instead it's a dynamic body with zero velocity).
+
+    Returns:
+        model, state, pipeline, contacts
+    """
+    builder = newton.ModelBuilder(gravity=0.0)
+    builder.rigid_gap = 0.0
+
+    body_a = builder.add_body(xform=wp.transform(wp.vec3(-gap / 2.0, 0.0, 0.0)))
+    builder.add_shape_sphere(body_a, radius=0.5)
+    builder.body_qd[-1] = (velocity, 0.0, 0.0, 0.0, 0.0, 0.0)
+
+    body_b = builder.add_body(xform=wp.transform(wp.vec3(gap / 2.0, 0.0, 0.0)))
+    builder.add_shape_sphere(body_b, radius=0.5)
+
+    model = builder.finalize(device=device)
+    state = model.state()
+
+    pipeline = newton.CollisionPipeline(
+        model,
+        broad_phase="nxn",
+        speculative_config=speculative_config,
+    )
+    contacts = pipeline.contacts()
+    return model, state, pipeline, contacts
+
+
+def test_speculative_disabled_no_contacts(test, device):
+    """Two spheres far apart with no speculative config produce zero contacts."""
+    _, state, pipeline, contacts = _build_two_sphere_model(device, gap=3.0, velocity=100.0)
+    pipeline.collide(state, contacts)
+    count = contacts.rigid_contact_count.numpy()[0]
+    test.assertEqual(count, 0, "Non-speculative pipeline should not detect contacts for separated spheres")
+
+
+def test_speculative_enabled_catches_fast_object(test, device):
+    """Two spheres far apart but approaching fast produce speculative contacts."""
+    config = newton.SpeculativeContactConfig(
+        max_speculative_extension=10.0,
+        collision_update_dt=1.0 / 60.0,
+    )
+    _, state, pipeline, contacts = _build_two_sphere_model(
+        device,
+        gap=3.0,
+        velocity=200.0,
+        speculative_config=config,
+    )
+    pipeline.collide(state, contacts)
+    count = contacts.rigid_contact_count.numpy()[0]
+    test.assertGreater(count, 0, "Speculative pipeline should detect contacts for fast approaching spheres")
+
+
+def test_speculative_diverging_no_contacts(test, device):
+    """Two spheres moving apart should not produce speculative contacts.
+
+    Body A moves in -X (away from B). The directed gap extension should be
+    zero because the approach velocity is negative.
+    """
+    config = newton.SpeculativeContactConfig(
+        max_speculative_extension=10.0,
+        collision_update_dt=1.0 / 60.0,
+    )
+    _, state, pipeline, contacts = _build_two_sphere_model(
+        device,
+        gap=3.0,
+        velocity=-200.0,
+        speculative_config=config,
+    )
+    pipeline.collide(state, contacts)
+    count = contacts.rigid_contact_count.numpy()[0]
+    test.assertEqual(count, 0, "Speculative pipeline should not detect contacts for diverging spheres")
+
+
+def test_speculative_max_extension_clamp(test, device):
+    """Max speculative extension clamps the gap so very far objects are not detected."""
+    config = newton.SpeculativeContactConfig(
+        max_speculative_extension=0.01,
+        collision_update_dt=1.0 / 60.0,
+    )
+    _, state, pipeline, contacts = _build_two_sphere_model(
+        device,
+        gap=3.0,
+        velocity=200.0,
+        speculative_config=config,
+    )
+    pipeline.collide(state, contacts)
+    count = contacts.rigid_contact_count.numpy()[0]
+    test.assertEqual(count, 0, "Max extension clamp should prevent detection of far-away objects")
+
+
+def test_speculative_dt_override(test, device):
+    """Passing dt to collide() overrides the config default."""
+    config = newton.SpeculativeContactConfig(
+        max_speculative_extension=10.0,
+        collision_update_dt=1e-6,
+    )
+    _, state, pipeline, contacts = _build_two_sphere_model(
+        device,
+        gap=3.0,
+        velocity=200.0,
+        speculative_config=config,
+    )
+    # With the tiny default dt, no contacts
+    pipeline.collide(state, contacts)
+    count_tiny = contacts.rigid_contact_count.numpy()[0]
+    test.assertEqual(count_tiny, 0, "Tiny default dt should not produce contacts")
+
+    # Override with a large dt
+    contacts.clear()
+    pipeline.collide(state, contacts, dt=1.0 / 60.0)
+    count_override = contacts.rigid_contact_count.numpy()[0]
+    test.assertGreater(count_override, 0, "Overridden dt should produce contacts")
+
+
+def test_speculative_angular_velocity(test, device):
+    """Angular velocity contributes to speculative extension.
+
+    A spinning body should produce speculative contacts even with zero linear
+    velocity if the angular speed bound is large enough.
+    """
+    builder = newton.ModelBuilder(gravity=0.0)
+    builder.rigid_gap = 0.0
+
+    body_a = builder.add_body(xform=wp.transform(wp.vec3(-0.75, 0.0, 0.0)))
+    builder.add_shape_box(body_a, hx=0.5, hy=0.5, hz=0.5)
+    builder.body_qd[-1] = (0.0, 0.0, 0.0, 0.0, 0.0, 200.0)
+
+    body_b = builder.add_body(xform=wp.transform(wp.vec3(0.75, 0.0, 0.0)))
+    builder.add_shape_box(body_b, hx=0.5, hy=0.5, hz=0.5)
+
+    model = builder.finalize(device=device)
+    state = model.state()
+
+    config = newton.SpeculativeContactConfig(
+        max_speculative_extension=10.0,
+        collision_update_dt=1.0 / 60.0,
+    )
+    pipeline = newton.CollisionPipeline(model, broad_phase="nxn", speculative_config=config)
+    contacts = pipeline.contacts()
+    pipeline.collide(state, contacts)
+    count = contacts.rigid_contact_count.numpy()[0]
+    test.assertGreater(count, 0, "Angular velocity should contribute to speculative extension")
+
+
+def _run_sphere_vs_thin_box_sim(device, speculative_config, num_frames=5):
+    """Simulate a fast sphere aimed at a thin static box.
+
+    The sphere (radius 0.25) starts at x = -2 moving at +50 m/s.
+    The thin box (half-thickness 0.02 in X) is centred at the origin.
+    With dt = 1/60 the sphere travels ~0.83 m per frame -- much more than
+    the box thickness (0.04 m), so without speculative contacts the sphere
+    tunnels straight through.
+
+    Returns the final X position of the sphere body.
+    """
+    builder = newton.ModelBuilder(gravity=0.0)
+    builder.rigid_gap = 0.0
+
+    sphere_body = builder.add_body(xform=wp.transform(wp.vec3(-2.0, 0.0, 0.0)))
+    builder.add_shape_sphere(sphere_body, radius=0.25)
+    builder.body_qd[-1] = (50.0, 0.0, 0.0, 0.0, 0.0, 0.0)
+
+    builder.add_shape_box(
+        body=-1,
+        xform=wp.transform_identity(),
+        hx=0.02,
+        hy=1.0,
+        hz=1.0,
+    )
+
+    model = builder.finalize(device=device)
+
+    pipeline = newton.CollisionPipeline(
+        model,
+        broad_phase="nxn",
+        speculative_config=speculative_config,
+    )
+    contacts = pipeline.contacts()
+    solver = newton.solvers.SolverXPBD(model)
+
+    state_0 = model.state()
+    state_1 = model.state()
+    control = model.control()
+    frame_dt = 1.0 / 60.0
+
+    for _ in range(num_frames):
+        pipeline.collide(state_0, contacts, dt=frame_dt)
+        state_0.clear_forces()
+        solver.step(state_0, state_1, control, contacts, frame_dt)
+        state_0, state_1 = state_1, state_0
+
+    body_q = state_0.body_q.numpy()
+    sphere_x = float(body_q[0][0])
+    return sphere_x
+
+
+def test_speculative_tunneling_without(test, device):
+    """Without speculative contacts the sphere tunnels through the thin box."""
+    final_x = _run_sphere_vs_thin_box_sim(device, speculative_config=None)
+    test.assertGreater(
+        final_x,
+        0.5,
+        f"Sphere should tunnel through the thin box (final x={final_x:.3f})",
+    )
+
+
+def test_speculative_tunneling_with(test, device):
+    """With speculative contacts the sphere is stopped by the thin box."""
+    config = newton.SpeculativeContactConfig(
+        max_speculative_extension=2.0,
+        collision_update_dt=1.0 / 60.0,
+    )
+    final_x = _run_sphere_vs_thin_box_sim(device, speculative_config=config)
+    test.assertLess(
+        final_x,
+        -0.2,
+        f"Sphere should be stopped by the thin box (final x={final_x:.3f})",
+    )
+
+
+class TestSpeculativeContacts(unittest.TestCase):
+    pass
+
+
+devices = get_cuda_test_devices()
+if not devices:
+    devices = [wp.get_device("cpu")]
+
+add_function_test(TestSpeculativeContacts, "test_speculative_disabled_no_contacts", test_speculative_disabled_no_contacts, devices=devices)
+add_function_test(TestSpeculativeContacts, "test_speculative_enabled_catches_fast_object", test_speculative_enabled_catches_fast_object, devices=devices)
+add_function_test(TestSpeculativeContacts, "test_speculative_diverging_no_contacts", test_speculative_diverging_no_contacts, devices=devices)
+add_function_test(TestSpeculativeContacts, "test_speculative_max_extension_clamp", test_speculative_max_extension_clamp, devices=devices)
+add_function_test(TestSpeculativeContacts, "test_speculative_dt_override", test_speculative_dt_override, devices=devices)
+add_function_test(TestSpeculativeContacts, "test_speculative_angular_velocity", test_speculative_angular_velocity, devices=devices)
+add_function_test(TestSpeculativeContacts, "test_speculative_tunneling_without", test_speculative_tunneling_without, devices=devices)
+add_function_test(TestSpeculativeContacts, "test_speculative_tunneling_with", test_speculative_tunneling_with, devices=devices)
+
+
+if __name__ == "__main__":
+    wp.clear_kernel_cache()
+    unittest.main(verbosity=2)

From 888118390cf862a6e7320e14823700621edea622 Mon Sep 17 00:00:00 2001
From: twidmer <twidmer@nvidia.com>
Date: Thu, 2 Apr 2026 11:55:29 +0200
Subject: [PATCH 03/10] Ran ruff

---
 newton/tests/test_speculative_contacts.py | 45 ++++++++++++++++++-----
 1 file changed, 36 insertions(+), 9 deletions(-)

diff --git a/newton/tests/test_speculative_contacts.py b/newton/tests/test_speculative_contacts.py
index 315700b62a..97ca9a4370 100644
--- a/newton/tests/test_speculative_contacts.py
+++ b/newton/tests/test_speculative_contacts.py
@@ -5,7 +5,6 @@
 
 import unittest
 
-import numpy as np
 import warp as wp
 
 import newton
@@ -250,14 +249,42 @@ class TestSpeculativeContacts(unittest.TestCase):
 if not devices:
     devices = [wp.get_device("cpu")]
 
-add_function_test(TestSpeculativeContacts, "test_speculative_disabled_no_contacts", test_speculative_disabled_no_contacts, devices=devices)
-add_function_test(TestSpeculativeContacts, "test_speculative_enabled_catches_fast_object", test_speculative_enabled_catches_fast_object, devices=devices)
-add_function_test(TestSpeculativeContacts, "test_speculative_diverging_no_contacts", test_speculative_diverging_no_contacts, devices=devices)
-add_function_test(TestSpeculativeContacts, "test_speculative_max_extension_clamp", test_speculative_max_extension_clamp, devices=devices)
-add_function_test(TestSpeculativeContacts, "test_speculative_dt_override", test_speculative_dt_override, devices=devices)
-add_function_test(TestSpeculativeContacts, "test_speculative_angular_velocity", test_speculative_angular_velocity, devices=devices)
-add_function_test(TestSpeculativeContacts, "test_speculative_tunneling_without", test_speculative_tunneling_without, devices=devices)
-add_function_test(TestSpeculativeContacts, "test_speculative_tunneling_with", test_speculative_tunneling_with, devices=devices)
+add_function_test(
+    TestSpeculativeContacts,
+    "test_speculative_disabled_no_contacts",
+    test_speculative_disabled_no_contacts,
+    devices=devices,
+)
+add_function_test(
+    TestSpeculativeContacts,
+    "test_speculative_enabled_catches_fast_object",
+    test_speculative_enabled_catches_fast_object,
+    devices=devices,
+)
+add_function_test(
+    TestSpeculativeContacts,
+    "test_speculative_diverging_no_contacts",
+    test_speculative_diverging_no_contacts,
+    devices=devices,
+)
+add_function_test(
+    TestSpeculativeContacts,
+    "test_speculative_max_extension_clamp",
+    test_speculative_max_extension_clamp,
+    devices=devices,
+)
+add_function_test(
+    TestSpeculativeContacts, "test_speculative_dt_override", test_speculative_dt_override, devices=devices
+)
+add_function_test(
+    TestSpeculativeContacts, "test_speculative_angular_velocity", test_speculative_angular_velocity, devices=devices
+)
+add_function_test(
+    TestSpeculativeContacts, "test_speculative_tunneling_without", test_speculative_tunneling_without, devices=devices
+)
+add_function_test(
+    TestSpeculativeContacts, "test_speculative_tunneling_with", test_speculative_tunneling_with, devices=devices
+)
 
 
 if __name__ == "__main__":

From de66f9077c259e75666809ca81912bcc28b225f6 Mon Sep 17 00:00:00 2001
From: twidmer <twidmer@nvidia.com>
Date: Wed, 8 Apr 2026 15:03:38 +0200
Subject: [PATCH 04/10] Implement MR comments

---
 docs/api/newton.rst                  |  1 +
 newton/_src/geometry/narrow_phase.py | 18 ++++++++++++++-
 newton/_src/sim/collide.py           | 34 +++++++++++++++++++++++-----
 3 files changed, 46 insertions(+), 7 deletions(-)

diff --git a/docs/api/newton.rst b/docs/api/newton.rst
index 129e536b9e..8c02409c3a 100644
--- a/docs/api/newton.rst
+++ b/docs/api/newton.rst
@@ -55,6 +55,7 @@ newton
    ParticleFlags
    SDF
    ShapeFlags
+   SpeculativeContactConfig
    State
    TetMesh
 
diff --git a/newton/_src/geometry/narrow_phase.py b/newton/_src/geometry/narrow_phase.py
index f111b5cd6e..5cfaf079d0 100644
--- a/newton/_src/geometry/narrow_phase.py
+++ b/newton/_src/geometry/narrow_phase.py
@@ -527,7 +527,23 @@ def narrow_phase_primitive_kernel(
                 contact_data.margin_b = margin_offset_b
                 contact_data.shape_a = shape_a
                 contact_data.shape_b = shape_b
-                contact_data.gap_sum = gap_sum
+
+                # Recompute gap_sum with directed approach speed now that the
+                # contact normal is available (the pre-routing gap_sum used
+                # undirected speed as a conservative candidate-generation bound).
+                directed_gap_sum = gap_a + gap_b
+                if wp.static(speculative):
+                    vel_rel = shape_lin_vel[shape_b] - shape_lin_vel[shape_a]
+                    v_approach = (
+                        -wp.dot(vel_rel, contact_normal)
+                        + shape_ang_speed_bound[shape_a]
+                        + shape_ang_speed_bound[shape_b]
+                    )
+                    directed_gap_sum = directed_gap_sum + wp.min(
+                        wp.max(v_approach * speculative_dt, 0.0),
+                        max_speculative_extension,
+                    )
+                contact_data.gap_sum = directed_gap_sum
 
                 # Check margin for all possible contacts
                 contact_0_valid = False
diff --git a/newton/_src/sim/collide.py b/newton/_src/sim/collide.py
index cf3c866254..73b3841bb7 100644
--- a/newton/_src/sim/collide.py
+++ b/newton/_src/sim/collide.py
@@ -28,6 +28,12 @@
 from ..sim.state import State
 
 
+def _validate_speculative_scalar(value: float, name: str) -> None:
+    """Raise ``ValueError`` for negative or non-finite speculative parameters."""
+    if not np.isfinite(value) or value < 0.0:
+        raise ValueError(f"{name} must be a non-negative finite number, got {value!r}")
+
+
 @dataclasses.dataclass
 class SpeculativeContactConfig:
     """Configuration for speculative contact detection.
@@ -46,6 +52,10 @@ class SpeculativeContactConfig:
     max_speculative_extension: float = 0.1
     collision_update_dt: float = 1.0 / 60.0
 
+    def __post_init__(self):
+        _validate_speculative_scalar(self.collision_update_dt, "collision_update_dt")
+        _validate_speculative_scalar(self.max_speculative_extension, "max_speculative_extension")
+
 
 @wp.struct
 class ContactWriterData:
@@ -120,12 +130,14 @@ def write_contact(
     gap_b = writer_data.shape_gap[contact_data.shape_b]
     contact_gap = gap_a + gap_b
 
-    # Directed speculative gap extension: only extend for approaching pairs
+    # Directed speculative gap extension: only extend for approaching pairs.
+    # contact_normal_a_to_b points from A toward B, so approaching motion
+    # gives dot(vel_b - vel_a, n) < 0.  Negate to get a positive approach speed.
     if writer_data.speculative_dt > 0.0:
         vel_a = writer_data.shape_lin_vel[contact_data.shape_a]
         vel_b = writer_data.shape_lin_vel[contact_data.shape_b]
         v_approach = (
-            wp.dot(vel_b - vel_a, contact_normal_a_to_b)
+            -wp.dot(vel_b - vel_a, contact_normal_a_to_b)
             + writer_data.shape_ang_speed_bound[contact_data.shape_a]
             + writer_data.shape_ang_speed_bound[contact_data.shape_b]
         )
@@ -200,6 +212,7 @@ def compute_shape_aabbs(
         shape_lin_vel: wp.array[wp.vec3],
         shape_ang_speed_bound: wp.array[float],
         speculative_dt: float,
+        max_speculative_extension: float,
         # outputs
         aabb_lower: wp.array[wp.vec3],
         aabb_upper: wp.array[wp.vec3],
@@ -273,9 +286,12 @@ def compute_shape_aabbs(
                 v = shape_lin_vel[shape_id]
                 vel_dt = v * speculative_dt
                 ang_ext = shape_ang_speed_bound[shape_id] * speculative_dt
+                ext_neg = wp.max(-vel_dt, wp.vec3(0.0, 0.0, 0.0))
+                ext_pos = wp.max(vel_dt, wp.vec3(0.0, 0.0, 0.0))
                 ang_vec = wp.vec3(ang_ext, ang_ext, ang_ext)
-                lo = lo - wp.max(-vel_dt, wp.vec3(0.0, 0.0, 0.0)) - ang_vec
-                hi = hi + wp.max(vel_dt, wp.vec3(0.0, 0.0, 0.0)) + ang_vec
+                cap = wp.vec3(max_speculative_extension, max_speculative_extension, max_speculative_extension)
+                lo = lo - wp.min(ext_neg + ang_vec, cap)
+                hi = hi + wp.min(ext_pos + ang_vec, cap)
 
             aabb_lower[shape_id] = lo
             aabb_upper[shape_id] = hi
@@ -302,9 +318,12 @@ def compute_shape_aabbs(
                 v = shape_lin_vel[shape_id]
                 vel_dt = v * speculative_dt
                 ang_ext = shape_ang_speed_bound[shape_id] * speculative_dt
+                ext_neg = wp.max(-vel_dt, wp.vec3(0.0, 0.0, 0.0))
+                ext_pos = wp.max(vel_dt, wp.vec3(0.0, 0.0, 0.0))
                 ang_vec = wp.vec3(ang_ext, ang_ext, ang_ext)
-                lo = lo - wp.max(-vel_dt, wp.vec3(0.0, 0.0, 0.0)) - ang_vec
-                hi = hi + wp.max(vel_dt, wp.vec3(0.0, 0.0, 0.0)) + ang_vec
+                cap = wp.vec3(max_speculative_extension, max_speculative_extension, max_speculative_extension)
+                lo = lo - wp.min(ext_neg + ang_vec, cap)
+                hi = hi + wp.min(ext_pos + ang_vec, cap)
 
             aabb_lower[shape_id] = lo
             aabb_upper[shape_id] = hi
@@ -901,6 +920,8 @@ def collide(
         if self._speculative_enabled:
             cfg = self.speculative_config
             speculative_dt = dt if dt is not None else cfg.collision_update_dt
+            if dt is not None:
+                _validate_speculative_scalar(dt, "dt")
             max_speculative_extension = cfg.max_speculative_extension
         else:
             speculative_dt = 0.0
@@ -952,6 +973,7 @@ def collide(
                 self._shape_lin_vel,
                 self._shape_ang_speed_bound,
                 speculative_dt,
+                max_speculative_extension,
             ],
             outputs=[
                 self.narrow_phase.shape_aabb_lower,

From 2e8bf6b47669e5784ff0167317e2ceaf043e61d2 Mon Sep 17 00:00:00 2001
From: twidmer <twidmer@nvidia.com>
Date: Wed, 8 Apr 2026 15:40:13 +0200
Subject: [PATCH 05/10] Update the docs

---
 CHANGELOG.md                 |  1 +
 docs/concepts/collisions.rst | 41 ++++++++++++++++++++++++++++++++++++
 newton/_src/sim/collide.py   | 11 +++++-----
 3 files changed, 47 insertions(+), 6 deletions(-)

diff --git a/CHANGELOG.md b/CHANGELOG.md
index a5e457acc6..b5d39e6b5e 100644
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@@ -36,6 +36,7 @@
 - Add `total_force_friction` and `force_matrix_friction` to `SensorContact` for tangential (friction) force decomposition
 - Add `compute_normals` and `compute_uvs` optional arguments to `Mesh.create_heightfield()` and `Mesh.create_terrain()`
 - Add RJ45 plug-socket insertion example with SDF contacts, latch joint, and interactive gizmo
+- Add `SpeculativeContactConfig` and speculative contact support in `CollisionPipeline` to detect contacts for fast-moving objects before they tunnel through thin geometry
 
 ### Changed
 
diff --git a/docs/concepts/collisions.rst b/docs/concepts/collisions.rst
index f7e856b915..83624e0274 100644
--- a/docs/concepts/collisions.rst
+++ b/docs/concepts/collisions.rst
@@ -1089,6 +1089,47 @@ Example (mesh SDF workflow):
 
 The builder's ``rigid_gap`` (default 0.1) applies to shapes without explicit ``gap``. Alternatively, use ``builder.default_shape_cfg.gap``.
 
+.. _Speculative Contacts:
+
+Speculative Contacts
+--------------------
+
+Fast-moving objects can travel farther than the contact gap in a single time
+step, causing them to tunnel through thin geometry.  **Speculative contacts**
+widen the detection window based on per-shape velocity so that contacts which
+*will* occur within the next collision update interval are caught early.
+
+Enable speculative contacts by passing a :class:`SpeculativeContactConfig` to
+:class:`CollisionPipeline`:
+
+.. code-block:: python
+
+    config = newton.SpeculativeContactConfig(
+        max_speculative_extension=0.5,   # cap per-axis AABB growth [m]
+        collision_update_dt=1.0 / 60.0,  # expected interval between collide() calls
+    )
+    pipeline = newton.CollisionPipeline(model, speculative_config=config)
+
+At each ``collide()`` call the pipeline:
+
+1. Computes per-shape linear velocity and an angular-speed bound from
+   ``State.body_qd``.
+2. Expands each shape AABB by the clamped velocity contribution (capped by
+   ``max_speculative_extension``) so the broad phase returns candidate pairs
+   that are about to collide.
+3. In the narrow phase, widens the contact gap using the **directed** approach
+   speed along the contact normal, so only genuinely approaching pairs are
+   accepted.
+
+The ``collision_update_dt`` can be overridden per call:
+
+.. code-block:: python
+
+    pipeline.collide(state, contacts, dt=sim_dt)
+
+When ``speculative_config`` is ``None`` (the default), all speculative code
+paths are eliminated at compile time with zero runtime overhead.
+
 .. _Common Patterns:
 
 Common Patterns
diff --git a/newton/_src/sim/collide.py b/newton/_src/sim/collide.py
index 73b3841bb7..827ee6cf5f 100644
--- a/newton/_src/sim/collide.py
+++ b/newton/_src/sim/collide.py
@@ -41,16 +41,15 @@ class SpeculativeContactConfig:
     When passed to :class:`CollisionPipeline`, AABBs and gap thresholds are
     expanded based on per-shape velocity so that contacts which will occur
     within the next collision update interval are detected early.
-
-    Attributes:
-        max_speculative_extension: Maximum speculative gap extension [m].
-            Clamps ``vel * dt`` to prevent excessively large AABBs.
-        collision_update_dt: Default time interval between collision updates [s].
-            Can be overridden per-call via ``CollisionPipeline.collide(dt=...)``.
     """
 
     max_speculative_extension: float = 0.1
+    """Maximum speculative gap extension [m].  Clamps ``vel * dt`` to
+    prevent excessively large AABBs."""
+
     collision_update_dt: float = 1.0 / 60.0
+    """Default time interval between collision updates [s].  Can be
+    overridden per-call via ``CollisionPipeline.collide(dt=...)``."""
 
     def __post_init__(self):
         _validate_speculative_scalar(self.collision_update_dt, "collision_update_dt")

From 09071409bd2a7418948fcb684d4a4460742f1836 Mon Sep 17 00:00:00 2001
From: twidmer <twidmer@nvidia.com>
Date: Thu, 9 Apr 2026 16:06:05 +0200
Subject: [PATCH 06/10] Improve the docs

---
 docs/concepts/collisions.rst | 7 ++++---
 1 file changed, 4 insertions(+), 3 deletions(-)

diff --git a/docs/concepts/collisions.rst b/docs/concepts/collisions.rst
index 83624e0274..d999b07628 100644
--- a/docs/concepts/collisions.rst
+++ b/docs/concepts/collisions.rst
@@ -1117,9 +1117,10 @@ At each ``collide()`` call the pipeline:
 2. Expands each shape AABB by the clamped velocity contribution (capped by
    ``max_speculative_extension``) so the broad phase returns candidate pairs
    that are about to collide.
-3. In the narrow phase, widens the contact gap using the **directed** approach
-   speed along the contact normal, so only genuinely approaching pairs are
-   accepted.
+3. In the narrow phase, recomputes the contact gap using the normal-projected
+   approach speed of the relative linear velocity **plus** per-shape
+   angular-speed bounds (clamped by ``max_speculative_extension``), so only
+   genuinely approaching pairs are accepted.
 
 The ``collision_update_dt`` can be overridden per call:
 

From 5113899d468e4626449a92b34f1924983714933c Mon Sep 17 00:00:00 2001
From: twidmer <twidmer@nvidia.com>
Date: Fri, 10 Apr 2026 09:32:03 +0200
Subject: [PATCH 07/10] Extend speculative contacts to support meshes

---
 .../_src/geometry/contact_reduction_global.py | 209 ++++++------
 newton/_src/geometry/narrow_phase.py          | 311 ++++++++++++------
 newton/_src/geometry/sdf_contact.py           |  67 +++-
 newton/tests/test_speculative_contacts.py     | 212 ++++++++++++
 4 files changed, 598 insertions(+), 201 deletions(-)

diff --git a/newton/_src/geometry/contact_reduction_global.py b/newton/_src/geometry/contact_reduction_global.py
index 349f47a056..d0a793408a 100644
--- a/newton/_src/geometry/contact_reduction_global.py
+++ b/newton/_src/geometry/contact_reduction_global.py
@@ -1214,105 +1214,126 @@ def export_reduced_contacts_kernel(
     return export_reduced_contacts_kernel
 
 
-@wp.kernel(enable_backward=False, module="unique")
-def mesh_triangle_contacts_to_reducer_kernel(
-    shape_types: wp.array[int],
-    shape_data: wp.array[wp.vec4],
-    shape_transform: wp.array[wp.transform],
-    shape_source: wp.array[wp.uint64],
-    shape_gap: wp.array[float],
-    shape_heightfield_index: wp.array[wp.int32],
-    heightfield_data: wp.array[HeightfieldData],
-    heightfield_elevations: wp.array[wp.float32],
-    triangle_pairs: wp.array[wp.vec3i],
-    triangle_pairs_count: wp.array[int],
-    reducer_data: GlobalContactReducerData,
-    total_num_threads: int,
-):
-    """Process mesh/heightfield-triangle contacts and store them in GlobalContactReducer.
+def create_mesh_triangle_contacts_to_reducer_kernel(speculative: bool = False):
+    """Factory for the mesh/heightfield-triangle → reducer kernel.
 
-    This kernel processes triangle pairs (mesh-or-hfield shape, convex-shape, triangle_index)
-    and computes contacts using GJK/MPR, storing results in the GlobalContactReducer for
-    subsequent reduction and export.
-
-    Uses grid stride loop over triangle pairs.
+    When *speculative* is True the kernel reads per-shape velocity arrays and
+    extends ``gap_sum`` by a scalar speculative margin.  When False the extra
+    code is eliminated at compile time via ``wp.static``.
     """
-    tid = wp.tid()
 
-    num_triangle_pairs = triangle_pairs_count[0]
+    @wp.kernel(enable_backward=False, module="unique")
+    def mesh_triangle_contacts_to_reducer_kernel(
+        shape_types: wp.array[int],
+        shape_data: wp.array[wp.vec4],
+        shape_transform: wp.array[wp.transform],
+        shape_source: wp.array[wp.uint64],
+        shape_gap: wp.array[float],
+        shape_heightfield_index: wp.array[wp.int32],
+        heightfield_data: wp.array[HeightfieldData],
+        heightfield_elevations: wp.array[wp.float32],
+        triangle_pairs: wp.array[wp.vec3i],
+        triangle_pairs_count: wp.array[int],
+        reducer_data: GlobalContactReducerData,
+        total_num_threads: int,
+        shape_lin_vel: wp.array[wp.vec3],
+        shape_ang_speed_bound: wp.array[float],
+        speculative_dt: float,
+        max_speculative_extension: float,
+    ):
+        """Process mesh/heightfield-triangle contacts and store them in GlobalContactReducer.
+
+        This kernel processes triangle pairs (mesh-or-hfield shape, convex-shape, triangle_index)
+        and computes contacts using GJK/MPR, storing results in the GlobalContactReducer for
+        subsequent reduction and export.
 
-    for i in range(tid, num_triangle_pairs, total_num_threads):
-        if i >= triangle_pairs.shape[0]:
-            break
+        Uses grid stride loop over triangle pairs.
+        """
+        tid = wp.tid()
 
-        triple = triangle_pairs[i]
-        shape_a = triple[0]  # Mesh or heightfield shape
-        shape_b = triple[1]  # Convex shape
-        tri_idx = triple[2]
+        num_triangle_pairs = triangle_pairs_count[0]
 
-        type_a = shape_types[shape_a]
+        for i in range(tid, num_triangle_pairs, total_num_threads):
+            if i >= triangle_pairs.shape[0]:
+                break
 
-        if type_a == GeoType.HFIELD:
-            # Heightfield triangle
-            hfd = heightfield_data[shape_heightfield_index[shape_a]]
-            X_ws_a = shape_transform[shape_a]
-            shape_data_a, v0_world = get_triangle_shape_from_heightfield(hfd, heightfield_elevations, X_ws_a, tri_idx)
-        else:
-            # Mesh triangle (mesh_id already validated by midphase)
-            mesh_id_a = shape_source[shape_a]
-            scale_data_a = shape_data[shape_a]
-            mesh_scale_a = wp.vec3(scale_data_a[0], scale_data_a[1], scale_data_a[2])
-            X_ws_a = shape_transform[shape_a]
-            shape_data_a, v0_world = get_triangle_shape_from_mesh(mesh_id_a, mesh_scale_a, X_ws_a, tri_idx)
-
-        # Extract shape B data
-        pos_b, quat_b, shape_data_b, _scale_b, margin_offset_b = extract_shape_data(
-            shape_b,
-            shape_transform,
-            shape_types,
-            shape_data,
-            shape_source,
-        )
+            triple = triangle_pairs[i]
+            shape_a = triple[0]  # Mesh or heightfield shape
+            shape_b = triple[1]  # Convex shape
+            tri_idx = triple[2]
 
-        # Triangle position is vertex A in world space.
-        # For heightfield prisms, edges are in heightfield-local space
-        # so we pass the heightfield rotation to let MPR/GJK work in
-        # that frame (where -Z is always the down axis).
-        pos_a = v0_world
-        if type_a == GeoType.HFIELD:
-            quat_a = wp.transform_get_rotation(shape_transform[shape_a])
-        else:
-            quat_a = wp.quat_identity()
-
-        # Back-face culling: skip when the convex center is behind the
-        # triangle face.  TRIANGLE_PRISM (heightfields) handles this
-        # via its extruded support function.
-        if shape_data_a.shape_type == int(GeoTypeEx.TRIANGLE):
-            face_normal = wp.cross(shape_data_a.scale, shape_data_a.auxiliary)
-            center_dist = wp.dot(face_normal, pos_b - pos_a)
-            if center_dist < 0.0:
-                continue
-
-        # Extract margin offset for shape A (signed distance padding)
-        margin_offset_a = shape_data[shape_a][3]
-
-        # Use additive per-shape contact gap for detection threshold
-        gap_a = shape_gap[shape_a]
-        gap_b = shape_gap[shape_b]
-        gap_sum = gap_a + gap_b
-
-        # Compute and write contacts using GJK/MPR
-        wp.static(create_compute_gjk_mpr_contacts(write_contact_to_reducer))(
-            shape_data_a,
-            shape_data_b,
-            quat_a,
-            quat_b,
-            pos_a,
-            pos_b,
-            gap_sum,
-            shape_a,
-            shape_b,
-            margin_offset_a,
-            margin_offset_b,
-            reducer_data,
-        )
+            type_a = shape_types[shape_a]
+
+            if type_a == GeoType.HFIELD:
+                # Heightfield triangle
+                hfd = heightfield_data[shape_heightfield_index[shape_a]]
+                X_ws_a = shape_transform[shape_a]
+                shape_data_a, v0_world = get_triangle_shape_from_heightfield(
+                    hfd, heightfield_elevations, X_ws_a, tri_idx
+                )
+            else:
+                # Mesh triangle (mesh_id already validated by midphase)
+                mesh_id_a = shape_source[shape_a]
+                scale_data_a = shape_data[shape_a]
+                mesh_scale_a = wp.vec3(scale_data_a[0], scale_data_a[1], scale_data_a[2])
+                X_ws_a = shape_transform[shape_a]
+                shape_data_a, v0_world = get_triangle_shape_from_mesh(mesh_id_a, mesh_scale_a, X_ws_a, tri_idx)
+
+            # Extract shape B data
+            pos_b, quat_b, shape_data_b, _scale_b, margin_offset_b = extract_shape_data(
+                shape_b,
+                shape_transform,
+                shape_types,
+                shape_data,
+                shape_source,
+            )
+
+            # Triangle position is vertex A in world space.
+            # For heightfield prisms, edges are in heightfield-local space
+            # so we pass the heightfield rotation to let MPR/GJK work in
+            # that frame (where -Z is always the down axis).
+            pos_a = v0_world
+            if type_a == GeoType.HFIELD:
+                quat_a = wp.transform_get_rotation(shape_transform[shape_a])
+            else:
+                quat_a = wp.quat_identity()
+
+            # Back-face culling: skip when the convex center is behind the
+            # triangle face.  TRIANGLE_PRISM (heightfields) handles this
+            # via its extruded support function.
+            if shape_data_a.shape_type == int(GeoTypeEx.TRIANGLE):
+                face_normal = wp.cross(shape_data_a.scale, shape_data_a.auxiliary)
+                center_dist = wp.dot(face_normal, pos_b - pos_a)
+                if center_dist < 0.0:
+                    continue
+
+            # Extract margin offset for shape A (signed distance padding)
+            margin_offset_a = shape_data[shape_a][3]
+
+            # Use additive per-shape contact gap for detection threshold
+            gap_a = shape_gap[shape_a]
+            gap_b = shape_gap[shape_b]
+            gap_sum = gap_a + gap_b
+
+            if wp.static(speculative):
+                vel_rel = shape_lin_vel[shape_b] - shape_lin_vel[shape_a]
+                rel_speed = wp.length(vel_rel) + shape_ang_speed_bound[shape_a] + shape_ang_speed_bound[shape_b]
+                gap_sum = gap_sum + wp.min(rel_speed * speculative_dt, max_speculative_extension)
+
+            # Compute and write contacts using GJK/MPR
+            wp.static(create_compute_gjk_mpr_contacts(write_contact_to_reducer))(
+                shape_data_a,
+                shape_data_b,
+                quat_a,
+                quat_b,
+                pos_a,
+                pos_b,
+                gap_sum,
+                shape_a,
+                shape_b,
+                margin_offset_a,
+                margin_offset_b,
+                reducer_data,
+            )
+
+    return mesh_triangle_contacts_to_reducer_kernel
diff --git a/newton/_src/geometry/narrow_phase.py b/newton/_src/geometry/narrow_phase.py
index 036c51af66..d577f05ac4 100644
--- a/newton/_src/geometry/narrow_phase.py
+++ b/newton/_src/geometry/narrow_phase.py
@@ -36,7 +36,7 @@
 from ..geometry.contact_reduction_global import (
     GlobalContactReducer,
     create_export_reduced_contacts_kernel,
-    mesh_triangle_contacts_to_reducer_kernel,
+    create_mesh_triangle_contacts_to_reducer_kernel,
     reduce_buffered_contacts_kernel,
     write_contact_to_reducer,
 )
@@ -807,115 +807,140 @@ def narrow_phase_kernel_gjk_mpr(
     return narrow_phase_kernel_gjk_mpr
 
 
-@wp.kernel(enable_backward=False)
-def narrow_phase_find_mesh_triangle_overlaps_kernel(
-    shape_types: wp.array[int],
-    shape_transform: wp.array[wp.transform],
-    shape_source: wp.array[wp.uint64],
-    shape_gap: wp.array[float],  # Per-shape contact gaps
-    shape_data: wp.array[wp.vec4],  # Shape data (scale xyz, margin w)
-    shape_collision_radius: wp.array[float],
-    shape_heightfield_index: wp.array[wp.int32],
-    heightfield_data: wp.array[HeightfieldData],
-    shape_pairs_mesh: wp.array[wp.vec2i],
-    shape_pairs_mesh_count: wp.array[int],
-    total_num_threads: int,
-    # outputs
-    triangle_pairs: wp.array[wp.vec3i],  # (shape_a, shape_b, triangle_idx)
-    triangle_pairs_count: wp.array[int],
-):
-    """Find triangles that overlap with a convex shape for mesh and heightfield pairs.
-
-    For mesh pairs, uses a tiled BVH query. For heightfield pairs, projects the
-    convex shape's bounding sphere onto the heightfield grid and emits triangle
-    pairs for each overlapping cell.
+def _create_find_mesh_triangle_overlaps_kernel(speculative: bool):
+    """Factory for the midphase kernel that finds mesh/heightfield triangle overlaps.
 
-    Outputs triples of ``(mesh_or_hfield_shape, other_shape, triangle_idx)``.
+    When *speculative* is True the kernel reads per-shape velocity arrays and
+    expands the BVH query AABB by the speculative margin so that triangles
+    about to be hit are included as candidates.
     """
-    tid, j = wp.tid()
-
-    num_mesh_pairs = shape_pairs_mesh_count[0]
-
-    # Strided loop over mesh pairs
-    for i in range(tid, num_mesh_pairs, total_num_threads):
-        pair = shape_pairs_mesh[i]
-        shape_a = pair[0]
-        shape_b = pair[1]
-
-        type_a = shape_types[shape_a]
-        type_b = shape_types[shape_b]
-
-        # -----------------------------------------------------------------
-        # Heightfield-vs-convex midphase (grid cell lookup)
-        # Pairs are normalized so the heightfield is always shape_a.
-        # -----------------------------------------------------------------
-        if type_a == GeoType.HFIELD:
-            # Only run on j==0; the j dimension is for tiled BVH queries (mesh only).
-            if j != 0:
+
+    @wp.kernel(enable_backward=False)
+    def narrow_phase_find_mesh_triangle_overlaps_kernel(
+        shape_types: wp.array[int],
+        shape_transform: wp.array[wp.transform],
+        shape_source: wp.array[wp.uint64],
+        shape_gap: wp.array[float],  # Per-shape contact gaps
+        shape_data: wp.array[wp.vec4],  # Shape data (scale xyz, margin w)
+        shape_collision_radius: wp.array[float],
+        shape_heightfield_index: wp.array[wp.int32],
+        heightfield_data: wp.array[HeightfieldData],
+        shape_pairs_mesh: wp.array[wp.vec2i],
+        shape_pairs_mesh_count: wp.array[int],
+        total_num_threads: int,
+        shape_lin_vel: wp.array[wp.vec3],
+        shape_ang_speed_bound: wp.array[float],
+        speculative_dt: float,
+        max_speculative_extension: float,
+        # outputs
+        triangle_pairs: wp.array[wp.vec3i],  # (shape_a, shape_b, triangle_idx)
+        triangle_pairs_count: wp.array[int],
+    ):
+        """Find triangles that overlap with a convex shape for mesh and heightfield pairs.
+
+        For mesh pairs, uses a tiled BVH query. For heightfield pairs, projects the
+        convex shape's bounding sphere onto the heightfield grid and emits triangle
+        pairs for each overlapping cell.
+
+        Outputs triples of ``(mesh_or_hfield_shape, other_shape, triangle_idx)``.
+        """
+        tid, j = wp.tid()
+
+        num_mesh_pairs = shape_pairs_mesh_count[0]
+
+        # Strided loop over mesh pairs
+        for i in range(tid, num_mesh_pairs, total_num_threads):
+            pair = shape_pairs_mesh[i]
+            shape_a = pair[0]
+            shape_b = pair[1]
+
+            type_a = shape_types[shape_a]
+            type_b = shape_types[shape_b]
+
+            # -----------------------------------------------------------------
+            # Heightfield-vs-convex midphase (grid cell lookup)
+            # Pairs are normalized so the heightfield is always shape_a.
+            # -----------------------------------------------------------------
+            if type_a == GeoType.HFIELD:
+                # Only run on j==0; the j dimension is for tiled BVH queries (mesh only).
+                if j != 0:
+                    continue
+                hfd = heightfield_data[shape_heightfield_index[shape_a]]
+                heightfield_vs_convex_midphase(
+                    shape_a,
+                    shape_b,
+                    hfd,
+                    shape_transform,
+                    shape_collision_radius,
+                    shape_gap,
+                    triangle_pairs,
+                    triangle_pairs_count,
+                )
                 continue
-            hfd = heightfield_data[shape_heightfield_index[shape_a]]
-            heightfield_vs_convex_midphase(
-                shape_a,
-                shape_b,
-                hfd,
-                shape_transform,
-                shape_collision_radius,
-                shape_gap,
+
+            # -----------------------------------------------------------------
+            # Mesh-vs-convex midphase (BVH query)
+            # -----------------------------------------------------------------
+            mesh_shape = -1
+            non_mesh_shape = -1
+
+            if type_a == GeoType.MESH and type_b != GeoType.MESH:
+                mesh_shape = shape_a
+                non_mesh_shape = shape_b
+            elif type_b == GeoType.MESH and type_a != GeoType.MESH:
+                mesh_shape = shape_b
+                non_mesh_shape = shape_a
+            else:
+                # Mesh-mesh collision not supported in this path
+                continue
+
+            # Get mesh BVH ID and mesh transform
+            mesh_id = shape_source[mesh_shape]
+            if mesh_id == wp.uint64(0):
+                continue
+
+            # Get mesh world transform
+            X_mesh_ws = shape_transform[mesh_shape]
+
+            # Get non-mesh shape world transform
+            X_ws = shape_transform[non_mesh_shape]
+
+            # Use per-shape contact gaps for consistent pairwise thresholding.
+            gap_non_mesh = shape_gap[non_mesh_shape]
+            gap_mesh = shape_gap[mesh_shape]
+            gap_sum = gap_non_mesh + gap_mesh
+
+            if wp.static(speculative):
+                vel_rel = shape_lin_vel[non_mesh_shape] - shape_lin_vel[mesh_shape]
+                rel_speed = (
+                    wp.length(vel_rel) + shape_ang_speed_bound[mesh_shape] + shape_ang_speed_bound[non_mesh_shape]
+                )
+                gap_sum = gap_sum + wp.min(rel_speed * speculative_dt, max_speculative_extension)
+
+            # Call mesh_vs_convex_midphase with the shape_data and pair gap sum.
+            mesh_vs_convex_midphase(
+                j,
+                mesh_shape,
+                non_mesh_shape,
+                X_mesh_ws,
+                X_ws,
+                mesh_id,
+                shape_types,
+                shape_data,
+                shape_source,
+                gap_sum,
                 triangle_pairs,
                 triangle_pairs_count,
             )
-            continue
-
-        # -----------------------------------------------------------------
-        # Mesh-vs-convex midphase (BVH query)
-        # -----------------------------------------------------------------
-        mesh_shape = -1
-        non_mesh_shape = -1
-
-        if type_a == GeoType.MESH and type_b != GeoType.MESH:
-            mesh_shape = shape_a
-            non_mesh_shape = shape_b
-        elif type_b == GeoType.MESH and type_a != GeoType.MESH:
-            mesh_shape = shape_b
-            non_mesh_shape = shape_a
-        else:
-            # Mesh-mesh collision not supported in this path
-            continue
-
-        # Get mesh BVH ID and mesh transform
-        mesh_id = shape_source[mesh_shape]
-        if mesh_id == wp.uint64(0):
-            continue
-
-        # Get mesh world transform
-        X_mesh_ws = shape_transform[mesh_shape]
-
-        # Get non-mesh shape world transform
-        X_ws = shape_transform[non_mesh_shape]
-
-        # Use per-shape contact gaps for consistent pairwise thresholding.
-        gap_non_mesh = shape_gap[non_mesh_shape]
-        gap_mesh = shape_gap[mesh_shape]
-        gap_sum = gap_non_mesh + gap_mesh
-
-        # Call mesh_vs_convex_midphase with the shape_data and pair gap sum.
-        mesh_vs_convex_midphase(
-            j,
-            mesh_shape,
-            non_mesh_shape,
-            X_mesh_ws,
-            X_ws,
-            mesh_id,
-            shape_types,
-            shape_data,
-            shape_source,
-            gap_sum,
-            triangle_pairs,
-            triangle_pairs_count,
-        )
+
+    return narrow_phase_find_mesh_triangle_overlaps_kernel
+
+
+_find_mesh_triangle_overlaps = _create_find_mesh_triangle_overlaps_kernel(speculative=False)
+_find_mesh_triangle_overlaps_speculative = _create_find_mesh_triangle_overlaps_kernel(speculative=True)
 
 
-def create_narrow_phase_process_mesh_triangle_contacts_kernel(writer_func: Any):
+def create_narrow_phase_process_mesh_triangle_contacts_kernel(writer_func: Any, speculative: bool = False):
     @wp.kernel(enable_backward=False, module="unique")
     def narrow_phase_process_mesh_triangle_contacts_kernel(
         shape_types: wp.array[int],
@@ -930,6 +955,10 @@ def narrow_phase_process_mesh_triangle_contacts_kernel(
         triangle_pairs_count: wp.array[int],
         writer_data: Any,
         total_num_threads: int,
+        shape_lin_vel: wp.array[wp.vec3],
+        shape_ang_speed_bound: wp.array[float],
+        speculative_dt: float,
+        max_speculative_extension: float,
     ):
         """
         Process triangle pairs to generate contacts using GJK/MPR.
@@ -1001,6 +1030,11 @@ def narrow_phase_process_mesh_triangle_contacts_kernel(
             gap_b = shape_gap[shape_b]
             gap_sum = gap_a + gap_b
 
+            if wp.static(speculative):
+                vel_rel = shape_lin_vel[shape_b] - shape_lin_vel[shape_a]
+                rel_speed = wp.length(vel_rel) + shape_ang_speed_bound[shape_a] + shape_ang_speed_bound[shape_b]
+                gap_sum = gap_sum + wp.min(rel_speed * speculative_dt, max_speculative_extension)
+
             # Compute and write contacts using GJK/MPR with standard post-processing
             wp.static(create_compute_gjk_mpr_contacts(writer_func))(
                 shape_data_a,
@@ -1096,6 +1130,7 @@ def compute_mesh_plane_block_offsets_scan(
 def create_narrow_phase_process_mesh_plane_contacts_kernel(
     writer_func: Any,
     reduce_contacts: bool = False,
+    speculative: bool = False,
 ):
     """
     Create a mesh-plane collision kernel.
@@ -1103,6 +1138,8 @@ def create_narrow_phase_process_mesh_plane_contacts_kernel(
     Args:
         writer_func: Contact writer function (e.g., write_contact_simple)
         reduce_contacts: If True, return multi-block load-balanced variant for global reduction.
+        speculative: When True, extends ``gap_sum`` by a scalar speculative
+            margin derived from per-shape velocity arrays.
 
     Returns:
         A warp kernel that processes mesh-plane collisions
@@ -1121,6 +1158,10 @@ def narrow_phase_process_mesh_plane_contacts_kernel(
         shape_pairs_mesh_plane_count: wp.array[int],
         writer_data: Any,
         total_num_blocks: int,
+        shape_lin_vel: wp.array[wp.vec3],
+        shape_ang_speed_bound: wp.array[float],
+        speculative_dt: float,
+        max_speculative_extension: float,
     ):
         """
         Process mesh-plane collisions without contact reduction.
@@ -1169,6 +1210,13 @@ def narrow_phase_process_mesh_plane_contacts_kernel(
             gap_plane = shape_gap[plane_shape]
             gap_sum = gap_mesh + gap_plane
 
+            if wp.static(speculative):
+                vel_rel = shape_lin_vel[plane_shape] - shape_lin_vel[mesh_shape]
+                rel_speed = (
+                    wp.length(vel_rel) + shape_ang_speed_bound[mesh_shape] + shape_ang_speed_bound[plane_shape]
+                )
+                gap_sum = gap_sum + wp.min(rel_speed * speculative_dt, max_speculative_extension)
+
             # Strided loop over vertices across all threads in the launch
             total_num_threads = total_num_blocks * wp.block_dim()
             for vertex_idx in range(tid, num_vertices, total_num_threads):
@@ -1227,6 +1275,10 @@ def narrow_phase_process_mesh_plane_contacts_reduce_kernel(
         block_offsets: wp.array[wp.int32],
         writer_data: Any,
         total_num_blocks: int,
+        shape_lin_vel: wp.array[wp.vec3],
+        shape_ang_speed_bound: wp.array[float],
+        speculative_dt: float,
+        max_speculative_extension: float,
     ):
         """Process mesh-plane collisions with dynamic load balancing.
 
@@ -1300,6 +1352,13 @@ def narrow_phase_process_mesh_plane_contacts_reduce_kernel(
             gap_plane = shape_gap[plane_shape]
             gap_sum = gap_mesh + gap_plane
 
+            if wp.static(speculative):
+                vel_rel = shape_lin_vel[plane_shape] - shape_lin_vel[mesh_shape]
+                rel_speed = (
+                    wp.length(vel_rel) + shape_ang_speed_bound[mesh_shape] + shape_ang_speed_bound[plane_shape]
+                )
+                gap_sum = gap_sum + wp.min(rel_speed * speculative_dt, max_speculative_extension)
+
             # Process this block's chunk of vertices — write contacts directly
             # to the global reducer buffer (no per-block shared memory reduction).
             chunk_len = vert_end - vert_start
@@ -1548,9 +1607,15 @@ def __init__(
             )
         # Create triangle contacts kernel when meshes or heightfields are present
         if has_meshes or has_heightfields:
-            self.mesh_triangle_contacts_kernel = create_narrow_phase_process_mesh_triangle_contacts_kernel(writer_func)
+            self.mesh_triangle_contacts_kernel = create_narrow_phase_process_mesh_triangle_contacts_kernel(
+                writer_func, speculative=speculative
+            )
+            self.mesh_triangle_overlaps_kernel = (
+                _find_mesh_triangle_overlaps_speculative if speculative else _find_mesh_triangle_overlaps
+            )
         else:
             self.mesh_triangle_contacts_kernel = None
+            self.mesh_triangle_overlaps_kernel = _find_mesh_triangle_overlaps
 
         # Create mesh-specific kernels only when has_meshes=True
         if has_meshes:
@@ -1561,10 +1626,12 @@ def __init__(
                 self.mesh_plane_contacts_kernel = create_narrow_phase_process_mesh_plane_contacts_kernel(
                     write_contact_to_reducer,
                     reduce_contacts=True,
+                    speculative=speculative,
                 )
             else:
                 self.mesh_plane_contacts_kernel = create_narrow_phase_process_mesh_plane_contacts_kernel(
                     writer_func,
+                    speculative=speculative,
                 )
             # Only create mesh-mesh SDF kernel on CUDA (uses __shared__ memory via func_native)
             if is_gpu_device:
@@ -1573,11 +1640,13 @@ def __init__(
                         write_contact_to_reducer,
                         enable_heightfields=has_heightfields,
                         reduce_contacts=True,
+                        speculative=speculative,
                     )
                 else:
                     self.mesh_mesh_contacts_kernel = create_narrow_phase_process_mesh_mesh_contacts_kernel(
                         writer_func,
                         enable_heightfields=has_heightfields,
+                        speculative=speculative,
                     )
             else:
                 self.mesh_mesh_contacts_kernel = None
@@ -1590,10 +1659,14 @@ def __init__(
             # Global contact reducer uses hardcoded BETA_THRESHOLD (0.1mm) same as shared-memory reduction
             # Slot layout: NUM_SPATIAL_DIRECTIONS spatial + 1 max-depth = VALUES_PER_KEY slots per key
             self.export_reduced_contacts_kernel = create_export_reduced_contacts_kernel(writer_func)
+            self.mesh_triangle_to_reducer_kernel = create_mesh_triangle_contacts_to_reducer_kernel(
+                speculative=speculative
+            )
             # Global contact reducer for all mesh contact types
             self.global_contact_reducer = GlobalContactReducer(max_triangle_pairs, device=device)
         else:
             self.export_reduced_contacts_kernel = None
+            self.mesh_triangle_to_reducer_kernel = None
             self.global_contact_reducer = None
 
         self.hydroelastic_sdf = hydroelastic_sdf
@@ -1860,6 +1933,10 @@ def launch_custom_write(
                         self.shape_pairs_mesh_plane_count,
                         writer_data,
                         self.num_tile_blocks,
+                        _slv,
+                        _sasb,
+                        speculative_dt,
+                        max_speculative_extension,
                     ],
                     device=device,
                     block_dim=self.block_dim,
@@ -1869,7 +1946,7 @@ def launch_custom_write(
             # Launch midphase: finds overlapping triangles for both mesh and heightfield pairs
             second_dim = self.tile_size_mesh_convex if ENABLE_TILE_BVH_QUERY else 1
             wp.launch(
-                kernel=narrow_phase_find_mesh_triangle_overlaps_kernel,
+                kernel=self.mesh_triangle_overlaps_kernel,
                 dim=[self.num_tile_blocks, second_dim],
                 inputs=[
                     shape_types,
@@ -1883,6 +1960,10 @@ def launch_custom_write(
                     self.shape_pairs_mesh,
                     self.shape_pairs_mesh_count,
                     self.num_tile_blocks,
+                    _slv,
+                    _sasb,
+                    speculative_dt,
+                    max_speculative_extension,
                 ],
                 outputs=[
                     self.triangle_pairs,
@@ -1929,6 +2010,10 @@ def launch_custom_write(
                             self.mesh_plane_block_offsets,
                             reducer_data,
                             self.num_mesh_plane_blocks,
+                            _slv,
+                            _sasb,
+                            speculative_dt,
+                            max_speculative_extension,
                         ],
                         device=device,
                         block_dim=self.tile_size_mesh_plane,
@@ -1937,7 +2022,7 @@ def launch_custom_write(
 
                 # Mesh/heightfield-triangle contacts → same global reducer
                 wp.launch(
-                    kernel=mesh_triangle_contacts_to_reducer_kernel,
+                    kernel=self.mesh_triangle_to_reducer_kernel,
                     dim=self.total_num_threads,
                     inputs=[
                         shape_types,
@@ -1952,6 +2037,10 @@ def launch_custom_write(
                         self.triangle_pairs_count,
                         reducer_data,
                         self.total_num_threads,
+                        _slv,
+                        _sasb,
+                        speculative_dt,
+                        max_speculative_extension,
                     ],
                     device=device,
                     block_dim=self.block_dim,
@@ -1975,6 +2064,10 @@ def launch_custom_write(
                         self.triangle_pairs_count,
                         writer_data,
                         self.total_num_threads,
+                        _slv,
+                        _sasb,
+                        speculative_dt,
+                        max_speculative_extension,
                     ],
                     device=device,
                     block_dim=self.block_dim,
@@ -2050,6 +2143,10 @@ def launch_custom_write(
                             self.mesh_mesh_block_offsets,
                             reducer_data,
                             self.num_mesh_mesh_blocks,
+                            _slv,
+                            _sasb,
+                            speculative_dt,
+                            max_speculative_extension,
                         ],
                         device=device,
                         block_dim=self.tile_size_mesh_mesh,
@@ -2079,6 +2176,10 @@ def launch_custom_write(
                             shape_edge_range,
                             writer_data,
                             self.num_tile_blocks,
+                            _slv,
+                            _sasb,
+                            speculative_dt,
+                            max_speculative_extension,
                         ],
                         device=device,
                         block_dim=self.tile_size_mesh_mesh,
diff --git a/newton/_src/geometry/sdf_contact.py b/newton/_src/geometry/sdf_contact.py
index b739b939db..b78f9c7c49 100644
--- a/newton/_src/geometry/sdf_contact.py
+++ b/newton/_src/geometry/sdf_contact.py
@@ -22,6 +22,30 @@
 _get_shared_memory_sdf_cache = create_shared_memory_pointer_block_dim_mul_func(1)
 
 
+@wp.func
+def _query_mesh_face_normal(
+    mesh_id: wp.uint64,
+    point_local: wp.vec3,
+    max_dist: float = 1000.0,
+) -> wp.vec3:
+    """Return the outward face normal of the closest triangle on a mesh.
+
+    Falls back to the point-to-center direction when the query misses.
+    The returned vector is in mesh-local space and is normalized.
+    """
+    face_index = int(0)
+    face_u = float(0.0)
+    face_v = float(0.0)
+    sign = float(0.0)
+    res = wp.mesh_query_point_sign_normal(mesh_id, point_local, max_dist, sign, face_index, face_u, face_v)
+    if res:
+        n = wp.mesh_eval_face_normal(mesh_id, face_index)
+        if sign < 0.0:
+            n = -n
+        return n
+    return wp.vec3(0.0, 1.0, 0.0)
+
+
 @wp.func
 def scale_sdf_result_to_world(
     distance: float,
@@ -999,6 +1023,7 @@ def create_narrow_phase_process_mesh_mesh_contacts_kernel(
     writer_func: Any,
     enable_heightfields: bool = True,
     reduce_contacts: bool = False,
+    speculative: bool = False,
 ):
     find_interesting_edges, do_edge_sdf_collision = _create_sdf_contact_funcs(enable_heightfields)
 
@@ -1022,6 +1047,10 @@ def mesh_sdf_collision_kernel(
         shape_edge_range: wp.array[wp.vec2i],
         writer_data: Any,
         total_num_blocks: int,
+        shape_lin_vel: wp.array[wp.vec3],
+        shape_ang_speed_bound: wp.array[float],
+        speculative_dt: float,
+        max_speculative_extension: float,
     ):
         """Process mesh-mesh and mesh-heightfield collisions using SDF-based detection."""
         block_id, t = wp.tid()
@@ -1038,7 +1067,13 @@ def mesh_sdf_collision_kernel(
                 has_hfield = False
                 pair = pair_encoded
 
-            gap_sum = shape_gap[pair[0]] + shape_gap[pair[1]]
+            base_gap_sum = shape_gap[pair[0]] + shape_gap[pair[1]]
+            gap_sum = base_gap_sum
+
+            if wp.static(speculative):
+                vel_rel = shape_lin_vel[pair[1]] - shape_lin_vel[pair[0]]
+                rel_speed = wp.length(vel_rel) + shape_ang_speed_bound[pair[0]] + shape_ang_speed_bound[pair[1]]
+                gap_sum = gap_sum + wp.min(rel_speed * speculative_dt, max_speculative_extension)
 
             for mode in range(2):
                 tri_shape = pair[mode]
@@ -1246,6 +1281,15 @@ def mesh_sdf_collision_kernel(
                                 else:
                                     direction_world = wp.vec3(0.0, 1.0, 0.0)
 
+                            if wp.static(speculative):
+                                base_threshold = base_gap_sum + triangle_mesh_margin + sdf_mesh_margin
+                                if dist > base_threshold and not sdf_is_hfield:
+                                    face_n = _query_mesh_face_normal(mesh_id_sdf, point)
+                                    face_n_world = wp.transform_vector(X_sdf_ws, face_n)
+                                    fn_len = wp.length(face_n_world)
+                                    if fn_len > 0.0:
+                                        direction_world = face_n_world / fn_len
+
                             contact_normal = -direction_world if mode == 0 else direction_world
 
                             contact_data = ContactData()
@@ -1298,6 +1342,10 @@ def mesh_sdf_collision_global_reduce_kernel(
         block_offsets: wp.array[wp.int32],
         reducer_data: GlobalContactReducerData,
         total_num_blocks: int,
+        shape_lin_vel: wp.array[wp.vec3],
+        shape_ang_speed_bound: wp.array[float],
+        speculative_dt: float,
+        max_speculative_extension: float,
     ):
         """Process mesh-mesh collisions with global hashtable contact reduction.
 
@@ -1334,7 +1382,13 @@ def mesh_sdf_collision_global_reduce_kernel(
                 has_hfield = False
                 pair = pair_encoded
 
-            gap_sum = shape_gap[pair[0]] + shape_gap[pair[1]]
+            base_gap_sum = shape_gap[pair[0]] + shape_gap[pair[1]]
+            gap_sum = base_gap_sum
+
+            if wp.static(speculative):
+                vel_rel = shape_lin_vel[pair[1]] - shape_lin_vel[pair[0]]
+                rel_speed = wp.length(vel_rel) + shape_ang_speed_bound[pair[0]] + shape_ang_speed_bound[pair[1]]
+                gap_sum = gap_sum + wp.min(rel_speed * speculative_dt, max_speculative_extension)
 
             for mode in range(2):
                 tri_shape = pair[mode]
@@ -1546,6 +1600,15 @@ def mesh_sdf_collision_global_reduce_kernel(
                                 else:
                                     direction_world = wp.vec3(0.0, 1.0, 0.0)
 
+                            if wp.static(speculative):
+                                base_threshold = base_gap_sum + triangle_mesh_margin + sdf_mesh_margin
+                                if dist > base_threshold and not sdf_is_hfield:
+                                    face_n = _query_mesh_face_normal(mesh_id_sdf, point)
+                                    face_n_world = wp.transform_vector(X_sdf_ws, face_n)
+                                    fn_len = wp.length(face_n_world)
+                                    if fn_len > 0.0:
+                                        direction_world = face_n_world / fn_len
+
                             contact_normal = -direction_world if mode == 0 else direction_world
 
                             export_and_reduce_contact_centered(
diff --git a/newton/tests/test_speculative_contacts.py b/newton/tests/test_speculative_contacts.py
index 97ca9a4370..d8a36b60a0 100644
--- a/newton/tests/test_speculative_contacts.py
+++ b/newton/tests/test_speculative_contacts.py
@@ -5,6 +5,7 @@
 
 import unittest
 
+import numpy as np
 import warp as wp
 
 import newton
@@ -241,6 +242,193 @@ def test_speculative_tunneling_with(test, device):
     )
 
 
+def _make_thin_wall_mesh(hx=0.02, hy=1.0, hz=1.0):
+    """Return a :class:`newton.Mesh` representing a thin box (wall).
+
+    The wall is centred at the origin with half-extents ``(hx, hy, hz)``.
+    Winding is CCW when viewed from the +X side so that the face normals
+    point outward.
+    """
+    verts = np.array(
+        [
+            [-hx, -hy, -hz],
+            [hx, -hy, -hz],
+            [hx, hy, -hz],
+            [-hx, hy, -hz],
+            [-hx, -hy, hz],
+            [hx, -hy, hz],
+            [hx, hy, hz],
+            [-hx, hy, hz],
+        ],
+        dtype=np.float32,
+    )
+    tris = np.array(
+        [
+            # -X face
+            0, 3, 7,  0, 7, 4,
+            # +X face
+            1, 5, 6,  1, 6, 2,
+            # -Y face
+            0, 4, 5,  0, 5, 1,
+            # +Y face
+            3, 2, 6,  3, 6, 7,
+            # -Z face
+            0, 1, 2,  0, 2, 3,
+            # +Z face
+            4, 7, 6,  4, 6, 5,
+        ],
+        dtype=np.int32,
+    )
+    return newton.Mesh(verts, tris, compute_inertia=False)
+
+
+# -- Sphere vs mesh wall (mesh-triangle path) --------------------------------
+
+
+def _run_sphere_vs_mesh_wall_sim(device, speculative_config, num_frames=5):
+    """Simulate a fast sphere aimed at a thin *mesh* wall.
+
+    Same geometry as ``_run_sphere_vs_thin_box_sim`` but the wall is a
+    triangle mesh instead of a primitive box, exercising the mesh-triangle
+    contact path.
+    """
+    builder = newton.ModelBuilder(gravity=0.0)
+    builder.rigid_gap = 0.0
+
+    sphere_body = builder.add_body(xform=wp.transform(wp.vec3(-2.0, 0.0, 0.0)))
+    builder.add_shape_sphere(sphere_body, radius=0.25)
+    builder.body_qd[-1] = (50.0, 0.0, 0.0, 0.0, 0.0, 0.0)
+
+    wall_mesh = _make_thin_wall_mesh()
+    builder.add_shape_mesh(body=-1, mesh=wall_mesh, xform=wp.transform_identity())
+
+    model = builder.finalize(device=device)
+
+    pipeline = newton.CollisionPipeline(
+        model,
+        broad_phase="nxn",
+        speculative_config=speculative_config,
+    )
+    contacts = pipeline.contacts()
+    solver = newton.solvers.SolverXPBD(model)
+
+    state_0 = model.state()
+    state_1 = model.state()
+    control = model.control()
+    frame_dt = 1.0 / 60.0
+
+    for _ in range(num_frames):
+        pipeline.collide(state_0, contacts, dt=frame_dt)
+        state_0.clear_forces()
+        solver.step(state_0, state_1, control, contacts, frame_dt)
+        state_0, state_1 = state_1, state_0
+
+    body_q = state_0.body_q.numpy()
+    return float(body_q[0][0])
+
+
+def test_speculative_tunneling_mesh_wall_without(test, device):
+    """Without speculative contacts the sphere tunnels through the mesh wall."""
+    final_x = _run_sphere_vs_mesh_wall_sim(device, speculative_config=None)
+    test.assertGreater(
+        final_x,
+        0.5,
+        f"Sphere should tunnel through the mesh wall (final x={final_x:.3f})",
+    )
+
+
+def test_speculative_tunneling_mesh_wall_with(test, device):
+    """With speculative contacts the sphere is stopped by the mesh wall."""
+    config = newton.SpeculativeContactConfig(
+        max_speculative_extension=2.0,
+        collision_update_dt=1.0 / 60.0,
+    )
+    final_x = _run_sphere_vs_mesh_wall_sim(device, speculative_config=config)
+    test.assertLess(
+        final_x,
+        -0.2,
+        f"Sphere should be stopped by the mesh wall (final x={final_x:.3f})",
+    )
+
+
+# -- Mesh box vs mesh wall (mesh-mesh SDF path) ------------------------------
+
+
+def _run_mesh_box_vs_mesh_wall_sim(device, speculative_config, num_frames=10):
+    """Simulate a fast mesh box aimed at a thin mesh wall.
+
+    Both the projectile and the wall are triangle meshes with SDFs,
+    exercising the mesh-mesh SDF contact path.  Same geometry as the
+    sphere-vs-primitive-box test (wall half-thickness 0.02 m).
+
+    Uses ``max_resolution=256`` so the SDF has enough voxels across the
+    0.04 m wall, and 8 XPBD iterations because mesh-mesh SDF contacts
+    have zero effective radii (unlike sphere contacts) and need more
+    solver work to fully resolve the large speculative gap.
+    """
+    builder = newton.ModelBuilder(gravity=0.0)
+    builder.rigid_gap = 0.0
+
+    box_mesh = newton.Mesh.create_box(0.25, compute_normals=False, compute_uvs=False)
+    box_mesh.build_sdf(device=device, max_resolution=256)
+
+    box_body = builder.add_body(xform=wp.transform(wp.vec3(-2.0, 0.0, 0.0)))
+    builder.add_shape_mesh(box_body, mesh=box_mesh)
+    builder.body_qd[-1] = (50.0, 0.0, 0.0, 0.0, 0.0, 0.0)
+
+    wall_mesh = _make_thin_wall_mesh()
+    wall_mesh.build_sdf(device=device, max_resolution=256)
+    builder.add_shape_mesh(body=-1, mesh=wall_mesh, xform=wp.transform_identity())
+
+    model = builder.finalize(device=device)
+
+    pipeline = newton.CollisionPipeline(
+        model,
+        broad_phase="nxn",
+        speculative_config=speculative_config,
+    )
+    contacts = pipeline.contacts()
+    solver = newton.solvers.SolverXPBD(model, iterations=8)
+
+    state_0 = model.state()
+    state_1 = model.state()
+    control = model.control()
+    frame_dt = 1.0 / 60.0
+
+    for _ in range(num_frames):
+        pipeline.collide(state_0, contacts, dt=frame_dt)
+        state_0.clear_forces()
+        solver.step(state_0, state_1, control, contacts, frame_dt)
+        state_0, state_1 = state_1, state_0
+
+    body_q = state_0.body_q.numpy()
+    return float(body_q[0][0])
+
+
+def test_speculative_tunneling_mesh_mesh_without(test, device):
+    """Without speculative contacts the mesh box tunnels through the mesh wall."""
+    final_x = _run_mesh_box_vs_mesh_wall_sim(device, speculative_config=None)
+    test.assertGreater(
+        final_x,
+        0.5,
+        f"Mesh box should tunnel through the mesh wall (final x={final_x:.3f})",
+    )
+
+
+def test_speculative_tunneling_mesh_mesh_with(test, device):
+    """With speculative contacts the mesh box is stopped by the mesh wall."""
+    config = newton.SpeculativeContactConfig(
+        max_speculative_extension=2.0,
+        collision_update_dt=1.0 / 60.0,
+    )
+    final_x = _run_mesh_box_vs_mesh_wall_sim(device, speculative_config=config)
+    test.assertLess(
+        final_x,
+        -0.2,
+        f"Mesh box should be stopped by the mesh wall (final x={final_x:.3f})",
+    )
+
+
 class TestSpeculativeContacts(unittest.TestCase):
     pass
 
@@ -285,6 +473,30 @@ class TestSpeculativeContacts(unittest.TestCase):
 add_function_test(
     TestSpeculativeContacts, "test_speculative_tunneling_with", test_speculative_tunneling_with, devices=devices
 )
+add_function_test(
+    TestSpeculativeContacts,
+    "test_speculative_tunneling_mesh_wall_without",
+    test_speculative_tunneling_mesh_wall_without,
+    devices=devices,
+)
+add_function_test(
+    TestSpeculativeContacts,
+    "test_speculative_tunneling_mesh_wall_with",
+    test_speculative_tunneling_mesh_wall_with,
+    devices=devices,
+)
+add_function_test(
+    TestSpeculativeContacts,
+    "test_speculative_tunneling_mesh_mesh_without",
+    test_speculative_tunneling_mesh_mesh_without,
+    devices=devices,
+)
+add_function_test(
+    TestSpeculativeContacts,
+    "test_speculative_tunneling_mesh_mesh_with",
+    test_speculative_tunneling_mesh_mesh_with,
+    devices=devices,
+)
 
 
 if __name__ == "__main__":

From 8751e228b66fc079b8804464f00c8d2fcd98e56a Mon Sep 17 00:00:00 2001
From: twidmer <twidmer@nvidia.com>
Date: Thu, 16 Apr 2026 08:45:03 +0200
Subject: [PATCH 08/10] Merge branch 'main' into dev/tw2/speculative_contacts

# Conflicts:
#	newton/_src/geometry/contact_reduction_global.py
#	newton/_src/geometry/narrow_phase.py
#	newton/_src/sim/collide.py
---
 .github/workflows/aws_gpu_benchmarks.yml      |    4 +-
 .github/workflows/aws_gpu_tests.yml           |    4 +-
 .github/workflows/minimum_deps_tests.yml      |    4 +-
 .github/workflows/mujoco_warp_tests.yml       |    4 +-
 .github/workflows/warp_nightly_tests.yml      |    4 +-
 CHANGELOG.md                                  |   65 +-
 docs/concepts/collisions.rst                  |   42 +-
 docs/guide/release.rst                        |   30 +-
 newton/_src/geometry/collision_convex.py      |    2 +
 newton/_src/geometry/collision_core.py        |    3 +
 newton/_src/geometry/contact_data.py          |   29 +
 .../_src/geometry/contact_reduction_global.py |  293 ++-
 .../contact_reduction_hydroelastic.py         |   22 +-
 newton/_src/geometry/contact_sort.py          |  376 ++++
 newton/_src/geometry/multicontact.py          |    2 +
 newton/_src/geometry/narrow_phase.py          |   84 +-
 newton/_src/geometry/raycast.py               |   54 +-
 newton/_src/geometry/sdf_contact.py           |   15 +-
 newton/_src/geometry/sdf_hydroelastic.py      |   68 +-
 newton/_src/geometry/support_function.py      |   25 +-
 newton/_src/geometry/types.py                 |   18 +
 newton/_src/sim/builder.py                    |    2 +-
 newton/_src/sim/collide.py                    |   66 +-
 newton/_src/sim/contacts.py                   |   30 +-
 .../_src/solvers/kamino/_src/core/builder.py  |    4 +-
 .../_src/solvers/kamino/_src/core/geometry.py |   25 +
 newton/_src/solvers/kamino/_src/core/model.py |   11 +-
 .../_src/solvers/kamino/_src/core/shapes.py   |   77 +-
 .../solvers/kamino/_src/geometry/unified.py   |   64 +-
 .../kamino/examples/rl/example_rl_bipedal.py  |  120 +-
 .../solvers/kamino/examples/rl/simulation.py  |  111 +-
 .../tests/test_geometry_mesh_heightfield.py   |  604 ++++++
 .../kamino/tests/test_geometry_unified.py     |    2 +-
 newton/_src/solvers/mujoco/kernels.py         |  408 ++--
 newton/_src/solvers/mujoco/solver_mujoco.py   |   84 +-
 newton/_src/solvers/xpbd/kernels.py           |   99 +
 newton/_src/solvers/xpbd/solver_xpbd.py       |  102 +
 newton/_src/utils/import_usd.py               |  454 +++-
 newton/_src/viewer/gl/newton_envmap.jpg       |  Bin 187281 -> 105653 bytes
 newton/_src/viewer/gl/opengl.py               |   68 +-
 newton/_src/viewer/gl/shaders.py              |  193 +-
 newton/_src/viewer/kernels.py                 |   12 +
 newton/_src/viewer/picking.py                 |   52 +
 newton/_src/viewer/viewer.py                  |   55 +-
 newton/_src/viewer/viewer_gl.py               |  100 +-
 newton/_src/viewer/viewer_viser.py            |  144 +-
 newton/examples/__init__.py                   |   51 +-
 .../examples/basic/example_basic_conveyor.py  |    4 +-
 newton/examples/cloth/example_cloth_franka.py |  174 +-
 .../robot/example_robot_panda_hydro.py        |   16 +-
 newton/tests/assets/humanoid_mjc.usda         | 1878 +++++++++++++++++
 newton/tests/test_broad_phase.py              |   10 -
 newton/tests/test_collision_pipeline.py       |  319 +++
 newton/tests/test_contact_reduction_global.py |  501 ++++-
 newton/tests/test_hashtable.py                |    7 -
 newton/tests/test_hydroelastic.py             |    1 -
 newton/tests/test_import_usd.py               |  152 ++
 newton/tests/test_import_usd_multi_dof.py     |   67 +
 newton/tests/test_menagerie_mujoco.py         |    2 -
 newton/tests/test_menagerie_usd_mujoco.py     |   15 +-
 newton/tests/test_mujoco_solver.py            |  108 +
 newton/tests/test_narrow_phase.py             |    2 -
 newton/tests/test_raycast.py                  |  497 +++--
 newton/tests/test_remesh.py                   |    6 -
 newton/tests/test_sensor_raycast.py           |   75 +
 newton/tests/test_solver_xpbd.py              |  383 ++++
 newton/tests/test_viewer_picking.py           |    2 -
 uv.lock                                       |  188 +-
 68 files changed, 7602 insertions(+), 891 deletions(-)
 create mode 100644 newton/_src/geometry/contact_sort.py
 create mode 100644 newton/_src/solvers/kamino/tests/test_geometry_mesh_heightfield.py
 create mode 100644 newton/tests/assets/humanoid_mjc.usda
 create mode 100644 newton/tests/test_import_usd_multi_dof.py

diff --git a/.github/workflows/aws_gpu_benchmarks.yml b/.github/workflows/aws_gpu_benchmarks.yml
index 189f05d6ab..7f98144f8a 100644
--- a/.github/workflows/aws_gpu_benchmarks.yml
+++ b/.github/workflows/aws_gpu_benchmarks.yml
@@ -71,7 +71,7 @@ jobs:
           echo "LATEST_AMI_ID=$LATEST_AMI_ID" >> "$GITHUB_ENV"
       - name: Start EC2 runner
         id: start-ec2-runner
-        uses: machulav/ec2-github-runner@a00f575a87f3a96ec6de9413d16eeb828a3cc0a8  # v2.5.2
+        uses: machulav/ec2-github-runner@343a1b2ae682e681c3cec9a235d882da17ff04ef  # v2.6.1
         with:
           mode: start
           github-token: ${{ secrets.GH_PERSONAL_ACCESS_TOKEN }}
@@ -219,7 +219,7 @@ jobs:
           role-duration-seconds: ${{ env.AWS_ROLE_DURATION }}
 
       - name: Stop EC2 runner
-        uses: machulav/ec2-github-runner@a00f575a87f3a96ec6de9413d16eeb828a3cc0a8  # v2.5.2
+        uses: machulav/ec2-github-runner@343a1b2ae682e681c3cec9a235d882da17ff04ef  # v2.6.1
         with:
           mode: stop
           github-token: ${{ secrets.GH_PERSONAL_ACCESS_TOKEN }}
diff --git a/.github/workflows/aws_gpu_tests.yml b/.github/workflows/aws_gpu_tests.yml
index 2185027d95..2e28c1cab2 100644
--- a/.github/workflows/aws_gpu_tests.yml
+++ b/.github/workflows/aws_gpu_tests.yml
@@ -88,7 +88,7 @@ jobs:
           echo "LATEST_AMI_ID=$LATEST_AMI_ID" >> "$GITHUB_ENV"
       - name: Start EC2 runner
         id: start-ec2-runner
-        uses: machulav/ec2-github-runner@a00f575a87f3a96ec6de9413d16eeb828a3cc0a8  # v2.5.2
+        uses: machulav/ec2-github-runner@343a1b2ae682e681c3cec9a235d882da17ff04ef  # v2.6.1
         with:
           mode: start
           github-token: ${{ secrets.GH_PERSONAL_ACCESS_TOKEN }}
@@ -236,7 +236,7 @@ jobs:
           role-duration-seconds: ${{ env.AWS_ROLE_DURATION }}
 
       - name: Stop EC2 runner
-        uses: machulav/ec2-github-runner@a00f575a87f3a96ec6de9413d16eeb828a3cc0a8  # v2.5.2
+        uses: machulav/ec2-github-runner@343a1b2ae682e681c3cec9a235d882da17ff04ef  # v2.6.1
         with:
           mode: stop
           github-token: ${{ secrets.GH_PERSONAL_ACCESS_TOKEN }}
diff --git a/.github/workflows/minimum_deps_tests.yml b/.github/workflows/minimum_deps_tests.yml
index f42538560a..b1dd22bcde 100644
--- a/.github/workflows/minimum_deps_tests.yml
+++ b/.github/workflows/minimum_deps_tests.yml
@@ -64,7 +64,7 @@ jobs:
 
       - name: Start EC2 runner
         id: start-ec2-runner
-        uses: machulav/ec2-github-runner@a00f575a87f3a96ec6de9413d16eeb828a3cc0a8  # v2.5.2
+        uses: machulav/ec2-github-runner@343a1b2ae682e681c3cec9a235d882da17ff04ef  # v2.6.1
         with:
           mode: start
           github-token: ${{ secrets.GH_PERSONAL_ACCESS_TOKEN }}
@@ -186,7 +186,7 @@ jobs:
           role-duration-seconds: ${{ env.AWS_ROLE_DURATION }}
 
       - name: Stop EC2 runner
-        uses: machulav/ec2-github-runner@a00f575a87f3a96ec6de9413d16eeb828a3cc0a8  # v2.5.2
+        uses: machulav/ec2-github-runner@343a1b2ae682e681c3cec9a235d882da17ff04ef  # v2.6.1
         with:
           mode: stop
           github-token: ${{ secrets.GH_PERSONAL_ACCESS_TOKEN }}
diff --git a/.github/workflows/mujoco_warp_tests.yml b/.github/workflows/mujoco_warp_tests.yml
index c6992a8503..adcc68aa40 100644
--- a/.github/workflows/mujoco_warp_tests.yml
+++ b/.github/workflows/mujoco_warp_tests.yml
@@ -63,7 +63,7 @@ jobs:
 
       - name: Start EC2 runner
         id: start-ec2-runner
-        uses: machulav/ec2-github-runner@a00f575a87f3a96ec6de9413d16eeb828a3cc0a8  # v2.5.2
+        uses: machulav/ec2-github-runner@343a1b2ae682e681c3cec9a235d882da17ff04ef  # v2.6.1
         with:
           mode: start
           github-token: ${{ secrets.GH_PERSONAL_ACCESS_TOKEN }}
@@ -194,7 +194,7 @@ jobs:
           role-duration-seconds: ${{ env.AWS_ROLE_DURATION }}
 
       - name: Stop EC2 runner
-        uses: machulav/ec2-github-runner@a00f575a87f3a96ec6de9413d16eeb828a3cc0a8  # v2.5.2
+        uses: machulav/ec2-github-runner@343a1b2ae682e681c3cec9a235d882da17ff04ef  # v2.6.1
         with:
           mode: stop
           github-token: ${{ secrets.GH_PERSONAL_ACCESS_TOKEN }}
diff --git a/.github/workflows/warp_nightly_tests.yml b/.github/workflows/warp_nightly_tests.yml
index aa087f30ca..430d0e2067 100644
--- a/.github/workflows/warp_nightly_tests.yml
+++ b/.github/workflows/warp_nightly_tests.yml
@@ -63,7 +63,7 @@ jobs:
 
       - name: Start EC2 runner
         id: start-ec2-runner
-        uses: machulav/ec2-github-runner@a00f575a87f3a96ec6de9413d16eeb828a3cc0a8  # v2.5.2
+        uses: machulav/ec2-github-runner@343a1b2ae682e681c3cec9a235d882da17ff04ef  # v2.6.1
         with:
           mode: start
           github-token: ${{ secrets.GH_PERSONAL_ACCESS_TOKEN }}
@@ -189,7 +189,7 @@ jobs:
           role-duration-seconds: ${{ env.AWS_ROLE_DURATION }}
 
       - name: Stop EC2 runner
-        uses: machulav/ec2-github-runner@a00f575a87f3a96ec6de9413d16eeb828a3cc0a8  # v2.5.2
+        uses: machulav/ec2-github-runner@343a1b2ae682e681c3cec9a235d882da17ff04ef  # v2.6.1
         with:
           mode: stop
           github-token: ${{ secrets.GH_PERSONAL_ACCESS_TOKEN }}
diff --git a/CHANGELOG.md b/CHANGELOG.md
index bb65f599da..45e243e230 100644
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@@ -4,6 +4,40 @@
 
 ### Added
 
+- Add `SolverXPBD.update_contacts()` to populate `contacts.force` with per-contact spatial forces (linear force and torque) derived from XPBD constraint impulses
+- Raise process priority automatically in `--benchmark` mode for more stable measurements; add `--realtime` for maximum priority.
+- Add `TRIANGLE_PRISM` support-function type for heightfield triangles, extruding 1 m along the heightfield's local -Z so GJK/MPR naturally resolves shapes on the back side
+- Add `ViewerGL.log_scalar()` for live scalar time-series plots in the viewer
+- Add `deterministic` flag to `CollisionPipeline` and `NarrowPhase` for GPU-thread-scheduling-independent contact ordering via radix sort and deterministic fingerprint tiebreaking in contact reduction
+- Add `ViewerBase.log_arrows()` for arrow rendering (wide line + arrowhead) in the GL viewer with a dedicated geometry shader
+- Add `enable_multiccd` parameter to `SolverMuJoCo` for multi-CCD contact generation (up to 4 contact points per geom pair)
+- Add `ViewerViser.log_scalar()` for live scalar time-series plots via uPlot
+
+### Changed
+
+- Render all GL viewer lines (joints, contacts, wireframes) as geometry-shader quads instead of ``GL_LINES`` for uniform width across zoom levels and non-square viewports
+- Pin `mujoco` and `mujoco-warp` dependencies to `~=3.6.0`
+- Update default environment map texture in GL viewer (source: https://polyhaven.com/a/brown_photostudio_02)
+- Increase conveyor rail roughness in `example_basic_conveyor` to reduce mirror-like reflections
+
+### Fixed
+
+- Fix viewer crash with `imgui_bundle>=1.92.6` when editing colors by normalizing `color_edit3` input/output in `_edit_color3`
+- Show prismatic joints in the GL viewer when "Show Joints" is enabled
+- Fix connect constraint anchor computation to account for joint reference positions when `SolverMuJoCo` is the chosen solver.
+- Fix mesh-convex back-face contacts generating inverted normals that trap shapes inside meshes and cause solver divergence (NaN)
+- Fix MPR convergence failure on large and extreme-aspect-ratio mesh triangles by projecting the starting point onto the triangle nearest the convex center
+- Fix O(W²·S²) memory explosion in `CollisionPipeline` shape-pair buffer allocation for NXN and SAP broad phase modes by computing per-world pair counts instead of a global N²
+- Fix `SensorRaycast` ignoring `PLANE` geometry
+- Fix SDF hydroelastic broadphase scatter kernel using a grid-stride loop with binary search instead of per-pair thread launch
+- Fix box support-map sign flips from quaternion rotation noise (~1e-14) producing invalid GJK/MPR contacts for face-touching boxes with non-trivial base rotations
+- Fix USD import of multi-DOF joints from MuJoCo-converted assets where multiple revolute joints between the same two bodies caused false cycle detection; merge them into D6 joints with correct DOF label mapping for MjcActuator target resolution
+- Fix ViewerViser mesh popping artifacts caused by viser's automatic LOD simplification creating holes in complex geometry
+
+## [1.1.0] - 2026-04-13
+
+### Added
+
 - Add repeatable `--warp-config KEY=VALUE` CLI option for overriding `warp.config` attributes when running examples
 - Add 3D texture-based SDF, replacing NanoVDB volumes in the mesh-mesh collision pipeline for improved performance and CPU compatibility.
 - Parse URDF joint `limit effort="..."` values and propagate them to imported revolute and prismatic joint `effort_limit` settings
@@ -33,8 +67,14 @@
 - Add `compute_normals` and `compute_uvs` optional arguments to `Mesh.create_heightfield()` and `Mesh.create_terrain()`
 - Pin `newton-assets` and `mujoco_menagerie` downloads to specific commit SHAs for reproducible builds (`NEWTON_ASSETS_REF`, `MENAGERIE_REF`)
 - Add `ref` parameter to `download_asset()` to allow overriding the pinned revision
+- Add import of `UsdGeom.TetMesh` prims as soft meshes through `ModelBuilder.add_usd()`
 - Add `total_force_friction` and `force_matrix_friction` to `SensorContact` for tangential (friction) force decomposition
-- Add `compute_normals` and `compute_uvs` optional arguments to `Mesh.create_heightfield()` and `Mesh.create_terrain()`
+- Add Gaussian Splat geometry support via `ModelBuilder.add_shape_gaussian()` and USD import
+- Add configurable Gaussian sorting modes to `SensorTiledCamera`
+- Add automatic box, sphere, and capsule shape fitting for convex meshes during MJCF import
+- Add color and texture reading to `usd.utils.get_mesh()`
+- Export `ViewerBase` from `newton.viewer` public API
+- Add `custom_attributes` argument to `ModelBuilder.add_shape_convex_hull()`
 - Add RJ45 plug-socket insertion example with SDF contacts, latch joint, and interactive gizmo
 - Add `SpeculativeContactConfig` and speculative contact support in `CollisionPipeline` to detect contacts for fast-moving objects before they tunnel through thin geometry
 - Add `TRIANGLE_PRISM` support-function type for heightfield triangles, extruding 1 m along the heightfield's local -Z so GJK/MPR naturally resolves shapes on the back side
@@ -42,31 +82,32 @@
 
 ### Changed
 
+- Require `mujoco ~=3.6.0` and `mujoco-warp ~=3.6.0` (previously 3.5.x)
+- Replace `plyfile` dependency with `open3d` for mesh I/O. Users who depended on `plyfile` transitively should install it separately.
+- Switch Python build backend from `hatchling` to `uv_build`
 - Switch mesh-SDF collision from triangle-based gradient descent to edge-based Brent's method to reduce contact jitter
 - Unify heightfield and mesh collision pipeline paths; the separate `heightfield_midphase_kernel` and `shape_pairs_heightfield` buffer are removed in favor of the shared mesh midphase
-- Replace per-shape `Model.shape_heightfield_data` / `Model.heightfield_elevation_data` with compact `Model.shape_heightfield_index` / `Model.heightfield_data` / `Model.heightfield_elevations`, matching the SDF indirection pattern
+- Replace per-shape `Model.shape_heightfield_data` / `Model.heightfield_elevation_data` with compact `Model.shape_heightfield_index` / `Model.heightfield_data` / `Model.heightfield_elevations`, matching the SDF indirection pattern. Use `Model.heightfield_data` indexed via `Model.shape_heightfield_index` instead.
 - Standardize `rigid_contact_normal` to point from shape 0 toward shape 1 (A-to-B), matching the documented convention. Consumers that previously negated the normal on read (XPBD, VBD, MuJoCo, Kamino) no longer need to.
-- Replace `Model.sdf_data` / `sdf_volume` / `sdf_coarse_volume` with texture-based equivalents (`texture_sdf_data`, `texture_sdf_coarse_textures`, `texture_sdf_subgrid_textures`)
+- Replace `Model.sdf_data` / `sdf_volume` / `sdf_coarse_volume` with texture-based equivalents (`texture_sdf_data`, `texture_sdf_coarse_textures`, `texture_sdf_subgrid_textures`). Use `Model.texture_sdf_data`, `texture_sdf_coarse_textures`, and `texture_sdf_subgrid_textures` instead.
 - Render inertia boxes as wireframe lines instead of solid boxes in the GL viewer to avoid occluding objects
 - Make contact reduction normal binning configurable (polyhedron, scan directions, voxel budget) via constants in ``contact_reduction.py``
 - Upgrade GL viewer lighting from Blinn-Phong to Cook-Torrance PBR with GGX distribution, Schlick-GGX geometry, Fresnel-weighted ambient, and ACES filmic tone mapping
 - Change implicit MPM residual computation to consider both infinity and l2 norm
 - Change implicit MPM hardening law from exponential to hyperbolic sine (`sinh(-h * log(Jp))`), no longer scales elastic modulus
-- Change implicit MPM collider velocity mode names: `"forward"` / `"backward"` replace `"instantaneous"` / `"finite_difference"`
+- Change implicit MPM collider velocity mode names: `"forward"` / `"backward"` replace `"instantaneous"` / `"finite_difference"`. Old names are no longer accepted.
 - Simplify `SensorContact` force output: add `total_force` (aggregate per sensing object) and `force_matrix` (per-counterpart breakdown, `None` when no counterparts)
 - Add `sensing_obj_idx` (`list[int]`), `counterpart_indices` (`list[list[int]]`), `sensing_obj_type`, and `counterpart_type` attributes. Rename `include_total` to `measure_total`
 - Replace verbose Apache 2.0 boilerplate with two-line SPDX-only license headers across all source and documentation files
-- Add `custom_attributes` argument to `ModelBuilder.add_shape_convex_hull()`
 - Improve wrench preservation in hydroelastic contacts with contact reduction.
 - Show Newton deprecation warnings during example runs started via `python -m newton.examples ...` or `python -m newton.examples.<category>.<module>`; pass `-W ignore::DeprecationWarning` if you need the previous quiet behavior.
 - Reorder `ModelBuilder.add_shape_gaussian()` parameters so `xform` precedes `gaussian`, in line with other `add_shape_*` methods. Callers using positional arguments should switch to keyword form (`gaussian=..., xform=...`); passing a `Gaussian` as the second positional argument still works but emits a `DeprecationWarning`
 - Rename `ModelBuilder.add_shape_ellipsoid()` parameters `a`, `b`, `c` to `rx`, `ry`, `rz`. Old names are still accepted as keyword arguments but emit a `DeprecationWarning`
-- Rename `collide_plane_cylinder()` parameter `cylinder_center` to `cylinder_pos` for consistency with other collide functions
+- Rename `collide_plane_cylinder()` parameter `cylinder_center` to `cylinder_pos` for consistency with other collide functions. The old name is no longer accepted.
 - Add optional `state` parameter to `SolverBase.update_contacts()` to align the base-class signature with Kamino and MuJoCo solvers
 - Use `Literal` types for `SolverImplicitMPM.Config` string fields with fixed option sets (`solver`, `warmstart_mode`, `collider_velocity_mode`, `grid_type`, `transfer_scheme`, `integration_scheme`)
 - Migrate `wp.array(dtype=X)` type annotations to `wp.array[X]` bracket syntax (Warp 1.12+).
 - Align articulated `State.body_qd` / FK / IK / Jacobian / mass-matrix linear velocity with COM-referenced motion. If you were comparing `body_qd[:3]` against finite-differenced body-origin motion, recover origin velocity via `v_origin = v_com - omega x r_com_world`. Descendant `FREE` / `DISTANCE` `joint_qd` remains parent-frame and `joint_f` remains a world-frame COM wrench.
-- Pin `mujoco` and `mujoco-warp` dependencies to `~=3.6.0`
 
 ### Deprecated
 
@@ -102,11 +143,9 @@
 - Update `ModelBuilder` internal state after fast-path (GPU kernel) inertia validation so it matches the returned `Model`
 - Fix MJCF mesh scale resolution to use the mesh asset's own class rather than the geom's default class, avoiding incorrect vertex scaling for models like Robotiq 2F-85 V4
 - Fix articulated bodies drifting laterally on the ground in XPBD solver by solving rigid contacts before joints
-- Fix viewer crash with `imgui_bundle>=1.92.6` when editing colors by normalizing `color_edit3` input/output in `_edit_color3`
 - Fix `hide_collision_shapes=True` not hiding collision meshes that have bound PBR materials
 - Filter inactive particles in viewer so only particles with `ParticleFlags.ACTIVE` are rendered
 - Fix concurrent asset download races on Windows by using content-addressed cache directories
-- Show prismatic joints in the GL viewer when "Show Joints" is enabled
 - Fix body `gravcomp` not being written to the MuJoCo spec, causing it to be absent from XML saved via `save_to_mjcf`
 - Fix `compute_world_offsets` grid ordering to match terrain grid row-major order so replicated world indices align with terrain block indices
 - Fix `eq_solimp` not being written to the MuJoCo spec for equality constraints, causing it to be absent from XML saved via `save_to_mjcf`
@@ -131,14 +170,12 @@
 - Fix heightfield bounding-sphere radius underestimating Z extent for asymmetric height ranges (e.g. `min_z=0, max_z=10`)
 - Fix VBD self-contact barrier C2 discontinuity at `d = tau` caused by a factor-of-two error in the log-barrier coefficient
 - Fix fast inertia validation treating near-symmetric tensors within `np.allclose()` default tolerances as corrections, aligning CPU and GPU validation warnings
-- Fix connect constraint anchor computation to account for joint reference positions when `SolverMuJoCo` is the chosen solver.
-- Fix forward-kinematics child-origin linear velocity for articulated translated joints
 - Fix URDF joint dynamics friction import so specified friction values are preserved during simulation
+- Fix `requires_grad` not being preserved in `ArticulationView` attribute getters, breaking gradient propagation through selection queries
 - Fix duplicate Reset button in brick stacking example when using the example browser
-- Fix mesh-convex back-face contacts generating inverted normals that trap shapes inside meshes and cause solver divergence (NaN)
-- Fix MPR convergence failure on large and extreme-aspect-ratio mesh triangles by projecting the starting point onto the triangle nearest the convex center
 - Cap `cbor2` dependency to `<6` to prevent recorder test failures caused by breaking deserialization changes in cbor2 6.0
-- Fix O(W²·S²) memory explosion in `CollisionPipeline` shape-pair buffer allocation for NXN and SAP broad phase modes by computing per-world pair counts instead of a global N²
+- Clamp viewer picking force to prevent explosion when picking light objects near stiff contacts, configurable via `pick_max_acceleration` parameter on the `Picking` class (default 5g of effective articulation mass)
+- Fix `cloth_franka` example Jacobian broken by COM-referenced `body_qd` convention change; adjust robot base height, gripper orientations, and grasp targets for improved reachability (a follow-up PR will migrate the example to `newton.ik`)
 
 ## [1.0.0] - 2026-03-10
 
diff --git a/docs/concepts/collisions.rst b/docs/concepts/collisions.rst
index 92322a6ec4..a417621de7 100644
--- a/docs/concepts/collisions.rst
+++ b/docs/concepts/collisions.rst
@@ -1324,7 +1324,15 @@ and is consumed by the solver :meth:`~solvers.SolverBase.step` method for contac
    * - Attribute
      - Description
    * - :attr:`~Contacts.force`
-     - Contact spatial forces (used by :class:`~sensors.SensorContact`)
+     - Contact spatial forces (used by :class:`~sensors.SensorContact`).
+       Populated by :meth:`~solvers.SolverBase.update_contacts`.
+
+.. note::
+
+   :class:`~solvers.SolverXPBD` with ``rigid_contact_con_weighting`` enabled
+   (the default) does not conserve momentum at contacts.  The per-contact
+   forces written by :meth:`~solvers.SolverXPBD.update_contacts` are
+   approximate -- see that method's documentation for details.
 
 Example usage:
 
@@ -1671,6 +1679,38 @@ Custom collision properties can be authored in USD:
 
 See :doc:`custom_attributes` and :doc:`usd_parsing` for details.
 
+.. _Deterministic Contacts:
+
+Deterministic Contact Ordering
+------------------------------
+
+GPU thread scheduling is non-deterministic, so the order in which contacts are
+written to the output buffer can vary between runs.  Pass ``deterministic=True``
+to :class:`~newton.CollisionPipeline` (or :class:`~newton.geometry.NarrowPhase`) to guarantee
+a reproducible contact order:
+
+.. code-block:: python
+
+    pipeline = newton.CollisionPipeline(model, deterministic=True)
+
+This enables two mechanisms:
+
+1. **Fingerprint tiebreaking** — each contact carries a geometry-derived
+   fingerprint (triangle/edge index) that is used as a deterministic tiebreaker
+   in the ``atomic_max`` contact reduction, so the reduction winner is
+   independent of thread scheduling.
+2. **Radix sort** — after the narrow phase, all contact arrays are reordered by
+   a 64-bit key encoding ``(shape_a, shape_b, sub_key)`` via a radix sort +
+   gather pass.
+
+The overhead is small: fingerprint storage per contact, modified packing in
+the reduction, and one radix sort + gather pass per frame.  The sort is
+fully CUDA-graph-capturable.
+
+.. note::
+
+   Hydroelastic contacts are not yet covered by deterministic ordering.
+
 .. _Performance:
 
 Performance
diff --git a/docs/guide/release.rst b/docs/guide/release.rst
index c47c9eae89..e51437ad7a 100644
--- a/docs/guide/release.rst
+++ b/docs/guide/release.rst
@@ -75,7 +75,7 @@ Pre-release planning
        - Verify deprecated symbols carry proper deprecation warnings and
          migration guidance (see :ref:`deprecation-timeline`).
        - Confirm new public API has complete docstrings and is included in
-         Sphinx docs (run ``docs/generate_api.py``).
+         Sphinx docs (run ``uv run docs/generate_api.py``).
    * - ☐
      - Communicate the timeline to the community.
 
@@ -91,17 +91,33 @@ Code freeze and release branch creation
      - Create ``release-X.Y`` branch from ``main`` and push it.
    * - ☐
      - On **main**: bump the version in ``pyproject.toml`` to ``X.(Y+1).0.dev0`` and run
-       ``docs/generate_api.py``.
+       ``uv run docs/generate_api.py``.
    * - ☐
      - On **release-X.Y**: bump the version in ``pyproject.toml`` to ``X.Y.ZrcN`` and
-       run ``docs/generate_api.py``.
+       run ``uv run docs/generate_api.py``.
    * - ☐
      - On **release-X.Y**: update dependencies in ``pyproject.toml`` from dev
-       to RC versions where applicable, then regenerate ``uv.lock``
-       (``uv lock``) and commit it.
+       to RC versions where applicable and remove the NVIDIA package index
+       (``[[tool.uv.index]]`` entry for ``nvidia`` **and** the
+       ``warp-lang`` entry in ``[tool.uv.sources]`` that references it) so
+       the release wheel installs purely from PyPI, then regenerate
+       ``uv.lock`` (``uv lock``) and commit.
    * - ☐
      - Push tag ``vX.Y.Zrc1``.  This triggers the ``release.yml`` workflow
        (build wheel → PyPI publish with manual approval).
+   * - ☐
+     - Manually trigger the **minimum-dependency** and **multi-GPU** CI
+       workflows on the ``release-X.Y`` branch (the nightly orchestrator
+       only runs on ``main``).  Verify both pass before announcing the RC.
+
+       .. code-block:: bash
+
+          # Minimum-dependency tests (lowest compatible PyPI versions)
+          gh workflow run minimum_deps_tests.yml --ref release-X.Y
+
+          # Multi-GPU tests (g7e.12xlarge = 4× L40S GPUs)
+          gh workflow run aws_gpu_tests.yml --ref release-X.Y \
+              -f instance-type=g7e.12xlarge
    * - ☐
      - RC1 published to PyPI (approve in GitHub environment).
 
@@ -115,7 +131,7 @@ branch and open a pull request targeting ``release-X.Y`` — never push
 directly to the release branch.
 
 For each new RC (``rc2``, ``rc3``, …) bump the version in
-``pyproject.toml`` and run ``docs/generate_api.py``, then tag and push.
+``pyproject.toml`` and run ``uv run docs/generate_api.py``, then tag and push.
 Resolve any cherry-pick conflicts or missing dependent cherry-picks that
 cause CI failures before tagging.
 
@@ -194,7 +210,7 @@ otherwise.
        dependencies remain in the lock file.
    * - ☐
      - Bump the version in ``pyproject.toml`` to ``X.Y.Z`` (remove the RC suffix) and
-       run ``docs/generate_api.py``.
+       run ``uv run docs/generate_api.py``.
    * - ☐
      - Commit and push tag ``vX.Y.Z``.  Automated workflows trigger:
 
diff --git a/newton/_src/geometry/collision_convex.py b/newton/_src/geometry/collision_convex.py
index 906b3db94d..61d2df4769 100644
--- a/newton/_src/geometry/collision_convex.py
+++ b/newton/_src/geometry/collision_convex.py
@@ -104,6 +104,7 @@ def solve_convex_multi_contact(
             contact_data.contact_point_center = point
             contact_data.contact_normal_a_to_b = normal_ws
             contact_data.contact_distance = signed_distance
+            contact_data.sort_sub_key = contact_template.sort_sub_key << 3
             contact_data = post_process_contact(
                 contact_data, geom_a, position_a, orientation_a, geom_b, position_b, orientation_b
             )
@@ -205,6 +206,7 @@ def solve_convex_single_contact(
         contact_data.contact_point_center = point
         contact_data.contact_normal_a_to_b = normal
         contact_data.contact_distance = signed_distance
+        contact_data.sort_sub_key = contact_template.sort_sub_key << 3
 
         contact_data = post_process_contact(
             contact_data, geom_a, position_a, orientation_a, geom_b, position_b, orientation_b
diff --git a/newton/_src/geometry/collision_core.py b/newton/_src/geometry/collision_core.py
index 8312696ceb..66f66f6c42 100644
--- a/newton/_src/geometry/collision_core.py
+++ b/newton/_src/geometry/collision_core.py
@@ -307,6 +307,7 @@ def compute_gjk_mpr_contacts(
         margin_a: float,
         margin_b: float,
         writer_data: Any,
+        sort_sub_key: int = 0,
     ):
         """
         Compute contacts between two shapes using GJK/MPR algorithm and write them.
@@ -324,6 +325,7 @@ def compute_gjk_mpr_contacts(
             margin_a: Per-shape margin offset for shape A (signed distance padding)
             margin_b: Per-shape margin offset for shape B (signed distance padding)
             writer_data: Data structure for contact writer
+            sort_sub_key: Sub-key for deterministic contact sorting (e.g. triangle/edge index)
         """
         data_provider = SupportMapDataProvider()
 
@@ -354,6 +356,7 @@ def compute_gjk_mpr_contacts(
         contact_template.shape_a = shape_a
         contact_template.shape_b = shape_b
         contact_template.gap_sum = rigid_gap
+        contact_template.sort_sub_key = sort_sub_key
 
         if wp.static(ENABLE_MULTI_CONTACT):
             wp.static(create_solve_convex_multi_contact(support_func, writer_func, post_process_contact))(
diff --git a/newton/_src/geometry/contact_data.py b/newton/_src/geometry/contact_data.py
index a2aa469732..8330ef992b 100644
--- a/newton/_src/geometry/contact_data.py
+++ b/newton/_src/geometry/contact_data.py
@@ -37,6 +37,7 @@ class ContactData:
         contact_stiffness: Contact stiffness. 0.0 means no stiffness was set.
         contact_damping: Contact damping scale. 0.0 means no damping was set.
         contact_friction_scale: Friction scaling factor. 0.0 means no friction was set.
+        sort_sub_key: Sub-key for deterministic contact sorting (encodes edge/triangle/vertex index).
     """
 
     contact_point_center: wp.vec3
@@ -52,6 +53,34 @@ class ContactData:
     contact_stiffness: float
     contact_damping: float
     contact_friction_scale: float
+    sort_sub_key: int
+
+
+@wp.func
+def make_contact_sort_key(shape_a: int, shape_b: int, sort_sub_key: int) -> wp.int64:
+    """Build a 64-bit sort key for deterministic contact ordering.
+
+    Layout (bit 63 kept zero so int64 order matches uint64 order)::
+
+        [62:43] shape_a      (20 bits, max 1,048,575 shapes)
+        [42:23] shape_b      (20 bits, max 1,048,575 shapes)
+        [22:0]  sort_sub_key (23 bits, max 8,388,607)
+
+    Values exceeding these bit widths are silently masked.  The effective
+    limits depend on upstream bit consumption in each contact path:
+
+    - Mesh-triangle contacts: ``(tri_idx << 1) | 1`` — 22 effective bits
+      for ``tri_idx`` (~4M triangles).  When expanded by the multi-contact
+      path (``<< 3 | i``), this drops to 19 effective bits (~524K triangles).
+    - SDF contacts: ``(edge_idx << 2) | (mode << 1)`` — 21 effective bits
+      for ``edge_idx`` (~2M edges).  After multi-contact expansion
+      (``<< 3``), 18 effective bits (~262K edges).
+    """
+    return (
+        ((wp.int64(shape_a) & wp.int64(0xFFFFF)) << wp.int64(43))
+        | ((wp.int64(shape_b) & wp.int64(0xFFFFF)) << wp.int64(23))
+        | (wp.int64(sort_sub_key) & wp.int64(0x7FFFFF))
+    )
 
 
 @wp.func
diff --git a/newton/_src/geometry/contact_reduction_global.py b/newton/_src/geometry/contact_reduction_global.py
index d0a793408a..177afcbcaa 100644
--- a/newton/_src/geometry/contact_reduction_global.py
+++ b/newton/_src/geometry/contact_reduction_global.py
@@ -242,31 +242,217 @@ def make_contact_key(shape_a: int, shape_b: int, bin_id: int) -> wp.uint64:
     return key
 
 
+# ---------------------------------------------------------------------------
+# Contact value packing
+# ---------------------------------------------------------------------------
+# Two packing modes exist — **fast** (default) and **deterministic**.
+# Each variant is a standalone ``@wp.func``.  The dispatching wrappers
+# ``make_contact_value`` and ``unpack_contact_id`` select the variant
+# at runtime based on a ``deterministic`` flag passed from
+# ``GlobalContactReducerData.deterministic``, making the packing mode
+# a per-reducer property instead of process-global state.
+#
+# **Fast** — ``(float_flip(score) << 32) | contact_id``.
+#   Full 32-bit score precision, no fingerprint. Contact_id in low 32 bits.
+#
+# **Deterministic** — ``(float_flip(score)>>10 << 42) | (fp << 20) | (id & 0xFFFFF)``.
+#   22-bit score, 22-bit fingerprint tiebreaker, 20-bit contact_id.
+# ---------------------------------------------------------------------------
+
+# 22-bit fingerprint is wide enough to distinguish any two contacts that share
+# the same truncated score within a single reduction slot.  The remaining 20
+# bits for contact_id support up to 1,048,575 buffered contacts.
+FINGERPRINT_BITS = wp.constant(wp.uint64(22))
+CONTACT_ID_BITS = wp.constant(wp.uint64(20))
+CONTACT_ID_MASK = wp.constant(wp.uint64((1 << 20) - 1))
+FINGERPRINT_MASK = wp.constant(wp.uint64((1 << 22) - 1))
+# Plain Python int (not wp.constant) because it is used inside wp.static()
+# which requires a Python-level value for compile-time evaluation.
+SCORE_SHIFT = 10
+
+
+# -- Fast (non-deterministic) variants -------------------------------------
+
+
 @wp.func
-def make_contact_value(score: float, contact_id: int) -> wp.uint64:
-    """Pack score and contact_id into hashtable value for atomic max.
+def _make_contact_value_fast(score: float, fingerprint: int, contact_id: int) -> wp.uint64:
+    """Pack score and contact_id into a uint64 for ``atomic_max`` (fast path).
 
-    High 32 bits: float_flip(score) - makes floats comparable as unsigned ints
-    Low 32 bits: contact_id - identifies which contact in the buffer
+    ::
 
-    Args:
-        score: Spatial projection score (higher is better)
-        contact_id: Index into the contact buffer
+        63                  32 31                 0
+        ┌─────────────────────┬────────────────────┐
+        │  float_flip(score)  │    contact_id      │
+        │     (32 bits)       │    (32 bits)        │
+        └─────────────────────┴────────────────────┘
 
-    Returns:
-        64-bit value for hashtable (atomic max will select highest score)
+    Full 32-bit IEEE-754 precision for the score.  The fingerprint argument
+    is accepted for signature compatibility but ignored — ties are broken
+    by contact_id (non-deterministic, but correct).
+
+    Args:
+        score: Spatial projection score or negated depth [m]. Higher is better.
+        fingerprint: Ignored in this variant (kept for signature compatibility).
+        contact_id: Index into the contact buffer (from ``atomic_add``).
     """
     return (wp.uint64(float_flip(score)) << wp.uint64(32)) | wp.uint64(contact_id)
 
 
+@wp.func
+def _make_preprune_probe_fast(score: float, fingerprint: int) -> wp.uint64:
+    """Pre-prune ceiling probe (fast path).
+
+    Packs the full-precision score with ``0xFFFFFFFF`` in the contact_id
+    field, creating the maximum possible value for this score.  The
+    comparison ``stored < probe`` is true whenever the stored value can
+    be beaten, regardless of what contact_id the new contact receives.
+    """
+    return (wp.uint64(float_flip(score)) << wp.uint64(32)) | wp.uint64(0xFFFFFFFF)
+
+
 @wp.func_native("""
 return static_cast<int32_t>(packed & 0xFFFFFFFFull);
 """)
-def unpack_contact_id(packed: wp.uint64) -> int:
-    """Extract contact_id from packed value."""
+def _unpack_contact_id_fast(packed: wp.uint64) -> int:
+    """Extract contact_id (low 32 bits) — fast variant."""
+    ...
+
+
+# -- Deterministic variants ------------------------------------------------
+
+
+@wp.func
+def _make_contact_value_det(score: float, fingerprint: int, contact_id: int) -> wp.uint64:
+    """Pack score, fingerprint, and contact_id into a uint64 for ``atomic_max``.
+
+    This packing enables **deterministic contact reduction**: multiple GPU
+    threads propose contacts for the same reduction slot via ``atomic_max``.
+    By encoding a deterministic fingerprint (derived from geometry) above
+    the non-deterministic contact_id, the ``atomic_max`` winner is always
+    the same regardless of thread scheduling.
+
+    ::
+
+        63        42 41        20 19          0
+        ┌──────────┬────────────┬──────────────┐
+        │  score   │ fingerprint│  contact_id  │
+        │ (22 bit) │  (22 bit)  │   (20 bit)   │
+        └──────────┴────────────┴──────────────┘
+
+    **Score (bits 63-42, 22 bits)** — ``float_flip(score) >> 10``.
+    ``float_flip`` reinterprets the IEEE-754 float as an order-preserving
+    uint32 (see http://stereopsis.com/radix.html).  The right-shift by
+    ``SCORE_SHIFT`` (10) discards the 10 least-significant bits of the
+    mantissa, keeping 1 sign-equivalent + 8 exponent + 13 mantissa = 22
+    bits.  This gives ~2^-13 ≈ 1.2e-4 relative precision — sufficient to
+    distinguish contacts whose spatial projection scores or negated depths
+    differ by more than ~0.1 mm at 1 m scale.
+
+    **Fingerprint (bits 41-20, 22 bits)** — deterministic tiebreaker
+    derived from geometry (edge index | mode/source tag bits).  When two
+    contacts have the same truncated score, the fingerprint breaks the tie
+    so that ``atomic_max`` always picks the same winner regardless of
+    thread scheduling.  Effective limits depend on upstream bit consumption:
+
+    - Mesh-triangle contacts: ``(tri_idx << 1) | 1`` — 21 effective bits
+      for ``tri_idx`` (~2M triangles).
+    - SDF contacts: ``(edge_idx << 2) | (mode << 1)`` — 20 effective bits
+      for ``edge_idx`` (~1M edges).
+
+    Meshes exceeding these limits will overflow the fingerprint field,
+    causing non-deterministic tiebreaking for those contacts.
+
+    **Contact ID (bits 19-0, 20 bits)** — buffer slot assigned by
+    ``atomic_add``.  20 bits supports up to 1,048,575 buffered contacts.
+    Non-deterministic, but only matters when both score and fingerprint
+    are identical, which requires two geometrically identical contacts —
+    an impossible case.
+
+    The cascade ``score > fingerprint > contact_id`` means ``atomic_max``
+    on this uint64 selects the contact with the best score, breaking ties
+    deterministically via fingerprint.
+
+    Args:
+        score: Spatial projection score or negated depth [m]. Higher is better.
+        fingerprint: Deterministic contact identifier (e.g. ``(edge_idx << 2) | (mode << 1)``).
+        contact_id: Index into the contact buffer (from ``atomic_add``).
+    """
+    return (
+        (wp.uint64(float_flip(score) >> wp.uint32(wp.static(SCORE_SHIFT))) << wp.uint64(42))
+        | ((wp.uint64(fingerprint) & FINGERPRINT_MASK) << CONTACT_ID_BITS)
+        | (wp.uint64(contact_id) & CONTACT_ID_MASK)
+    )
+
+
+@wp.func
+def _make_preprune_probe_det(score: float, fingerprint: int) -> wp.uint64:
+    """Deterministic pre-prune probe for ``export_and_reduce_contact_centered``.
+
+    Packs the score and fingerprint with ``CONTACT_ID_MASK`` (all 1s) in the
+    contact_id field, creating the *ceiling* value for this (score, fingerprint)
+    pair.  The pre-prune comparison ``stored < probe`` is then true whenever
+    the stored value can be beaten by a contact with this score and fingerprint,
+    regardless of what ``contact_id`` it receives from ``atomic_add``.
+
+    This makes the pre-prune decision depend only on deterministic quantities
+    (score and fingerprint), never on the non-deterministic contact_id.
+    """
+    return (
+        (wp.uint64(float_flip(score) >> wp.uint32(wp.static(SCORE_SHIFT))) << wp.uint64(42))
+        | ((wp.uint64(fingerprint) & FINGERPRINT_MASK) << CONTACT_ID_BITS)
+        | CONTACT_ID_MASK
+    )
+
+
+@wp.func_native("""
+return static_cast<int32_t>(packed & 0xFFFFFull);
+""")
+def _unpack_contact_id_det(packed: wp.uint64) -> int:
+    """Extract contact_id (low 20 bits) — deterministic variant."""
     ...
 
 
+# -- Per-reducer dispatching functions -------------------------------------
+# These functions dispatch between fast and deterministic variants based on
+# a ``deterministic`` flag, making the packing mode a per-reducer property
+# instead of process-global state.
+
+
+@wp.func
+def make_contact_value(score: float, fingerprint: int, contact_id: int, deterministic: int) -> wp.uint64:
+    """Pack score, fingerprint, and contact_id into a uint64 for ``atomic_max``.
+
+    Dispatches between fast and deterministic packing based on the
+    ``deterministic`` flag.  See :func:`_make_contact_value_fast` and
+    :func:`_make_contact_value_det` for the two packing layouts.
+
+    Args:
+        score: Spatial projection score or negated depth [m]. Higher is better.
+        fingerprint: Deterministic contact identifier (ignored in fast mode).
+        contact_id: Index into the contact buffer (from ``atomic_add``).
+        deterministic: Non-zero to use deterministic packing.
+    """
+    if deterministic != 0:
+        return _make_contact_value_det(score, fingerprint, contact_id)
+    return _make_contact_value_fast(score, fingerprint, contact_id)
+
+
+@wp.func
+def unpack_contact_id(packed: wp.uint64, deterministic: int) -> int:
+    """Extract contact_id from a packed value.
+
+    Dispatches between fast (low 32 bits) and deterministic (low 20 bits)
+    unpacking based on the ``deterministic`` flag.
+
+    Args:
+        packed: Packed uint64 value from ``make_contact_value``.
+        deterministic: Non-zero to use deterministic unpacking.
+    """
+    if deterministic != 0:
+        return _unpack_contact_id_det(packed)
+    return _unpack_contact_id_fast(packed)
+
+
 @wp.func
 def encode_oct(n: wp.vec3) -> wp.vec2:
     """Encode a unit normal into octahedral 2D representation.
@@ -337,6 +523,11 @@ class GlobalContactReducerData:
     contact_count: wp.array[wp.int32]
     capacity: int
 
+    # Deterministic fingerprint per contact (triangle/edge/vertex index).
+    # Used as a deterministic tiebreaker in make_contact_value so that
+    # atomic_max picks the same winner regardless of thread scheduling.
+    contact_fingerprints: wp.array[wp.int32]
+
     # Optional hydroelastic data
     # contact_area: area of contact surface element (per contact)
     contact_area: wp.array[wp.float32]
@@ -376,6 +567,12 @@ class GlobalContactReducerData:
     ht_capacity: int
     ht_values_per_key: int
 
+    # When non-zero, replace the speculative pre-prune probe with a
+    # deterministic variant (make_preprune_probe) so that the prune
+    # decision depends only on score and fingerprint, never on the
+    # non-deterministic contact_id.
+    deterministic: int
+
 
 @wp.kernel(enable_backward=False)
 def _clear_active_kernel(
@@ -510,6 +707,7 @@ def __init__(
         device: str | None = None,
         store_hydroelastic_data: bool = False,
         store_moment_data: bool = False,
+        deterministic: bool = False,
     ):
         """Initialize the global contact reducer.
 
@@ -519,10 +717,22 @@ def __init__(
             store_hydroelastic_data: If True, allocate arrays for contact_area and entry_k_eff
             store_moment_data: If True, allocate moment accumulator arrays for friction
                 moment matching. Only needed when ``moment_matching=True``.
+            deterministic: If True, use deterministic fingerprint-based tiebreaking
+                in contact reduction and replace the pre-prune probe with a
+                deterministic variant.
         """
+        max_det_contacts = 1 << int(CONTACT_ID_BITS)
+        if deterministic and capacity > max_det_contacts:
+            raise ValueError(
+                f"Deterministic contact packing supports at most {max_det_contacts} "
+                f"buffered contacts ({int(CONTACT_ID_BITS)}-bit contact_id), "
+                f"but capacity={capacity}. Reduce max_triangle_pairs or disable "
+                f"deterministic mode."
+            )
         self.capacity = capacity
         self.device = device
         self.store_hydroelastic_data = store_hydroelastic_data
+        self.deterministic = deterministic
 
         self.values_per_key = NUM_SPATIAL_DIRECTIONS + 1
 
@@ -530,6 +740,7 @@ def __init__(
         self.position_depth = wp.zeros(capacity, dtype=wp.vec4, device=device)
         self.normal = wp.zeros(capacity, dtype=wp.vec2, device=device)  # Octahedral-encoded normals
         self.shape_pairs = wp.zeros(capacity, dtype=wp.vec2i, device=device)
+        self.contact_fingerprints = wp.zeros(capacity, dtype=wp.int32, device=device)
 
         # Optional hydroelastic data arrays
         if store_hydroelastic_data:
@@ -657,6 +868,7 @@ def get_data_struct(self) -> GlobalContactReducerData:
         data.shape_pairs = self.shape_pairs
         data.contact_count = self.contact_count
         data.capacity = self.capacity
+        data.contact_fingerprints = self.contact_fingerprints
         data.contact_area = self.contact_area
         data.contact_nbin_entry = self.contact_nbin_entry
         data.entry_k_eff = self.entry_k_eff
@@ -671,6 +883,7 @@ def get_data_struct(self) -> GlobalContactReducerData:
         data.ht_insert_failures = self.ht_insert_failures
         data.ht_capacity = self.hashtable.capacity
         data.ht_values_per_key = self.values_per_key
+        data.deterministic = 1 if self.deterministic else 0
         return data
 
 
@@ -681,6 +894,7 @@ def export_contact_to_buffer(
     position: wp.vec3,
     normal: wp.vec3,
     depth: float,
+    fingerprint: int,
     reducer_data: GlobalContactReducerData,
 ) -> int:
     """Store a contact in the buffer without reduction.
@@ -691,6 +905,7 @@ def export_contact_to_buffer(
         position: Contact position in world space
         normal: Contact normal
         depth: Penetration depth (negative = penetrating)
+        fingerprint: Deterministic contact identifier (e.g. triangle/edge/vertex index)
         reducer_data: GlobalContactReducerData with all arrays
 
     Returns:
@@ -706,6 +921,7 @@ def export_contact_to_buffer(
     reducer_data.position_depth[contact_id] = wp.vec4(position[0], position[1], position[2], depth)
     reducer_data.normal[contact_id] = encode_oct(normal)
     reducer_data.shape_pairs[contact_id] = wp.vec2i(shape_a, shape_b)
+    reducer_data.contact_fingerprints[contact_id] = fingerprint
 
     return contact_id
 
@@ -746,6 +962,7 @@ def reduce_contact_in_hashtable(
     pd = reducer_data.position_depth[contact_id]
     normal = decode_oct(reducer_data.normal[contact_id])
     pair = reducer_data.shape_pairs[contact_id]
+    fingerprint = reducer_data.contact_fingerprints[contact_id]
 
     position = wp.vec3(pd[0], pd[1], pd[2])
     depth = pd[3]
@@ -775,11 +992,11 @@ def reduce_contact_in_hashtable(
             if use_beta:
                 dir_2d = get_spatial_direction_2d(dir_i)
                 score = wp.dot(pos_2d, dir_2d)
-                value = make_contact_value(score, contact_id)
+                value = make_contact_value(score, fingerprint, contact_id, reducer_data.deterministic)
                 slot_id = dir_i
                 reduction_update_slot(entry_idx, slot_id, value, reducer_data.ht_values, ht_capacity)
 
-        max_depth_value = make_contact_value(-depth, contact_id)
+        max_depth_value = make_contact_value(-depth, fingerprint, contact_id, reducer_data.deterministic)
         reduction_update_slot(
             entry_idx, wp.static(NUM_SPATIAL_DIRECTIONS), max_depth_value, reducer_data.ht_values, ht_capacity
         )
@@ -809,7 +1026,7 @@ def reduce_contact_in_hashtable(
     voxel_entry_idx = hashtable_find_or_insert(voxel_key, reducer_data.ht_keys, reducer_data.ht_active_slots)
     if voxel_entry_idx >= 0:
         # Use -depth so atomic_max selects most penetrating (most negative depth)
-        voxel_value = make_contact_value(-depth, contact_id)
+        voxel_value = make_contact_value(-depth, fingerprint, contact_id, reducer_data.deterministic)
         reduction_update_slot(voxel_entry_idx, voxel_local_slot, voxel_value, reducer_data.ht_values, ht_capacity)
     else:
         wp.atomic_add(reducer_data.ht_insert_failures, 0, 1)
@@ -822,6 +1039,7 @@ def export_and_reduce_contact(
     position: wp.vec3,
     normal: wp.vec3,
     depth: float,
+    fingerprint: int,
     reducer_data: GlobalContactReducerData,
     beta: float,
     shape_transform: wp.array[wp.transform],
@@ -830,7 +1048,7 @@ def export_and_reduce_contact(
     shape_voxel_resolution: wp.array[wp.vec3i],
 ) -> int:
     """Export contact to buffer and register in hashtable for reduction."""
-    contact_id = export_contact_to_buffer(shape_a, shape_b, position, normal, depth, reducer_data)
+    contact_id = export_contact_to_buffer(shape_a, shape_b, position, normal, depth, fingerprint, reducer_data)
 
     if contact_id >= 0:
         reduce_contact_in_hashtable(
@@ -853,6 +1071,7 @@ def export_and_reduce_contact_centered(
     position: wp.vec3,
     normal: wp.vec3,
     depth: float,
+    fingerprint: int,
     centered_position: wp.vec3,
     X_ws_voxel_shape: wp.transform,
     aabb_lower_voxel: wp.vec3,
@@ -879,6 +1098,7 @@ def export_and_reduce_contact_centered(
         position: World-space contact position (stored in buffer)
         normal: Contact normal (a-to-b)
         depth: Penetration depth
+        fingerprint: Deterministic contact identifier (e.g. edge index)
         centered_position: Midpoint-centered position for spatial projection
         X_ws_voxel_shape: World-to-local transform for voxel computation
         aabb_lower_voxel: Local AABB lower for voxel grid
@@ -897,11 +1117,16 @@ def export_and_reduce_contact_centered(
     entry_idx = hashtable_find_or_insert(key, reducer_data.ht_keys, reducer_data.ht_active_slots)
 
     # === Pre-prune normal bin: non-atomic reads ===
+    # In deterministic mode we use _make_preprune_probe_det (score + fingerprint +
+    # max contact_id) so the prune decision never depends on the non-deterministic
+    # contact_id.  In non-deterministic mode we use the cheaper floor probe.
     might_win = False
 
     if entry_idx >= 0:
-        # Check max-depth slot first (cheapest — no direction computation)
-        max_depth_probe = make_contact_value(-depth, 0)
+        if reducer_data.deterministic != 0:
+            max_depth_probe = _make_preprune_probe_det(-depth, fingerprint)
+        else:
+            max_depth_probe = _make_contact_value_fast(-depth, 0, 0)
         if reducer_data.ht_values[wp.static(NUM_SPATIAL_DIRECTIONS) * ht_capacity + entry_idx] < max_depth_probe:
             might_win = True
 
@@ -910,7 +1135,10 @@ def export_and_reduce_contact_centered(
                 if not might_win:
                     dir_2d = get_spatial_direction_2d(dir_i)
                     score = wp.dot(pos_2d, dir_2d)
-                    probe = make_contact_value(score, 0)
+                    if reducer_data.deterministic != 0:
+                        probe = _make_preprune_probe_det(score, fingerprint)
+                    else:
+                        probe = _make_contact_value_fast(score, 0, 0)
                     if reducer_data.ht_values[dir_i * ht_capacity + entry_idx] < probe:
                         might_win = True
 
@@ -929,7 +1157,10 @@ def export_and_reduce_contact_centered(
     if not might_win:
         voxel_entry_idx = hashtable_find_or_insert(voxel_key, reducer_data.ht_keys, reducer_data.ht_active_slots)
         if voxel_entry_idx >= 0:
-            voxel_probe = make_contact_value(-depth, 0)
+            if reducer_data.deterministic != 0:
+                voxel_probe = _make_preprune_probe_det(-depth, fingerprint)
+            else:
+                voxel_probe = _make_contact_value_fast(-depth, 0, 0)
             if reducer_data.ht_values[voxel_local_slot * ht_capacity + voxel_entry_idx] < voxel_probe:
                 might_win = True
 
@@ -937,20 +1168,20 @@ def export_and_reduce_contact_centered(
         return -1
 
     # === Allocate buffer slot (only for contacts that might win) ===
-    contact_id = export_contact_to_buffer(shape_a, shape_b, position, normal, depth, reducer_data)
+    contact_id = export_contact_to_buffer(shape_a, shape_b, position, normal, depth, fingerprint, reducer_data)
     if contact_id < 0:
         return -1
 
-    # === Register in hashtable with real contact_id ===
+    # === Register in hashtable with fingerprint for deterministic tiebreaking ===
     if entry_idx >= 0:
         for dir_i in range(wp.static(NUM_SPATIAL_DIRECTIONS)):
             if use_beta:
                 dir_2d = get_spatial_direction_2d(dir_i)
                 score = wp.dot(pos_2d, dir_2d)
-                value = make_contact_value(score, contact_id)
+                value = make_contact_value(score, fingerprint, contact_id, reducer_data.deterministic)
                 reduction_update_slot(entry_idx, dir_i, value, reducer_data.ht_values, ht_capacity)
 
-        max_depth_value = make_contact_value(-depth, contact_id)
+        max_depth_value = make_contact_value(-depth, fingerprint, contact_id, reducer_data.deterministic)
         reduction_update_slot(
             entry_idx, wp.static(NUM_SPATIAL_DIRECTIONS), max_depth_value, reducer_data.ht_values, ht_capacity
         )
@@ -961,7 +1192,7 @@ def export_and_reduce_contact_centered(
     if voxel_entry_idx < 0:
         voxel_entry_idx = hashtable_find_or_insert(voxel_key, reducer_data.ht_keys, reducer_data.ht_active_slots)
     if voxel_entry_idx >= 0:
-        voxel_value = make_contact_value(-depth, contact_id)
+        voxel_value = make_contact_value(-depth, fingerprint, contact_id, reducer_data.deterministic)
         reduction_update_slot(voxel_entry_idx, voxel_local_slot, voxel_value, reducer_data.ht_values, ht_capacity)
     else:
         wp.atomic_add(reducer_data.ht_insert_failures, 0, 1)
@@ -1075,6 +1306,7 @@ def write_contact_to_reducer(
         position=position,
         normal=normal,
         depth=depth,
+        fingerprint=contact_data.sort_sub_key,
         reducer_data=reducer_data,
     )
 
@@ -1101,7 +1333,9 @@ def create_export_reduced_contacts_kernel(writer_func: Any):
     # Define vector type for tracking exported contact IDs
     exported_ids_vec = wp.types.vector(length=VALUES_PER_KEY, dtype=wp.int32)
 
-    @wp.kernel(enable_backward=False, module="unique")
+    _module = f"export_reduced_contacts_{writer_func.__name__}"
+
+    @wp.kernel(enable_backward=False, module=_module)
     def export_reduced_contacts_kernel(
         # Hashtable arrays
         ht_keys: wp.array[wp.uint64],
@@ -1111,6 +1345,7 @@ def export_reduced_contacts_kernel(
         position_depth: wp.array[wp.vec4],
         normal: wp.array[wp.vec2],  # Octahedral-encoded
         shape_pairs: wp.array[wp.vec2i],
+        contact_fingerprints: wp.array[wp.int32],
         # Global dedup flags: one int per buffer contact, for cross-entry deduplication
         exported_flags: wp.array[wp.int32],
         # Shape data for extracting margin and effective radius
@@ -1122,6 +1357,8 @@ def export_reduced_contacts_kernel(
         writer_data: Any,
         # Grid stride parameters
         total_num_threads: int,
+        # Packing mode (non-zero = deterministic 20-bit contact IDs)
+        deterministic: int,
     ):
         """Export reduced contacts to the writer.
 
@@ -1157,8 +1394,8 @@ def export_reduced_contacts_kernel(
                 if value == wp.uint64(0):
                     continue
 
-                # Extract contact ID from low 32 bits
-                contact_id = unpack_contact_id(value)
+                # Extract contact ID
+                contact_id = unpack_contact_id(value, deterministic)
 
                 # Skip if already exported within this entry
                 if is_contact_already_exported(contact_id, exported_ids, num_exported):
@@ -1207,6 +1444,7 @@ def export_reduced_contacts_kernel(
                 contact_data.shape_a = shape_a
                 contact_data.shape_b = shape_b
                 contact_data.gap_sum = gap_sum
+                contact_data.sort_sub_key = contact_fingerprints[contact_id]
 
                 # Call the writer function
                 writer_func(contact_data, writer_data, -1)
@@ -1334,6 +1572,7 @@ def mesh_triangle_contacts_to_reducer_kernel(
                 margin_offset_a,
                 margin_offset_b,
                 reducer_data,
+                (tri_idx << 1) | 1,
             )
 
     return mesh_triangle_contacts_to_reducer_kernel
diff --git a/newton/_src/geometry/contact_reduction_hydroelastic.py b/newton/_src/geometry/contact_reduction_hydroelastic.py
index 982307c90d..beb8a69546 100644
--- a/newton/_src/geometry/contact_reduction_hydroelastic.py
+++ b/newton/_src/geometry/contact_reduction_hydroelastic.py
@@ -47,13 +47,13 @@
     VALUES_PER_KEY,
     GlobalContactReducer,
     GlobalContactReducerData,
+    _make_contact_value_fast,
+    _unpack_contact_id_fast,
     decode_oct,
     export_contact_to_buffer,
     is_contact_already_exported,
     make_contact_key,
-    make_contact_value,
     reduction_update_slot,
-    unpack_contact_id,
 )
 
 # =============================================================================
@@ -137,8 +137,8 @@ def export_hydroelastic_contact_to_buffer(
     Returns:
         Contact ID if successfully stored, -1 if buffer full
     """
-    # Use base function to store common contact data
-    contact_id = export_contact_to_buffer(shape_a, shape_b, position, normal, depth, reducer_data)
+    # Use base function to store common contact data (fingerprint=0: hydroelastic excluded from determinism)
+    contact_id = export_contact_to_buffer(shape_a, shape_b, position, normal, depth, 0, reducer_data)
 
     if contact_id >= 0:
         # Store hydroelastic-specific data (k_eff is stored per entry, not per contact)
@@ -223,10 +223,10 @@ def reduce_hydroelastic_contacts_kernel(
                     for dir_i in range(wp.static(NUM_SPATIAL_DIRECTIONS)):
                         dir_2d = get_spatial_direction_2d(dir_i)
                         score = wp.dot(pos_2d_centered, dir_2d) * pen_weight
-                        value = make_contact_value(score, i)
+                        value = _make_contact_value_fast(score, 0, i)
                         reduction_update_slot(entry_idx, dir_i, value, reducer_data.ht_values, ht_capacity)
 
-                max_depth_value = make_contact_value(-depth, i)
+                max_depth_value = _make_contact_value_fast(-depth, 0, i)
                 reduction_update_slot(
                     entry_idx,
                     wp.static(NUM_SPATIAL_DIRECTIONS),
@@ -263,7 +263,7 @@ def reduce_hydroelastic_contacts_kernel(
                 reducer_data.entry_k_eff[voxel_entry_idx] = _effective_stiffness(
                     shape_material_k_hydro[shape_a], shape_material_k_hydro[shape_b]
                 )
-                voxel_value = make_contact_value(-depth, i)
+                voxel_value = _make_contact_value_fast(-depth, 0, i)
                 reduction_update_slot(
                     voxel_entry_idx,
                     voxel_local_slot,
@@ -330,7 +330,7 @@ def accumulate_reduced_depth_kernel(
                 value = ht_values[slot * ht_capacity + entry_idx]
                 if value == wp.uint64(0):
                     continue
-                contact_id = unpack_contact_id(value)
+                contact_id = _unpack_contact_id_fast(value)
                 if is_contact_already_exported(contact_id, p1_ids, p1_count):
                     continue
                 p1_ids[p1_count] = contact_id
@@ -402,7 +402,7 @@ def accumulate_moments_kernel(
                 value = ht_values[slot * ht_capacity + entry_idx]
                 if value == wp.uint64(0):
                     continue
-                contact_id = unpack_contact_id(value)
+                contact_id = _unpack_contact_id_fast(value)
                 if is_contact_already_exported(contact_id, p2_ids, p2_count):
                     continue
                 p2_ids[p2_count] = contact_id
@@ -565,7 +565,7 @@ def export_hydroelastic_reduced_contacts_kernel(
                     continue
 
                 # Extract contact ID from low 32 bits
-                contact_id = unpack_contact_id(value)
+                contact_id = _unpack_contact_id_fast(value)
 
                 # Skip if already exported
                 if is_contact_already_exported(contact_id, exported_ids, num_exported):
@@ -762,7 +762,7 @@ def export_hydroelastic_reduced_contacts_kernel(
                                 wp.static(NUM_SPATIAL_DIRECTIONS) * ht_capacity + nbin_entry_idx
                             ]
                             if nbin_max_depth_value != wp.uint64(0):
-                                nbin_max_depth_contact_id = unpack_contact_id(nbin_max_depth_value)
+                                nbin_max_depth_contact_id = _unpack_contact_id_fast(nbin_max_depth_value)
                                 nbin_max_depth = position_depth[nbin_max_depth_contact_id][3]
                                 if nbin_max_depth < 0.0:
                                     nbin_anchor_depth = -nbin_max_depth
diff --git a/newton/_src/geometry/contact_sort.py b/newton/_src/geometry/contact_sort.py
new file mode 100644
index 0000000000..5e2135c86d
--- /dev/null
+++ b/newton/_src/geometry/contact_sort.py
@@ -0,0 +1,376 @@
+# SPDX-FileCopyrightText: Copyright (c) 2026 The Newton Developers
+# SPDX-License-Identifier: Apache-2.0
+
+"""Deterministic contact sorting via radix sort on per-contact keys.
+
+Provides the machinery to reorder contact arrays into a canonical,
+deterministic order after the narrow-phase collision pipeline has
+written contacts in GPU-scheduling-dependent order.
+
+The sort always operates over the full pre-allocated buffer (for CUDA
+graph capture compatibility).  Unused slots beyond ``contact_count``
+are filled with ``0x7FFFFFFFFFFFFFFF`` so they sort to the end.
+"""
+
+from __future__ import annotations
+
+import warp as wp
+
+from ..core.types import Devicelike
+
+# Sentinel key for unused contact slots.  ``radix_sort_pairs`` treats
+# keys as signed int64, so ``0x7FFF…`` (max positive int64) sorts last.
+SORT_KEY_SENTINEL = wp.constant(wp.int64(0x7FFFFFFFFFFFFFFF))
+
+
+@wp.kernel(enable_backward=False)
+def _prepare_sort(
+    contact_count: wp.array[int],
+    sort_keys_src: wp.array[wp.int64],
+    sort_keys_dst: wp.array[wp.int64],
+    sort_indices: wp.array[wp.int32],
+):
+    """Copy active keys and init identity indices; fill unused slots with sentinel."""
+    tid = wp.tid()
+    if tid < contact_count[0]:
+        sort_keys_dst[tid] = sort_keys_src[tid]
+        sort_indices[tid] = wp.int32(tid)
+    else:
+        sort_keys_dst[tid] = SORT_KEY_SENTINEL
+        sort_indices[tid] = wp.int32(tid)
+
+
+# -----------------------------------------------------------------------
+# Structs + fused backup/gather kernels for the two contact layouts.
+#
+# Each layout has ONE struct holding both the live arrays and their
+# scratch-buffer counterparts, plus two kernels:
+#   _backup_*  — copies only active contacts into the scratch buffers
+#   _gather_*  — permuted write-back from scratch into the live arrays
+# This replaces the previous N x wp.copy + N x kernel-launch pattern
+# with 2 kernel launches total (backup + gather) regardless of how
+# many arrays are being sorted.
+# -----------------------------------------------------------------------
+
+
+@wp.struct
+class _SimpleContactArrays:
+    """Live + scratch arrays for the simplified narrow-phase contact layout."""
+
+    pair: wp.array[wp.vec2i]
+    position: wp.array[wp.vec3]
+    normal: wp.array[wp.vec3]
+    penetration: wp.array[float]
+    tangent: wp.array[wp.vec3]
+    pair_buf: wp.array[wp.vec2i]
+    position_buf: wp.array[wp.vec3]
+    normal_buf: wp.array[wp.vec3]
+    penetration_buf: wp.array[float]
+    tangent_buf: wp.array[wp.vec3]
+    has_tangent: int
+
+
+@wp.kernel(enable_backward=False)
+def _backup_simple_kernel(data: _SimpleContactArrays, count: wp.array[int]):
+    """Copy active contacts into scratch buffers."""
+    i = wp.tid()
+    if i >= count[0]:
+        return
+    data.pair_buf[i] = data.pair[i]
+    data.position_buf[i] = data.position[i]
+    data.normal_buf[i] = data.normal[i]
+    data.penetration_buf[i] = data.penetration[i]
+    if data.has_tangent != 0:
+        data.tangent_buf[i] = data.tangent[i]
+
+
+@wp.kernel(enable_backward=False)
+def _gather_simple_kernel(data: _SimpleContactArrays, perm: wp.array[wp.int32], count: wp.array[int]):
+    """Permuted write-back from scratch into live arrays."""
+    i = wp.tid()
+    if i >= count[0]:
+        return
+    p = perm[i]
+    data.pair[i] = data.pair_buf[p]
+    data.position[i] = data.position_buf[p]
+    data.normal[i] = data.normal_buf[p]
+    data.penetration[i] = data.penetration_buf[p]
+    if data.has_tangent != 0:
+        data.tangent[i] = data.tangent_buf[p]
+
+
+@wp.struct
+class _FullContactArrays:
+    """Live + scratch arrays for the full CollisionPipeline contact layout."""
+
+    shape0: wp.array[wp.int32]
+    shape1: wp.array[wp.int32]
+    point0: wp.array[wp.vec3]
+    point1: wp.array[wp.vec3]
+    offset0: wp.array[wp.vec3]
+    offset1: wp.array[wp.vec3]
+    normal: wp.array[wp.vec3]
+    margin0: wp.array[float]
+    margin1: wp.array[float]
+    tids: wp.array[wp.int32]
+    stiffness: wp.array[float]
+    damping: wp.array[float]
+    friction: wp.array[float]
+    shape0_buf: wp.array[wp.int32]
+    shape1_buf: wp.array[wp.int32]
+    point0_buf: wp.array[wp.vec3]
+    point1_buf: wp.array[wp.vec3]
+    offset0_buf: wp.array[wp.vec3]
+    offset1_buf: wp.array[wp.vec3]
+    normal_buf: wp.array[wp.vec3]
+    margin0_buf: wp.array[float]
+    margin1_buf: wp.array[float]
+    tids_buf: wp.array[wp.int32]
+    stiffness_buf: wp.array[float]
+    damping_buf: wp.array[float]
+    friction_buf: wp.array[float]
+    has_shape_props: int
+
+
+@wp.kernel(enable_backward=False)
+def _backup_full_kernel(data: _FullContactArrays, count: wp.array[int]):
+    """Copy active contacts into scratch buffers."""
+    i = wp.tid()
+    if i >= count[0]:
+        return
+    data.shape0_buf[i] = data.shape0[i]
+    data.shape1_buf[i] = data.shape1[i]
+    data.point0_buf[i] = data.point0[i]
+    data.point1_buf[i] = data.point1[i]
+    data.offset0_buf[i] = data.offset0[i]
+    data.offset1_buf[i] = data.offset1[i]
+    data.normal_buf[i] = data.normal[i]
+    data.margin0_buf[i] = data.margin0[i]
+    data.margin1_buf[i] = data.margin1[i]
+    data.tids_buf[i] = data.tids[i]
+    if data.has_shape_props != 0:
+        data.stiffness_buf[i] = data.stiffness[i]
+        data.damping_buf[i] = data.damping[i]
+        data.friction_buf[i] = data.friction[i]
+
+
+@wp.kernel(enable_backward=False)
+def _gather_full_kernel(data: _FullContactArrays, perm: wp.array[wp.int32], count: wp.array[int]):
+    """Permuted write-back from scratch into live arrays."""
+    i = wp.tid()
+    if i >= count[0]:
+        return
+    p = perm[i]
+    data.shape0[i] = data.shape0_buf[p]
+    data.shape1[i] = data.shape1_buf[p]
+    data.point0[i] = data.point0_buf[p]
+    data.point1[i] = data.point1_buf[p]
+    data.offset0[i] = data.offset0_buf[p]
+    data.offset1[i] = data.offset1_buf[p]
+    data.normal[i] = data.normal_buf[p]
+    data.margin0[i] = data.margin0_buf[p]
+    data.margin1[i] = data.margin1_buf[p]
+    data.tids[i] = data.tids_buf[p]
+    if data.has_shape_props != 0:
+        data.stiffness[i] = data.stiffness_buf[p]
+        data.damping[i] = data.damping_buf[p]
+        data.friction[i] = data.friction_buf[p]
+
+
+class ContactSorter:
+    """Sort contact arrays into a deterministic canonical order.
+
+    Pre-allocates double-buffer arrays and permutation indices at construction
+    time so that the per-frame :meth:`sort_simple` / :meth:`sort_full` calls
+    are allocation-free and fully CUDA-graph-capturable (no host synchronization).
+
+    The radix sort always runs over the full *capacity* buffer.  Slots beyond
+    the active ``contact_count`` are filled with a sentinel key
+    (``0x7FFFFFFFFFFFFFFF``) so they sort to the end and the gather kernels
+    skip them via the ``contact_count`` guard.
+    """
+
+    def __init__(self, capacity: int, *, per_contact_shape_properties: bool = False, device: Devicelike = None):
+        with wp.ScopedDevice(device):
+            self._capacity = capacity
+            # radix_sort_pairs uses the second half as scratch, so allocate 2x.
+            self._sort_indices = wp.zeros(2 * capacity, dtype=wp.int32)
+            self._sort_keys_copy = wp.zeros(2 * capacity, dtype=wp.int64)
+
+            self._has_shape_props = per_contact_shape_properties
+
+            # Scratch buffers for the simple gather (NarrowPhase.launch path).
+            self._simple_pair_buf = wp.zeros(capacity, dtype=wp.vec2i)
+            self._simple_position_buf = wp.zeros(capacity, dtype=wp.vec3)
+            self._simple_normal_buf = wp.zeros(capacity, dtype=wp.vec3)
+            self._simple_penetration_buf = wp.zeros(capacity, dtype=float)
+            self._simple_tangent_buf = wp.zeros(capacity, dtype=wp.vec3)
+
+            # Scratch buffers for the full gather (CollisionPipeline.collide path).
+            self._full_shape0_buf = wp.zeros(capacity, dtype=wp.int32)
+            self._full_shape1_buf = wp.zeros(capacity, dtype=wp.int32)
+            self._full_point0_buf = wp.zeros(capacity, dtype=wp.vec3)
+            self._full_point1_buf = wp.zeros(capacity, dtype=wp.vec3)
+            self._full_offset0_buf = wp.zeros(capacity, dtype=wp.vec3)
+            self._full_offset1_buf = wp.zeros(capacity, dtype=wp.vec3)
+            self._full_normal_buf = wp.zeros(capacity, dtype=wp.vec3)
+            self._full_margin0_buf = wp.zeros(capacity, dtype=float)
+            self._full_margin1_buf = wp.zeros(capacity, dtype=float)
+            self._full_tids_buf = wp.zeros(capacity, dtype=wp.int32)
+            if per_contact_shape_properties:
+                self._full_stiffness_buf = wp.zeros(capacity, dtype=float)
+                self._full_damping_buf = wp.zeros(capacity, dtype=float)
+                self._full_friction_buf = wp.zeros(capacity, dtype=float)
+            else:
+                self._full_stiffness_buf = wp.zeros(0, dtype=float)
+                self._full_damping_buf = wp.zeros(0, dtype=float)
+                self._full_friction_buf = wp.zeros(0, dtype=float)
+
+    # ------------------------------------------------------------------
+    # Public API
+    # ------------------------------------------------------------------
+
+    def sort_simple(
+        self,
+        sort_keys: wp.array,
+        contact_count: wp.array,
+        *,
+        contact_pair: wp.array,
+        contact_position: wp.array,
+        contact_normal: wp.array,
+        contact_penetration: wp.array,
+        contact_tangent: wp.array | None = None,
+        device: Devicelike = None,
+    ) -> None:
+        """Sort contacts written through the simplified narrow-phase writer.
+
+        Fully graph-capturable — no host synchronization.
+
+        Args:
+            sort_keys: Per-contact int64 sort keys (filled by the writer).
+            contact_count: Single-element int array with the active contact count.
+            contact_pair: vec2i shape pair array.
+            contact_position: vec3 contact positions.
+            contact_normal: vec3 contact normals.
+            contact_penetration: float penetration depths.
+            contact_tangent: Optional vec3 tangent array.
+            device: Device to launch on.
+        """
+        n = self._capacity
+        self._sort_and_permute(sort_keys, contact_count, device=device)
+
+        has_tangent = contact_tangent is not None and contact_tangent.shape[0] > 0
+
+        data = _SimpleContactArrays()
+        data.pair = contact_pair
+        data.position = contact_position
+        data.normal = contact_normal
+        data.penetration = contact_penetration
+        data.tangent = contact_tangent if has_tangent else self._simple_tangent_buf
+        data.pair_buf = self._simple_pair_buf
+        data.position_buf = self._simple_position_buf
+        data.normal_buf = self._simple_normal_buf
+        data.penetration_buf = self._simple_penetration_buf
+        data.tangent_buf = self._simple_tangent_buf
+        data.has_tangent = 1 if has_tangent else 0
+
+        wp.launch(_backup_simple_kernel, dim=n, inputs=[data, contact_count], device=device)
+        wp.launch(_gather_simple_kernel, dim=n, inputs=[data, self._sort_indices, contact_count], device=device)
+
+    def sort_full(
+        self,
+        sort_keys: wp.array,
+        contact_count: wp.array,
+        *,
+        shape0: wp.array,
+        shape1: wp.array,
+        point0: wp.array,
+        point1: wp.array,
+        offset0: wp.array,
+        offset1: wp.array,
+        normal: wp.array,
+        margin0: wp.array,
+        margin1: wp.array,
+        tids: wp.array,
+        stiffness: wp.array | None = None,
+        damping: wp.array | None = None,
+        friction: wp.array | None = None,
+        device: Devicelike = None,
+    ) -> None:
+        """Sort contacts written through the full collide.py writer.
+
+        Fully graph-capturable — no host synchronization.
+
+        Args:
+            sort_keys: Per-contact int64 sort keys (filled by the writer).
+            contact_count: Single-element int array with the active contact count.
+            shape0: int array of first shape indices.
+            shape1: int array of second shape indices.
+            point0: vec3 body-frame contact points on shape 0.
+            point1: vec3 body-frame contact points on shape 1.
+            offset0: vec3 body-frame friction anchor offsets for shape 0.
+            offset1: vec3 body-frame friction anchor offsets for shape 1.
+            normal: vec3 contact normals.
+            margin0: float surface thickness for shape 0.
+            margin1: float surface thickness for shape 1.
+            tids: int tid array.
+            stiffness: Optional float per-contact stiffness.
+            damping: Optional float per-contact damping.
+            friction: Optional float per-contact friction.
+            device: Device to launch on.
+        """
+        n = self._capacity
+        self._sort_and_permute(sort_keys, contact_count, device=device)
+
+        has_props = self._has_shape_props
+
+        data = _FullContactArrays()
+        data.shape0 = shape0
+        data.shape1 = shape1
+        data.point0 = point0
+        data.point1 = point1
+        data.offset0 = offset0
+        data.offset1 = offset1
+        data.normal = normal
+        data.margin0 = margin0
+        data.margin1 = margin1
+        data.tids = tids
+        data.stiffness = (
+            stiffness if has_props and stiffness is not None and stiffness.shape[0] > 0 else self._full_stiffness_buf
+        )
+        data.damping = damping if has_props and damping is not None and damping.shape[0] > 0 else self._full_damping_buf
+        data.friction = (
+            friction if has_props and friction is not None and friction.shape[0] > 0 else self._full_friction_buf
+        )
+        data.shape0_buf = self._full_shape0_buf
+        data.shape1_buf = self._full_shape1_buf
+        data.point0_buf = self._full_point0_buf
+        data.point1_buf = self._full_point1_buf
+        data.offset0_buf = self._full_offset0_buf
+        data.offset1_buf = self._full_offset1_buf
+        data.normal_buf = self._full_normal_buf
+        data.margin0_buf = self._full_margin0_buf
+        data.margin1_buf = self._full_margin1_buf
+        data.tids_buf = self._full_tids_buf
+        data.stiffness_buf = self._full_stiffness_buf
+        data.damping_buf = self._full_damping_buf
+        data.friction_buf = self._full_friction_buf
+        data.has_shape_props = 1 if has_props else 0
+
+        wp.launch(_backup_full_kernel, dim=n, inputs=[data, contact_count], device=device)
+        wp.launch(_gather_full_kernel, dim=n, inputs=[data, self._sort_indices, contact_count], device=device)
+
+    # ------------------------------------------------------------------
+    # Internal helpers
+    # ------------------------------------------------------------------
+
+    def _sort_and_permute(self, sort_keys: wp.array, contact_count: wp.array, *, device: Devicelike = None) -> None:
+        """Prepare keys (sentinel-fill unused slots), then radix-sort over the full buffer."""
+        n = self._capacity
+        wp.launch(
+            _prepare_sort,
+            dim=n,
+            inputs=[contact_count, sort_keys, self._sort_keys_copy, self._sort_indices],
+            device=device,
+        )
+        wp.utils.radix_sort_pairs(self._sort_keys_copy, self._sort_indices, n)
diff --git a/newton/_src/geometry/multicontact.py b/newton/_src/geometry/multicontact.py
index 35eb275873..8e1a5611e0 100644
--- a/newton/_src/geometry/multicontact.py
+++ b/newton/_src/geometry/multicontact.py
@@ -766,6 +766,7 @@ def extract_4_point_contact_manifolds(
                 contact_data.contact_point_center = contact_point_world
                 contact_data.contact_normal_a_to_b = normal_world
                 contact_data.contact_distance = signed_distance
+                contact_data.sort_sub_key = (contact_template.sort_sub_key << 3) | i
 
                 contact_data = post_process_contact(
                     contact_data, geom_a, position_a, quaternion_a, geom_b, position_b, quaternion_b
@@ -946,6 +947,7 @@ def build_manifold(
             contact_data.contact_point_center = deepest_center_world
             contact_data.contact_normal_a_to_b = normal_world
             contact_data.contact_distance = deepest_signed_distance
+            contact_data.sort_sub_key = (contact_template.sort_sub_key << 3) | count_out
 
             contact_data = post_process_contact(
                 contact_data, geom_a, position_a_ws, quaternion_a_ws, geom_b, position_b_ws, quaternion_b_ws
diff --git a/newton/_src/geometry/narrow_phase.py b/newton/_src/geometry/narrow_phase.py
index d577f05ac4..1575bb29e2 100644
--- a/newton/_src/geometry/narrow_phase.py
+++ b/newton/_src/geometry/narrow_phase.py
@@ -32,7 +32,7 @@
     collide_sphere_cylinder,
     collide_sphere_sphere,
 )
-from ..geometry.contact_data import SHAPE_PAIR_HFIELD_BIT, ContactData, contact_passes_gap_check
+from ..geometry.contact_data import SHAPE_PAIR_HFIELD_BIT, ContactData, contact_passes_gap_check, make_contact_sort_key
 from ..geometry.contact_reduction_global import (
     GlobalContactReducer,
     create_export_reduced_contacts_kernel,
@@ -40,6 +40,7 @@
     reduce_buffered_contacts_kernel,
     write_contact_to_reducer,
 )
+from ..geometry.contact_sort import ContactSorter
 from ..geometry.flags import ShapeFlags
 from ..geometry.sdf_contact import (
     compute_block_counts_from_weights,
@@ -71,6 +72,7 @@ class ContactWriterData:
     contact_normal: wp.array[wp.vec3]
     contact_penetration: wp.array[float]
     contact_tangent: wp.array[wp.vec3]
+    contact_sort_key: wp.array[wp.int64]
 
 
 @wp.func
@@ -125,6 +127,11 @@ def write_contact_simple(
             world_x = wp.vec3(0.0, 1.0, 0.0)
         writer_data.contact_tangent[index] = wp.normalize(world_x - wp.dot(world_x, normal) * normal)
 
+    if writer_data.contact_sort_key.shape[0] > 0:
+        writer_data.contact_sort_key[index] = make_contact_sort_key(
+            contact_data.shape_a, contact_data.shape_b, contact_data.sort_sub_key
+        )
+
 
 def create_narrow_phase_primitive_kernel(writer_func: Any, speculative: bool = False):
     """
@@ -143,8 +150,9 @@ def create_narrow_phase_primitive_kernel(writer_func: Any, speculative: bool = F
     Returns:
         A warp kernel for primitive collision detection
     """
+    _module = f"narrow_phase_primitive_{writer_func.__name__}"
 
-    @wp.kernel(enable_backward=False, module="unique")
+    @wp.kernel(enable_backward=False, module=_module)
     def narrow_phase_primitive_kernel(
         candidate_pair: wp.array[wp.vec2i],
         candidate_pair_count: wp.array[int],
@@ -585,6 +593,7 @@ def narrow_phase_primitive_kernel(
                     if contact_0_valid:
                         contact_data.contact_point_center = contact_pos_0
                         contact_data.contact_distance = contact_dist_0
+                        contact_data.sort_sub_key = 0
                         writer_func(contact_data, writer_data, base_index)
                         base_index += 1
 
@@ -592,6 +601,7 @@ def narrow_phase_primitive_kernel(
                     if contact_1_valid:
                         contact_data.contact_point_center = contact_pos_1
                         contact_data.contact_distance = contact_dist_1
+                        contact_data.sort_sub_key = 1
                         writer_func(contact_data, writer_data, base_index)
                         base_index += 1
 
@@ -599,6 +609,7 @@ def narrow_phase_primitive_kernel(
                     if contact_2_valid:
                         contact_data.contact_point_center = contact_pos_2
                         contact_data.contact_distance = contact_dist_2
+                        contact_data.sort_sub_key = 2
                         writer_func(contact_data, writer_data, base_index)
                         base_index += 1
 
@@ -606,6 +617,7 @@ def narrow_phase_primitive_kernel(
                     if contact_3_valid:
                         contact_data.contact_point_center = contact_pos_3
                         contact_data.contact_distance = contact_dist_3
+                        contact_data.sort_sub_key = 3
                         writer_func(contact_data, writer_data, base_index)
 
                 continue
@@ -643,8 +655,11 @@ def create_narrow_phase_kernel_gjk_mpr(
         speculative: When True, extends ``gap_sum`` by a scalar speculative
             margin derived from per-shape velocity arrays.
     """
+    _sf = support_func.__name__ if support_func is not None else "default"
+    _ppc = post_process_contact.__name__ if post_process_contact is not None else "default"
+    _module = f"narrow_phase_gjk_mpr_{external_aabb}_{writer_func.__name__}_{_sf}_{_ppc}"
 
-    @wp.kernel(enable_backward=False, module="unique")
+    @wp.kernel(enable_backward=False, module=_module)
     def narrow_phase_kernel_gjk_mpr(
         candidate_pair: wp.array[wp.vec2i],
         candidate_pair_count: wp.array[int],
@@ -941,7 +956,9 @@ def narrow_phase_find_mesh_triangle_overlaps_kernel(
 
 
 def create_narrow_phase_process_mesh_triangle_contacts_kernel(writer_func: Any, speculative: bool = False):
-    @wp.kernel(enable_backward=False, module="unique")
+    _module = f"narrow_phase_mesh_tri_{writer_func.__name__}"
+
+    @wp.kernel(enable_backward=False, module=_module)
     def narrow_phase_process_mesh_triangle_contacts_kernel(
         shape_types: wp.array[int],
         shape_data: wp.array[wp.vec4],
@@ -1049,6 +1066,7 @@ def narrow_phase_process_mesh_triangle_contacts_kernel(
                 margin_offset_a,
                 margin_offset_b,
                 writer_data,
+                (tri_idx << 1) | 1,
             )
 
     return narrow_phase_process_mesh_triangle_contacts_kernel
@@ -1144,8 +1162,9 @@ def create_narrow_phase_process_mesh_plane_contacts_kernel(
     Returns:
         A warp kernel that processes mesh-plane collisions
     """
+    _module = f"narrow_phase_mesh_plane_{writer_func.__name__}_{reduce_contacts}"
 
-    @wp.kernel(enable_backward=False, module="unique")
+    @wp.kernel(enable_backward=False, module=_module)
     def narrow_phase_process_mesh_plane_contacts_kernel(
         shape_data: wp.array[wp.vec4],
         shape_transform: wp.array[wp.transform],
@@ -1253,6 +1272,7 @@ def narrow_phase_process_mesh_plane_contacts_kernel(
                     contact_data.shape_a = mesh_shape
                     contact_data.shape_b = plane_shape
                     contact_data.gap_sum = gap_sum
+                    contact_data.sort_sub_key = vertex_idx
 
                     if writer_data.contact_count[0] < writer_data.contact_max:
                         writer_func(contact_data, writer_data, -1)
@@ -1261,7 +1281,7 @@ def narrow_phase_process_mesh_plane_contacts_kernel(
     if not reduce_contacts:
         return narrow_phase_process_mesh_plane_contacts_kernel
 
-    @wp.kernel(enable_backward=False, module="unique")
+    @wp.kernel(enable_backward=False, module=_module)
     def narrow_phase_process_mesh_plane_contacts_reduce_kernel(
         shape_data: wp.array[wp.vec4],
         shape_transform: wp.array[wp.transform],
@@ -1399,6 +1419,7 @@ def narrow_phase_process_mesh_plane_contacts_reduce_kernel(
                         contact_data.shape_a = mesh_shape
                         contact_data.shape_b = plane_shape
                         contact_data.gap_sum = gap_sum
+                        contact_data.sort_sub_key = vertex_idx
 
                         writer_func(contact_data, writer_data, -1)
 
@@ -1511,6 +1532,8 @@ def __init__(
         has_heightfields: bool = False,
         use_lean_gjk_mpr: bool = False,
         speculative: bool = False,
+        deterministic: bool = False,
+        contact_max: int | None = None,
     ) -> None:
         """
         Initialize NarrowPhase with pre-allocated buffers.
@@ -1538,6 +1561,14 @@ def __init__(
                 When True, kernel variants that read per-shape velocity arrays and
                 extend gap thresholds are compiled. When False (default), the
                 speculative code paths are eliminated at compile time.
+            deterministic: Sort contacts after the narrow phase so that results are
+                independent of GPU thread scheduling.  Adds a radix sort + gather
+                pass.  Hydroelastic contacts are not yet covered.
+            contact_max: Maximum number of contacts for the deterministic sort buffer.
+                Must match the ``contact_pair`` array size passed to :meth:`launch`.
+                Defaults to ``max_candidate_pairs``.  Set this to a larger value when
+                a single candidate pair can emit multiple contacts (e.g. up to 4 for
+                primitive multi-contact paths).
         """
         self.max_candidate_pairs = max_candidate_pairs
         self.max_triangle_pairs = max_triangle_pairs
@@ -1545,6 +1576,7 @@ def __init__(
         self.reduce_contacts = reduce_contacts
         self.has_meshes = has_meshes
         self.has_heightfields = has_heightfields
+        self.deterministic = deterministic
 
         # Warn when running on CPU with meshes: mesh-mesh SDF contacts require CUDA
         is_gpu_device = wp.get_device(device).is_cuda
@@ -1663,7 +1695,9 @@ def __init__(
                 speculative=speculative
             )
             # Global contact reducer for all mesh contact types
-            self.global_contact_reducer = GlobalContactReducer(max_triangle_pairs, device=device)
+            self.global_contact_reducer = GlobalContactReducer(
+                max_triangle_pairs, device=device, deterministic=deterministic
+            )
         else:
             self.export_reduced_contacts_kernel = None
             self.mesh_triangle_to_reducer_kernel = None
@@ -1715,6 +1749,14 @@ def __init__(
             )
 
             self.empty_tangent = None
+            self._empty_sort_key = wp.zeros(0, dtype=wp.int64, device=device)
+            det_capacity = contact_max if contact_max is not None else max_candidate_pairs
+            if deterministic:
+                self._sort_key_array = wp.zeros(det_capacity, dtype=wp.int64, device=device)
+                self._contact_sorter = ContactSorter(det_capacity, device=device)
+            else:
+                self._sort_key_array = wp.zeros(0, dtype=wp.int64, device=device)
+                self._contact_sorter = None
             # Sentinel edge buffers used when no edge data is provided.
             # _empty_edge_range is indexed by shape id, so it must have one
             # slot per shape (not per candidate pair).
@@ -2200,12 +2242,14 @@ def launch_custom_write(
                         self.global_contact_reducer.position_depth,
                         self.global_contact_reducer.normal,
                         self.global_contact_reducer.shape_pairs,
+                        self.global_contact_reducer.contact_fingerprints,
                         self.global_contact_reducer.exported_flags,
                         shape_types,
                         shape_data,
                         shape_gap,
                         writer_data,
                         self.total_num_threads,
+                        int(self.global_contact_reducer.deterministic),
                     ],
                     device=device,
                     block_dim=self.block_dim,
@@ -2343,7 +2387,20 @@ def launch(
         # Clear external contact count (internal counters are cleared in launch_custom_write)
         contact_count.zero_()
 
+        # Verify sort-key buffer and sorter match the contact output capacity.
+        # Raising instead of silently reallocating keeps this path
+        # CUDA-graph-capturable and consistent with CollisionPipeline.collide().
+        if self.deterministic and self._sort_key_array.shape[0] != contact_max:
+            raise ValueError(
+                f"Contact output capacity ({contact_max}) does not match the "
+                f"deterministic sort buffer size ({self._sort_key_array.shape[0]}). "
+                f"The sorter operates over fixed-capacity buffers for CUDA graph capture "
+                f"compatibility, so the sizes must match exactly."
+            )
+
         # Create ContactWriterData struct
+        sort_key_arr = self._sort_key_array if self.deterministic else self._empty_sort_key
+
         writer_data = ContactWriterData()
         writer_data.contact_max = contact_max
         writer_data.contact_count = contact_count
@@ -2352,6 +2409,7 @@ def launch(
         writer_data.contact_normal = contact_normal
         writer_data.contact_penetration = contact_penetration
         writer_data.contact_tangent = contact_tangent
+        writer_data.contact_sort_key = sort_key_arr
 
         # Delegate to launch_custom_write
         self.launch_custom_write(
@@ -2374,3 +2432,15 @@ def launch(
             writer_data=writer_data,
             device=device,
         )
+
+        if self.deterministic:
+            self._contact_sorter.sort_simple(
+                sort_key_arr,
+                contact_count,
+                contact_pair=contact_pair,
+                contact_position=contact_position,
+                contact_normal=contact_normal,
+                contact_penetration=contact_penetration,
+                contact_tangent=contact_tangent,
+                device=device,
+            )
diff --git a/newton/_src/geometry/raycast.py b/newton/_src/geometry/raycast.py
index 7ed0f1b96c..6a11a61771 100644
--- a/newton/_src/geometry/raycast.py
+++ b/newton/_src/geometry/raycast.py
@@ -11,6 +11,8 @@
 
 # A small constant to avoid division by zero and other numerical issues
 MINVAL = 1e-15
+# Tolerance for near-parallel ray rejection (e.g. ray vs plane)
+PARALLEL_TOL = 1e-6
 
 
 @wp.func
@@ -516,6 +518,51 @@ def ray_intersect_mesh(
     return t_hit
 
 
+@wp.func
+def ray_intersect_plane(geom_to_world: wp.transform, ray_origin: wp.vec3, ray_direction: wp.vec3, size: wp.vec3):
+    """Computes ray-plane intersection.
+
+    The plane lies at z = 0 in local space with normal along +Z.  ``size`` holds ``(width, length, 0)``:
+    the full extents along local X and Y.  A value of ``0`` means infinite in that axis.  The plane is double-sided:
+    rays approaching from either side register intersections.
+
+    Args:
+        geom_to_world: The world transform of the plane.
+        ray_origin: The origin of the ray in world space.
+        ray_direction: The direction of the ray in world space.
+        size: ``(width, length, 0)`` -- full extents; ``0`` = infinite.
+
+    Returns:
+        The distance along the ray to the intersection point, or -1.0 if there is no intersection.
+    """
+    # transform ray to local frame
+    world_to_geom = wp.transform_inverse(geom_to_world)
+    ro = wp.transform_point(world_to_geom, ray_origin)
+    rd = wp.transform_vector(world_to_geom, ray_direction)
+
+    # Ray parallel to the plane (or degenerate)
+    if wp.abs(rd[2]) < PARALLEL_TOL:
+        return -1.0
+
+    # t where the ray crosses z = 0
+    t = -ro[2] / rd[2]
+    if t < 0.0:
+        return -1.0
+
+    hit_x = ro[0] + t * rd[0]
+    hit_y = ro[1] + t * rd[1]
+
+    half_w = size[0] * 0.5
+    half_l = size[1] * 0.5
+
+    if half_w > 0.0 and wp.abs(hit_x) > half_w:
+        return -1.0
+    if half_l > 0.0 and wp.abs(hit_y) > half_l:
+        return -1.0
+
+    return t
+
+
 @wp.func
 def ray_intersect_geom(
     geom_to_world: wp.transform,
@@ -529,7 +576,7 @@ def ray_intersect_geom(
     Computes the intersection of a ray with a geometry.
 
     Args:
-        geom_to_world: The world-to-shape transform.
+        geom_to_world: The world transform of the shape.
         size: The size of the geometry.
         geomtype: The type of the geometry.
         ray_origin: The origin of the ray.
@@ -541,7 +588,10 @@ def ray_intersect_geom(
     """
     t_hit = -1.0
 
-    if geomtype == GeoType.SPHERE:
+    if geomtype == GeoType.PLANE:
+        t_hit = ray_intersect_plane(geom_to_world, ray_origin, ray_direction, size)
+
+    elif geomtype == GeoType.SPHERE:
         r = size[0]
         t_hit = ray_intersect_sphere(geom_to_world, ray_origin, ray_direction, r)
 
diff --git a/newton/_src/geometry/sdf_contact.py b/newton/_src/geometry/sdf_contact.py
index b78f9c7c49..825206e836 100644
--- a/newton/_src/geometry/sdf_contact.py
+++ b/newton/_src/geometry/sdf_contact.py
@@ -1027,7 +1027,16 @@ def create_narrow_phase_process_mesh_mesh_contacts_kernel(
 ):
     find_interesting_edges, do_edge_sdf_collision = _create_sdf_contact_funcs(enable_heightfields)
 
-    @wp.kernel(enable_backward=False, module="unique")
+    # Derive a stable module name from the factory arguments so that
+    # identical configurations share the compiled CUDA kernel.  This is
+    # critical for deterministic contact generation: two CollisionPipeline
+    # instances with the same writer_func must execute the exact same
+    # compiled code, otherwise FMA-fusion or register-allocation
+    # differences between independent JIT compilations can produce subtly
+    # different floating-point results, breaking bit-exact reproducibility.
+    _module = f"sdf_contact_{writer_func.__name__}_{enable_heightfields}_{reduce_contacts}"
+
+    @wp.kernel(enable_backward=False, module=_module)
     def mesh_sdf_collision_kernel(
         shape_data: wp.array[wp.vec4],
         shape_transform: wp.array[wp.transform],
@@ -1303,6 +1312,7 @@ def mesh_sdf_collision_kernel(
                             contact_data.shape_a = pair[0]
                             contact_data.shape_b = pair[1]
                             contact_data.gap_sum = gap_sum
+                            contact_data.sort_sub_key = (edge_idx << 2) | (mode << 1)
 
                             writer_func(contact_data, writer_data, -1)
 
@@ -1321,7 +1331,7 @@ def mesh_sdf_collision_kernel(
     # but contacts are written directly to global buffer + hashtable.
     # =========================================================================
 
-    @wp.kernel(enable_backward=False, module="unique")
+    @wp.kernel(enable_backward=False, module=_module)
     def mesh_sdf_collision_global_reduce_kernel(
         shape_data: wp.array[wp.vec4],
         shape_transform: wp.array[wp.transform],
@@ -1617,6 +1627,7 @@ def mesh_sdf_collision_global_reduce_kernel(
                                 point_world,
                                 contact_normal,
                                 dist,
+                                (edge_idx << 2) | (mode << 1),
                                 point_world - midpoint,
                                 X_ws_tri,
                                 aabb_lower_tri,
diff --git a/newton/_src/geometry/sdf_hydroelastic.py b/newton/_src/geometry/sdf_hydroelastic.py
index 80700eae4c..386ed1b52e 100644
--- a/newton/_src/geometry/sdf_hydroelastic.py
+++ b/newton/_src/geometry/sdf_hydroelastic.py
@@ -658,13 +658,14 @@ def _broadphase_sdfs(
 
         wp.launch(
             kernel=broadphase_collision_pairs_scatter,
-            dim=[self.max_num_shape_pairs],
+            dim=[self.grid_size],
             inputs=[
-                self.num_blocks_per_pair,
-                shape_sdf_data,
+                self.grid_size,
+                self.block_broad_collide_count,
                 self.block_start_prefix,
                 shape_pairs_sdf_sdf,
                 shape_pairs_sdf_sdf_count,
+                shape_sdf_data,
                 self.shape_sdf_shape2blocks,
                 self.max_num_blocks_broad,
             ],
@@ -928,51 +929,52 @@ def broadphase_collision_pairs_count(
 
 @wp.kernel(enable_backward=False)
 def broadphase_collision_pairs_scatter(
-    thread_num_blocks: wp.array[wp.int32],
-    shape_sdf_data: wp.array[TextureSDFData],
+    grid_size: int,
+    block_broad_collide_count: wp.array[wp.int32],
     block_start_prefix: wp.array[wp.int32],
     shape_pairs_sdf_sdf: wp.array[wp.vec2i],
     shape_pairs_sdf_sdf_count: wp.array[wp.int32],
+    shape_sdf_data: wp.array[TextureSDFData],
     shape2blocks: wp.array[wp.vec2i],
     max_num_blocks_broad: int,
     # outputs
     block_broad_collide_shape_pair: wp.array[wp.vec2i],
     block_broad_idx: wp.array[wp.int32],
 ):
-    tid = wp.tid()
-    if tid >= shape_pairs_sdf_sdf_count[0]:
-        return
-
-    num_blocks = thread_num_blocks[tid]
-    if num_blocks == 0:
+    offset = wp.tid()
+    total_blocks = wp.min(block_broad_collide_count[0], max_num_blocks_broad)
+    pair_count = wp.min(shape_pairs_sdf_sdf_count[0], block_start_prefix.shape[0])
+    if pair_count == 0:
         return
 
-    pair = shape_pairs_sdf_sdf[tid]
-    shape_a = pair[0]
-    shape_b = pair[1]
-
-    # sort shapes such that the shape with the smaller voxel size is in second place
-    # NOTE: Confirm that this is OK to do for downstream code
-    voxel_radius_a = shape_sdf_data[shape_a].voxel_radius
-    voxel_radius_b = shape_sdf_data[shape_b].voxel_radius
-
-    if voxel_radius_b > voxel_radius_a:
-        shape_b, shape_a = shape_a, shape_b
+    for block_tid in range(offset, total_blocks, grid_size):
+        # Binary search: find rightmost pair_idx where prefix[pair_idx] <= block_tid
+        lo = int(0)
+        hi = int(pair_count - 1)
+        while lo < hi:
+            mid = (lo + hi + 1) // 2
+            if block_start_prefix[mid] <= block_tid:
+                lo = mid
+            else:
+                hi = mid - 1
+        pair_idx = lo
 
-    shape_b_idx = shape2blocks[shape_b]
-    shape_b_block_start = shape_b_idx[0]
+        pair = shape_pairs_sdf_sdf[pair_idx]
+        shape_a = pair[0]
+        shape_b = pair[1]
 
-    block_start = block_start_prefix[tid]
+        # Sort shapes so the one with smaller voxel size is shape_b
+        voxel_radius_a = shape_sdf_data[shape_a].voxel_radius
+        voxel_radius_b = shape_sdf_data[shape_b].voxel_radius
+        if voxel_radius_b > voxel_radius_a:
+            shape_b, shape_a = shape_a, shape_b
 
-    remaining = max_num_blocks_broad - block_start
-    if remaining <= 0:
-        return
-    num_blocks = wp.min(num_blocks, remaining)
+        shape_b_idx = shape2blocks[shape_b]
+        shape_b_block_start = shape_b_idx[0]
+        block_in_pair = block_tid - block_start_prefix[pair_idx]
 
-    pair = wp.vec2i(shape_a, shape_b)
-    for i in range(num_blocks):
-        block_broad_collide_shape_pair[block_start + i] = pair
-        block_broad_idx[block_start + i] = shape_b_block_start + i
+        block_broad_collide_shape_pair[block_tid] = wp.vec2i(shape_a, shape_b)
+        block_broad_idx[block_tid] = shape_b_block_start + block_in_pair
 
 
 @wp.kernel(enable_backward=False)
diff --git a/newton/_src/geometry/support_function.py b/newton/_src/geometry/support_function.py
index 5cda694e32..8c97ec5dc8 100644
--- a/newton/_src/geometry/support_function.py
+++ b/newton/_src/geometry/support_function.py
@@ -33,6 +33,11 @@
 
 from .types import GeoType
 
+# Relative deadband factor for box support-map sign decisions.
+# Near-zero direction components (e.g. from quaternion rotation noise ~1e-14)
+# are treated as non-negative, biasing toward the +1 vertex.
+BOX_SUPPORT_DEADBAND = 1.0e-10
+
 
 # Is not allowed to share values with GeoType
 class GeoTypeEx(enum.IntEnum):
@@ -168,9 +173,16 @@ def support_map(geom: GenericShapeData, direction: wp.vec3, data_provider: Suppo
             if direction[2] < 0.0:
                 result = result + wp.vec3(0.0, 0.0, -1.0)
     elif geom.shape_type == GeoType.BOX:
-        sx = 1.0 if direction[0] >= 0.0 else -1.0
-        sy = 1.0 if direction[1] >= 0.0 else -1.0
-        sz = 1.0 if direction[2] >= 0.0 else -1.0
+        # Use a relative deadband so near-zero direction components
+        # (from quaternion rotation noise ~1e-14) cannot flip the sign
+        # and select a different box vertex.  For face-aligned queries
+        # the non-primary components are zero; any vertex on that face
+        # is an equally valid support point, so biasing toward +1 is
+        # correct and keeps MPR's initial portal construction stable.
+        threshold = BOX_SUPPORT_DEADBAND * wp.length(direction)
+        sx = 1.0 if direction[0] >= -threshold else -1.0
+        sy = 1.0 if direction[1] >= -threshold else -1.0
+        sz = 1.0 if direction[2] >= -threshold else -1.0
 
         result = wp.vec3(sx * geom.scale[0], sy * geom.scale[1], sz * geom.scale[2])
 
@@ -317,9 +329,10 @@ def support_map_lean(geom: GenericShapeData, direction: wp.vec3, data_provider:
         result = wp.cw_mul(mesh.points[best_idx], geom.scale)
 
     elif geom.shape_type == GeoType.BOX:
-        sx = 1.0 if direction[0] >= 0.0 else -1.0
-        sy = 1.0 if direction[1] >= 0.0 else -1.0
-        sz = 1.0 if direction[2] >= 0.0 else -1.0
+        threshold = BOX_SUPPORT_DEADBAND * wp.length(direction)
+        sx = 1.0 if direction[0] >= -threshold else -1.0
+        sy = 1.0 if direction[1] >= -threshold else -1.0
+        sz = 1.0 if direction[2] >= -threshold else -1.0
         result = wp.vec3(sx * geom.scale[0], sy * geom.scale[1], sz * geom.scale[2])
 
     elif geom.shape_type == GeoType.SPHERE:
diff --git a/newton/_src/geometry/types.py b/newton/_src/geometry/types.py
index 921822a4f3..5c60b0ff62 100644
--- a/newton/_src/geometry/types.py
+++ b/newton/_src/geometry/types.py
@@ -79,6 +79,24 @@ class GeoType(enum.IntEnum):
     GAUSSIAN = 11
     """Gaussian splat."""
 
+    @property
+    def is_primitive(self) -> bool:
+        """Return whether this is a primitive (analytically defined) shape type."""
+        return self in {
+            GeoType.SPHERE,
+            GeoType.CYLINDER,
+            GeoType.CONE,
+            GeoType.CAPSULE,
+            GeoType.BOX,
+            GeoType.ELLIPSOID,
+            GeoType.PLANE,
+        }
+
+    @property
+    def is_explicit(self) -> bool:
+        """Return whether this is an explicit (data-driven) shape type."""
+        return self in {GeoType.MESH, GeoType.CONVEX_MESH, GeoType.HFIELD}
+
 
 class Mesh:
     """
diff --git a/newton/_src/sim/builder.py b/newton/_src/sim/builder.py
index 79807e853c..c9d3de5bad 100644
--- a/newton/_src/sim/builder.py
+++ b/newton/_src/sim/builder.py
@@ -2243,7 +2243,7 @@ def add_usd(
         force_position_velocity_actuation: bool = False,
         override_root_xform: bool = False,
     ) -> dict[str, Any]:
-        """Parses a Universal Scene Description (USD) stage containing UsdPhysics schema definitions for rigid-body articulations and adds the bodies, shapes and joints to the given ModelBuilder.
+        """Parses a Universal Scene Description (USD) stage and adds rigid bodies, soft bodies, shapes, and joints to the given ModelBuilder.
 
         The USD description has to be either a path (file name or URL), or an existing USD stage instance that implements the `Stage <https://openusd.org/dev/api/class_usd_stage.html>`_ interface.
 
diff --git a/newton/_src/sim/collide.py b/newton/_src/sim/collide.py
index b5404e03d5..1f5aa9e5e4 100644
--- a/newton/_src/sim/collide.py
+++ b/newton/_src/sim/collide.py
@@ -12,7 +12,8 @@
 from ..geometry.broad_phase_nxn import BroadPhaseAllPairs, BroadPhaseExplicit
 from ..geometry.broad_phase_sap import BroadPhaseSAP
 from ..geometry.collision_core import compute_tight_aabb_from_support
-from ..geometry.contact_data import ContactData
+from ..geometry.contact_data import ContactData, make_contact_sort_key
+from ..geometry.contact_sort import ContactSorter
 from ..geometry.differentiable_contacts import launch_differentiable_contact_augment
 from ..geometry.flags import ShapeFlags
 from ..geometry.kernels import create_soft_contacts
@@ -83,6 +84,7 @@ class ContactWriterData:
     out_stiffness: wp.array[float]
     out_damping: wp.array[float]
     out_friction: wp.array[float]
+    out_sort_key: wp.array[wp.int64]
     # Speculative contact fields (empty arrays / 0.0 when disabled)
     shape_lin_vel: wp.array[wp.vec3]
     shape_ang_speed_bound: wp.array[float]
@@ -189,6 +191,11 @@ def write_contact(
         writer_data.out_damping[index] = contact_data.contact_damping
         writer_data.out_friction[index] = contact_data.contact_friction_scale
 
+    if writer_data.out_sort_key.shape[0] > 0:
+        writer_data.out_sort_key[index] = make_contact_sort_key(
+            contact_data.shape_a, contact_data.shape_b, contact_data.sort_sub_key
+        )
+
 
 def _create_compute_shape_aabbs(speculative: bool):
     """Factory for the AABB kernel. When *speculative* is True the kernel reads
@@ -388,18 +395,16 @@ def prepare_geom_data_kernel(
     shape_margin: wp.array[float],
     body_q: wp.array[wp.transform],
     # Outputs
-    geom_data: wp.array[wp.vec4],  # scale xyz, margin w
-    geom_transform: wp.array[wp.transform],  # world space transform
+    geom_data: wp.array[wp.vec4],
+    geom_transform: wp.array[wp.transform],
 ):
     """Prepare geometry data arrays for NarrowPhase API."""
     idx = wp.tid()
 
-    # Pack scale and margin into geom_data
     scale = shape_scale[idx]
     margin = shape_margin[idx]
     geom_data[idx] = wp.vec4(scale[0], scale[1], scale[2], margin)
 
-    # Compute world space transform
     body_idx = shape_body[idx]
     if body_idx >= 0:
         geom_transform[idx] = wp.transform_multiply(body_q[body_idx], shape_transform[idx])
@@ -610,6 +615,7 @@ def __init__(
         narrow_phase: NarrowPhase | None = None,
         sdf_hydroelastic_config: HydroelasticSDF.Config | None = None,
         speculative_config: SpeculativeContactConfig | None = None,
+        deterministic: bool = False,
     ):
         """
         Initialize the CollisionPipeline (expert API).
@@ -647,6 +653,9 @@ def __init__(
                 within the next collision update interval are detected early.
                 ``None`` (default) disables speculative contacts with zero
                 runtime overhead via compile-time elimination.
+            deterministic: Sort contacts after the narrow phase so that results
+                are independent of GPU thread scheduling.  Adds a radix sort +
+                gather pass.  Hydroelastic contacts are not yet covered.
 
         .. note::
             When ``requires_grad`` is true (explicitly or via ``model.requires_grad``),
@@ -728,6 +737,12 @@ def __init__(
                     self.shape_pairs_excluded.shape[0] if self.shape_pairs_excluded is not None else 0
                 )
 
+            if deterministic and not narrow_phase.deterministic:
+                raise ValueError(
+                    "CollisionPipeline(deterministic=True) requires a deterministic "
+                    "NarrowPhase. Either omit narrow_phase or construct it with "
+                    "deterministic=True."
+                )
             if narrow_phase.max_candidate_pairs < self.shape_pairs_max:
                 raise ValueError(
                     "Provided narrow_phase.max_candidate_pairs is too small for this model and broad phase mode "
@@ -819,6 +834,7 @@ def __init__(
                 has_heightfields=has_heightfields,
                 use_lean_gjk_mpr=use_lean_gjk_mpr,
                 speculative=self._speculative_enabled,
+                deterministic=deterministic,
             )
             self.hydroelastic_sdf = self.narrow_phase.hydroelastic_sdf
 
@@ -850,6 +866,17 @@ def __init__(
         self.soft_contact_margin = soft_contact_margin
         self._soft_contact_max = soft_contact_max
         self.requires_grad = requires_grad
+        self.deterministic = deterministic
+        if deterministic:
+            per_contact_props = self.narrow_phase.hydroelastic_sdf is not None
+            with wp.ScopedDevice(device):
+                self._sort_key_array = wp.zeros(rigid_contact_max, dtype=wp.int64, device=device)
+            self._contact_sorter = ContactSorter(
+                rigid_contact_max, per_contact_shape_properties=per_contact_props, device=device
+            )
+        else:
+            self._sort_key_array = wp.zeros(0, dtype=wp.int64, device=device)
+            self._contact_sorter = None
 
         if self._speculative_enabled:
             with wp.ScopedDevice(device):
@@ -1106,6 +1133,15 @@ def collide(
         writer_data.out_stiffness = contacts.rigid_contact_stiffness
         writer_data.out_damping = contacts.rigid_contact_damping
         writer_data.out_friction = contacts.rigid_contact_friction
+        if self.deterministic and contacts.rigid_contact_max != self._sort_key_array.shape[0]:
+            raise ValueError(
+                f"Contacts buffer capacity ({contacts.rigid_contact_max}) does not match the "
+                f"deterministic sort buffer size ({self._sort_key_array.shape[0]}). "
+                f"The sorter operates over fixed-capacity buffers for CUDA graph capture "
+                f"compatibility, so the sizes must match exactly. Use CollisionPipeline.contacts() "
+                f"or pass matching rigid_contact_max."
+            )
+        writer_data.out_sort_key = self._sort_key_array
 
         writer_data.shape_lin_vel = self._shape_lin_vel
         writer_data.shape_ang_speed_bound = self._shape_ang_speed_bound
@@ -1141,6 +1177,26 @@ def collide(
             max_speculative_extension=max_speculative_extension,
         )
 
+        if self.deterministic and self._contact_sorter is not None:
+            self._contact_sorter.sort_full(
+                self._sort_key_array,
+                contacts.rigid_contact_count,
+                shape0=contacts.rigid_contact_shape0,
+                shape1=contacts.rigid_contact_shape1,
+                point0=contacts.rigid_contact_point0,
+                point1=contacts.rigid_contact_point1,
+                offset0=contacts.rigid_contact_offset0,
+                offset1=contacts.rigid_contact_offset1,
+                normal=contacts.rigid_contact_normal,
+                margin0=contacts.rigid_contact_margin0,
+                margin1=contacts.rigid_contact_margin1,
+                tids=contacts.rigid_contact_tids,
+                stiffness=contacts.rigid_contact_stiffness,
+                damping=contacts.rigid_contact_damping,
+                friction=contacts.rigid_contact_friction,
+                device=self.device,
+            )
+
         # Differentiable contact augmentation: reconstruct world-space contact
         # quantities through body_q so that gradients flow via wp.Tape.
         if self.requires_grad and contacts.rigid_contact_diff_distance is not None:
diff --git a/newton/_src/sim/contacts.py b/newton/_src/sim/contacts.py
index 707461db25..ce3be15935 100644
--- a/newton/_src/sim/contacts.py
+++ b/newton/_src/sim/contacts.py
@@ -6,6 +6,19 @@
 import warp as wp
 from warp import DeviceLike as Devicelike
 
+GENERATION_SENTINEL = -1
+"""Value reserved as an impossible generation; the increment kernel skips it."""
+
+
+@wp.kernel(enable_backward=False)
+def _increment_contact_generation(generation: wp.array[wp.int32]):
+    g = generation[0]
+    if g == 2147483647:
+        g = 0
+    else:
+        g = g + 1
+    generation[0] = g
+
 
 class Contacts:
     """
@@ -96,6 +109,12 @@ def __init__(
             # Create sliced views for individual counters (no additional allocation)
             self.rigid_contact_count = self._counter_array[0:1]
 
+            self.contact_generation = wp.zeros(1, dtype=wp.int32)
+            """Device-side generation counter, incremented each time :meth:`clear` is called.
+
+            Solvers can compare this against a cached value to detect whether the
+            contact set changed since the last conversion pass."""
+
             # rigid contacts — never requires_grad (narrow phase has enable_backward=False)
             self.rigid_contact_point_id = wp.zeros(rigid_contact_max, dtype=wp.int32)
             self.rigid_contact_shape0 = wp.full(rigid_contact_max, -1, dtype=wp.int32)
@@ -204,7 +223,7 @@ def clear(self):
         Clear contact data, resetting counts and optionally clearing all buffers.
 
         By default (clear_buffers=False), only resets contact counts. This is highly optimized,
-        requiring just 1 kernel launch. Collision detection overwrites all data up to the new
+        requiring just 2 kernel launches. Collision detection overwrites all data up to the new
         contact_count, and solvers only read up to count, so clearing stale data is unnecessary.
 
         If clear_buffers=True (conservative mode), performs full buffer clearing with sentinel
@@ -213,6 +232,15 @@ def clear(self):
         # Clear all counters with a single kernel launch (consolidated counter array)
         self._counter_array.zero_()
 
+        # Bump generation so solvers know the contact set changed (graph-capture safe)
+        wp.launch(
+            _increment_contact_generation,
+            dim=1,
+            inputs=[self.contact_generation],
+            device=self.contact_generation.device,
+            record_tape=False,
+        )
+
         if self.clear_buffers:
             # Conservative path: clear all buffers (7-10 kernel launches)
             # This is slower but may be useful for debugging or special cases
diff --git a/newton/_src/solvers/kamino/_src/core/builder.py b/newton/_src/solvers/kamino/_src/core/builder.py
index 6576236490..0bef7d432e 100644
--- a/newton/_src/solvers/kamino/_src/core/builder.py
+++ b/newton/_src/solvers/kamino/_src/core/builder.py
@@ -25,7 +25,7 @@
 from .materials import MaterialDescriptor, MaterialManager, MaterialPairProperties, MaterialPairsModel, MaterialsModel
 from .math import FLOAT32_EPS
 from .model import ModelKamino, ModelKaminoInfo
-from .shapes import ShapeDescriptorType, is_explicit_geo_type, max_contacts_for_shape_pair
+from .shapes import ShapeDescriptorType, max_contacts_for_shape_pair
 from .size import SizeKamino
 from .time import TimeModel
 from .types import Axis, float32, int32, mat33f, transformf, vec2i, vec3f, vec4f, vec6f
@@ -1130,7 +1130,7 @@ def collect_joint_model_data():
         # NOTE: This also finalizes the mesh/SDF/HField data on the device
         def make_geometry_source_pointer(geom: GeometryDescriptor, mesh_geoms: dict, device) -> int:
             # Append to data pointers array of the shape has a Mesh, SDF or HField source
-            if is_explicit_geo_type(geom.shape.type):
+            if geom.shape.type.is_explicit:
                 geom_uid = geom.uid
                 # If the geometry has a Mesh, SDF or HField source,
                 # finalize it and retrieve the mesh pointer/index
diff --git a/newton/_src/solvers/kamino/_src/core/geometry.py b/newton/_src/solvers/kamino/_src/core/geometry.py
index 87adcb5288..b9c7ea5075 100644
--- a/newton/_src/solvers/kamino/_src/core/geometry.py
+++ b/newton/_src/solvers/kamino/_src/core/geometry.py
@@ -331,6 +331,31 @@ class GeometriesModel:
     Shape of ``(num_excluded_geom_pairs,)`` and type :class:`vec2i`.
     """
 
+    ###
+    # Mesh / Heightfield Data (pass-through from Newton Model)
+    ###
+
+    heightfield_index: wp.array | None = None
+    """Per-shape heightfield index (``-1`` for non-heightfield shapes)."""
+
+    heightfield_data: wp.array | None = None
+    """Concatenated :class:`HeightfieldData` structs for all heightfields."""
+
+    heightfield_elevations: wp.array | None = None
+    """Concatenated elevation samples for all heightfields."""
+
+    collision_aabb_lower: wp.array | None = None
+    """Per-shape local-space collision AABB lower bounds."""
+
+    collision_aabb_upper: wp.array | None = None
+    """Per-shape local-space collision AABB upper bounds."""
+
+    voxel_resolution: wp.array | None = None
+    """Per-shape voxel resolution for mesh contact reduction."""
+
+    collision_radius: wp.array | None = None
+    """Per-shape bounding-sphere radius for broadphase AABB computation."""
+
 
 @dataclass
 class GeometriesData:
diff --git a/newton/_src/solvers/kamino/_src/core/model.py b/newton/_src/solvers/kamino/_src/core/model.py
index fedc3c6199..5f48f2e3ba 100644
--- a/newton/_src/solvers/kamino/_src/core/model.py
+++ b/newton/_src/solvers/kamino/_src/core/model.py
@@ -975,7 +975,6 @@ def _compute_num_entities_per_world(entity_world: wp.array, num_worlds: int) ->
         shape_scale_np = model.shape_scale.numpy()
         shape_flags_np = model.shape_flags.numpy()
         geom_shape_collision_group_np = model.shape_collision_group.numpy()
-        geom_shape_type_np = np.array(shape_type_np, dtype=int)
         geom_shape_params_np = np.zeros((model.shape_count, 4), dtype=float)
         model_num_collidable_geoms = 0
         for s in range(model.shape_count):
@@ -1311,7 +1310,7 @@ def _compute_num_entities_per_world(entity_world: wp.array, num_worlds: int) ->
                 wid=model.shape_world,
                 gid=wp.array(shape_sid_np, dtype=int32),  # TODO: Remove
                 bid=model.shape_body,
-                type=wp.array(geom_shape_type_np, dtype=int32),
+                type=wp.array(shape_type_np, dtype=int32),
                 flags=model.shape_flags,
                 ptr=model.shape_source_ptr,
                 params=wp.array(geom_shape_params_np, dtype=vec4f),
@@ -1322,6 +1321,14 @@ def _compute_num_entities_per_world(entity_world: wp.array, num_worlds: int) ->
                 margin=model.shape_margin,
                 collidable_pairs=model.shape_contact_pairs,
                 excluded_pairs=wp.array(sorted(model.shape_collision_filter_pairs), dtype=vec2i),
+                # Mesh / heightfield data pass-through from Newton model
+                heightfield_index=model.shape_heightfield_index,
+                heightfield_data=model.heightfield_data,
+                heightfield_elevations=model.heightfield_elevations,
+                collision_aabb_lower=model.shape_collision_aabb_lower,
+                collision_aabb_upper=model.shape_collision_aabb_upper,
+                voxel_resolution=model._shape_voxel_resolution,
+                collision_radius=model.shape_collision_radius,
             )
 
             # Per-material properties
diff --git a/newton/_src/solvers/kamino/_src/core/shapes.py b/newton/_src/solvers/kamino/_src/core/shapes.py
index f9c67dd069..5c534fb32a 100644
--- a/newton/_src/solvers/kamino/_src/core/shapes.py
+++ b/newton/_src/solvers/kamino/_src/core/shapes.py
@@ -51,25 +51,21 @@
 
 
 def is_primitive_geo_type(geo_type: GeoType) -> bool:
-    """Returns whether the geo type is a primitive shape."""
-    return geo_type in {
-        GeoType.SPHERE,
-        GeoType.CYLINDER,
-        GeoType.CONE,
-        GeoType.CAPSULE,
-        GeoType.BOX,
-        GeoType.ELLIPSOID,
-        GeoType.PLANE,
-    }
+    """Return whether the geo type is a primitive shape.
+
+    .. deprecated::
+        Use :attr:`GeoType.is_primitive` instead.
+    """
+    return geo_type.is_primitive
 
 
 def is_explicit_geo_type(geo_type: GeoType) -> bool:
-    """Returns whether the geo type is an explicit shape (mesh, convex, heightfield)."""
-    return geo_type in {
-        GeoType.MESH,
-        GeoType.CONVEX_MESH,
-        GeoType.HFIELD,
-    }
+    """Return whether the geo type is an explicit shape (mesh, convex, heightfield).
+
+    .. deprecated::
+        Use :attr:`GeoType.is_explicit` instead.
+    """
+    return geo_type.is_explicit
 
 
 class ShapeDescriptor(ABC, Descriptor):
@@ -546,16 +542,22 @@ def color(self) -> Vec3 | None:
 
 
 class HFieldShape(ShapeDescriptor):
-    """
-    A shape descriptor for height-field shapes.
+    """A shape descriptor for height-field (terrain) shapes.
 
-    WARNING: This class is not yet implemented.
+    Attributes:
+        heightfield: The underlying :class:`Heightfield` data.
     """
 
-    def __init__(self, name: str = "hfield", uid: str | None = None):
+    def __init__(self, heightfield: Heightfield, name: str = "hfield", uid: str | None = None):
+        """Initialize the height-field shape descriptor.
+
+        Args:
+            heightfield: A :class:`Heightfield` instance containing elevation data.
+            name: The name of the shape descriptor.
+            uid: Optional unique identifier of the shape descriptor.
+        """
         super().__init__(GeoType.HFIELD, name, uid)
-        # TODO: Remove this when HFieldShape is implemented
-        raise NotImplementedError("HFieldShape is not yet implemented.")
+        self._data: Heightfield = heightfield
 
     @override
     def __repr__(self):
@@ -572,6 +574,11 @@ def params(self) -> tuple[float, float, float]:
         """Returns the XYZ scaling of the height-field."""
         return 1.0, 1.0, 1.0
 
+    @property
+    @override
+    def data(self) -> Heightfield:
+        return self._data
+
 
 ###
 # Aliases
@@ -616,6 +623,12 @@ def max_contacts_for_shape_pair(type_a: int, type_b: int) -> tuple[int, int]:
     if type_a > type_b:
         type_a, type_b = type_b, type_a
 
+    # Contact counts for mesh/heightfield pairs are dynamic (bounded by the
+    # pipeline's max_contacts_per_pair setting).  The values below are
+    # conservative upper-bound estimates used for capacity allocation.
+    _MESH_CONVEX_MAX = 32
+    _MESH_MESH_MAX = 64
+
     if type_a == GeoType.SPHERE:
         return 1, 0
 
@@ -629,7 +642,7 @@ def max_contacts_for_shape_pair(type_a: int, type_b: int) -> tuple[int, int]:
         elif type_b == GeoType.BOX:
             return 8, 8
         elif type_b == GeoType.MESH or type_b == GeoType.CONVEX_MESH:
-            pass  # TODO: WHAT TO RETURN WHEN MESH SUPPORT IS ADDED?
+            return _MESH_CONVEX_MAX, 0
         elif type_b == GeoType.CONE:
             return 4, 4
         elif type_b == GeoType.PLANE:
@@ -643,7 +656,7 @@ def max_contacts_for_shape_pair(type_a: int, type_b: int) -> tuple[int, int]:
         elif type_b == GeoType.BOX:
             return 8, 8
         elif type_b == GeoType.MESH or type_b == GeoType.CONVEX_MESH:
-            pass  # TODO: WHAT TO RETURN WHEN MESH SUPPORT IS ADDED?
+            return _MESH_CONVEX_MAX, 0
         elif type_b == GeoType.CONE:
             return 8, 8
         elif type_b == GeoType.PLANE:
@@ -655,7 +668,7 @@ def max_contacts_for_shape_pair(type_a: int, type_b: int) -> tuple[int, int]:
         elif type_b == GeoType.BOX:
             return 8, 8
         elif type_b == GeoType.MESH or type_b == GeoType.CONVEX_MESH:
-            pass  # TODO: WHAT TO RETURN WHEN MESH SUPPORT IS ADDED?
+            return _MESH_CONVEX_MAX, 0
         elif type_b == GeoType.CONE:
             return 4, 4
         elif type_b == GeoType.PLANE:
@@ -665,7 +678,7 @@ def max_contacts_for_shape_pair(type_a: int, type_b: int) -> tuple[int, int]:
         if type_b == GeoType.BOX:
             return 12, 12
         elif type_b == GeoType.MESH or type_b == GeoType.CONVEX_MESH:
-            pass  # TODO: WHAT TO RETURN WHEN MESH SUPPORT IS ADDED?
+            return _MESH_CONVEX_MAX, 0
         elif type_b == GeoType.CONE:
             return 8, 8
         elif type_b == GeoType.PLANE:
@@ -673,13 +686,17 @@ def max_contacts_for_shape_pair(type_a: int, type_b: int) -> tuple[int, int]:
 
     elif type_a == GeoType.MESH or type_a == GeoType.CONVEX_MESH:
         if type_b == GeoType.HFIELD:
-            pass  # TODO: WHAT TO RETURN WHEN MESH SUPPORT IS ADDED?
+            return _MESH_MESH_MAX, 0
         elif type_b == GeoType.CONE:
-            pass  # TODO: WHAT TO RETURN WHEN MESH SUPPORT IS ADDED?
+            return _MESH_CONVEX_MAX, 0
         elif type_b == GeoType.PLANE:
-            pass  # TODO: WHAT TO RETURN WHEN MESH SUPPORT IS ADDED?
+            return _MESH_CONVEX_MAX, 0
         else:
-            pass  # TODO: WHAT TO RETURN WHEN MESH SUPPORT IS ADDED?
+            return _MESH_MESH_MAX, 0
+
+    elif type_a == GeoType.HFIELD:
+        # Heightfield vs convex primitives
+        return _MESH_CONVEX_MAX, 0
 
     elif type_a == GeoType.CONE:
         if type_b == GeoType.CONE:
diff --git a/newton/_src/solvers/kamino/_src/geometry/unified.py b/newton/_src/solvers/kamino/_src/geometry/unified.py
index b2643fb35b..a46d18c145 100644
--- a/newton/_src/solvers/kamino/_src/geometry/unified.py
+++ b/newton/_src/solvers/kamino/_src/geometry/unified.py
@@ -273,6 +273,9 @@ def _compute_collision_radius(geo_type: int32, scale: vec3f) -> float32:
             radius = wp.length(scale)
         else:
             radius = float32(1.0e6)
+    elif geo_type == GeoType.MESH or geo_type == GeoType.CONVEX_MESH or geo_type == GeoType.HFIELD:
+        # Large bounding sphere; the AABB kernel computes a tighter bound from mesh data
+        radius = float32(1.0e6)
     return radius
 
 
@@ -518,30 +521,48 @@ def __init__(
             | ShapeFlags.COLLIDE_PARTICLES  # Enable shape-particle collision
         )
 
+        # Detect whether the model contains mesh, convex mesh, or heightfield shapes.
+        # Keep mesh and heightfield flags separate: heightfield-only scenes should not
+        # trigger mesh-only kernel setup (mesh-mesh SDF contacts require CUDA).
+        geom_type_np = self._model.geoms.type.numpy()
+        _has_meshes = any(int(t) in (GeoType.MESH, GeoType.CONVEX_MESH) for t in geom_type_np)
+        _has_heightfields = any(int(t) == GeoType.HFIELD for t in geom_type_np)
+        _has_explicit = _has_meshes or _has_heightfields
+
         # Allocate internal data needed by the pipeline that
         # the Kamino model and data do not yet provide
         with wp.ScopedDevice(self._device):
             self.geom_type = wp.zeros(self._num_geoms, dtype=int32)
             self.geom_data = wp.zeros(self._num_geoms, dtype=vec4f)
             self.geom_collision_group = wp.array(geom_collision_group_list, dtype=int32)
-            self.shape_collision_radius = wp.zeros(self._num_geoms, dtype=float32)
+            self.collision_radius = wp.zeros(self._num_geoms, dtype=float32)
             self.shape_flags = wp.full(self._num_geoms, default_shape_flag, dtype=int32)
             self.shape_aabb_lower = wp.zeros(self._num_geoms, dtype=wp.vec3)
             self.shape_aabb_upper = wp.zeros(self._num_geoms, dtype=wp.vec3)
             self.broad_phase_pairs = wp.zeros(self._max_shape_pairs, dtype=wp.vec2i)
             self.broad_phase_pair_count = wp.zeros(1, dtype=wp.int32)
             self.narrow_phase_contact_count = wp.zeros(1, dtype=int32)
-            # TODO: These are currently left empty just to satisfy the narrow phase interface
-            # but we need to implement SDF/mesh/heightfield support in Kamino to make use of them.
-            # With has_meshes=False, these arrays are never accessed.
             self.shape_sdf_data = wp.empty(shape=(0,), dtype=TextureSDFData)
             self.shape_sdf_index = wp.full_like(self.geom_type, -1)
-            self.shape_collision_aabb_lower = wp.empty(shape=(0,), dtype=wp.vec3)
-            self.shape_collision_aabb_upper = wp.empty(shape=(0,), dtype=wp.vec3)
-            self.shape_voxel_resolution = wp.empty(shape=(0,), dtype=wp.vec3i)
-            self.shape_heightfield_index = None  # TODO
-            self.heightfield_data = None  # TODO
-            self.heightfield_elevations = None  # TODO
+
+        # Wire mesh / heightfield data from the model when explicit shapes exist;
+        # otherwise use empty placeholder arrays that satisfy the narrow-phase interface.
+        geoms = self._model.geoms
+        if _has_explicit:
+            self.collision_aabb_lower = geoms.collision_aabb_lower
+            self.collision_aabb_upper = geoms.collision_aabb_upper
+            self.voxel_resolution = geoms.voxel_resolution
+            self.heightfield_index = geoms.heightfield_index
+            self.heightfield_data = geoms.heightfield_data
+            self.heightfield_elevations = geoms.heightfield_elevations
+        else:
+            with wp.ScopedDevice(self._device):
+                self.collision_aabb_lower = wp.empty(shape=(0,), dtype=wp.vec3)
+                self.collision_aabb_upper = wp.empty(shape=(0,), dtype=wp.vec3)
+                self.voxel_resolution = wp.empty(shape=(0,), dtype=wp.vec3i)
+            self.heightfield_index = None
+            self.heightfield_data = None
+            self.heightfield_elevations = None
 
         # Initialize the broad-phase backend depending on the selected mode
         match self._broadphase:
@@ -555,7 +576,6 @@ def __init__(
                 raise ValueError(f"Unsupported broad phase mode: {self._broadphase}")
 
         # Initialize narrow-phase backend with the contact writer customized for Kamino
-        # Note: has_meshes=False since Kamino doesn't support mesh collisions yet
         self.narrow_phase = NarrowPhase(
             max_candidate_pairs=self._max_shape_pairs,
             max_triangle_pairs=self._max_triangle_pairs,
@@ -563,7 +583,8 @@ def __init__(
             shape_aabb_lower=self.shape_aabb_lower,
             shape_aabb_upper=self.shape_aabb_upper,
             contact_writer_warp_func=write_contact_unified_kamino,
-            has_meshes=False,
+            has_meshes=_has_meshes,
+            has_heightfields=_has_heightfields,
         )
 
         # Convert geometry data from Kamino to Newton format
@@ -657,11 +678,16 @@ def _convert_geometry_data(self):
                 self._model.geoms.gap,
                 self.geom_type,
                 self.geom_data,
-                self.shape_collision_radius,
+                self.collision_radius,
             ],
             device=self._device,
         )
 
+        # Use Newton's precomputed collision radius when available (gives
+        # tighter AABBs for meshes and heightfields than the 1e6 fallback).
+        if self._model.geoms.collision_radius is not None:
+            self.collision_radius.assign(self._model.geoms.collision_radius)
+
     def _update_geom_data(self, data: DataKamino, state: StateKamino):
         """
         Updates geometry poses from corresponding body states and computes respective AABBs.
@@ -683,7 +709,7 @@ def _update_geom_data(self, data: DataKamino, state: StateKamino):
                 self._model.geoms.offset,
                 self._model.geoms.margin,
                 self._model.geoms.gap,
-                self.shape_collision_radius,
+                self.collision_radius,
                 state.q_i,
             ],
             outputs=[
@@ -798,12 +824,12 @@ def _run_narrowphase(self, data: DataKamino, contacts: ContactsKamino):
             texture_sdf_data=self.shape_sdf_data,
             shape_sdf_index=self.shape_sdf_index,
             shape_gap=self._model.geoms.gap,
-            shape_collision_radius=self.shape_collision_radius,
+            shape_collision_radius=self.collision_radius,
             shape_flags=self.shape_flags,
-            shape_collision_aabb_lower=self.shape_collision_aabb_lower,
-            shape_collision_aabb_upper=self.shape_collision_aabb_upper,
-            shape_voxel_resolution=self.shape_voxel_resolution,
-            shape_heightfield_index=self.shape_heightfield_index,
+            shape_collision_aabb_lower=self.collision_aabb_lower,
+            shape_collision_aabb_upper=self.collision_aabb_upper,
+            shape_voxel_resolution=self.voxel_resolution,
+            shape_heightfield_index=self.heightfield_index,
             heightfield_data=self.heightfield_data,
             heightfield_elevations=self.heightfield_elevations,
             writer_data=writer_data,
diff --git a/newton/_src/solvers/kamino/examples/rl/example_rl_bipedal.py b/newton/_src/solvers/kamino/examples/rl/example_rl_bipedal.py
index 25637e2b42..671f601005 100644
--- a/newton/_src/solvers/kamino/examples/rl/example_rl_bipedal.py
+++ b/newton/_src/solvers/kamino/examples/rl/example_rl_bipedal.py
@@ -22,6 +22,9 @@
 import torch  # noqa: TID253
 import warp as wp
 
+# Newton
+import newton
+
 # Kamino
 from newton._src.solvers.kamino._src.utils import logger as msg
 from newton._src.solvers.kamino._src.utils.viewer import ViewerConfig
@@ -93,6 +96,95 @@ def _build_normalization(joint_names: list[str]):
     return offsets, scales
 
 
+###########################################################################
+# Terrain callback - adds a smooth heightfield
+###########################################################################
+
+
+def _make_terrain_fn(
+    nrow: int = 40,
+    ncol: int = 40,
+    hx: float = 10.0,
+    hy: float = 10.0,
+    amplitude: float = 0.35,
+    seed: int = 42,
+):
+    """Return a callback that adds a smooth heightfield terrain to a builder.
+
+    The elevation is a sum of low-frequency sine waves — gentle enough for
+    a bipedal robot to walk on yet clearly non-flat.
+
+    Args:
+        nrow: Grid rows.
+        ncol: Grid columns.
+        hx: Half-extent in X [m].
+        hy: Half-extent in Y [m].
+        amplitude: Peak-to-peak height variation [m].
+        seed: RNG seed for random phase offsets.
+    """
+    rng = np.random.default_rng(seed)
+    x = np.linspace(-hx, hx, ncol)
+    y = np.linspace(-hy, hy, nrow)
+    xx, yy = np.meshgrid(x, y)
+
+    elevation = np.zeros_like(xx)
+    for freq in (0.4, 0.7, 1.1):
+        px, py = rng.uniform(0, 2 * np.pi, size=2)
+        elevation += np.sin(freq * xx + px) * np.cos(freq * yy + py)
+    elevation *= amplitude / np.ptp(elevation)
+    center_r, center_c = nrow // 2, ncol // 2
+    elevation -= elevation[center_r, center_c]  # surface at origin == z=0 (robot feet)
+
+    hfield = newton.Heightfield(
+        data=elevation.astype(np.float32),
+        nrow=nrow,
+        ncol=ncol,
+        hx=hx,
+        hy=hy,
+    )
+
+    def _add_terrain(builder):
+        cfg = newton.ModelBuilder.ShapeConfig()
+        cfg.margin = 0.01
+        cfg.gap = 0.02
+        builder.add_shape_heightfield(heightfield=hfield, cfg=cfg)
+
+    return _add_terrain
+
+
+###########################################################################
+# Scene callback - adds pushable balls
+###########################################################################
+
+BALL_RADIUS = 0.2
+BALL_POSITIONS = [
+    wp.vec3(0.5, 0.0, BALL_RADIUS + 0.01),
+    wp.vec3(-0.6, 0.4, BALL_RADIUS + 0.01),
+    wp.vec3(0.3, -0.5, BALL_RADIUS + 0.01),
+    wp.vec3(-0.4, -0.3, BALL_RADIUS + 0.01),
+    wp.vec3(0.7, 0.6, BALL_RADIUS + 0.01),
+]
+
+
+def _make_balls_fn(num_balls: int = 1):
+    """Return a callback that adds *num_balls* pushable spheres."""
+    num_balls = max(0, min(num_balls, len(BALL_POSITIONS)))
+    positions = BALL_POSITIONS[:num_balls]
+
+    def _add_balls(robot_builder):
+        ball_cfg = newton.ModelBuilder.ShapeConfig()
+        ball_cfg.density = 50.0
+        ball_cfg.mu = 0.5
+        for i, pos in enumerate(positions):
+            ball_body = robot_builder.add_body(
+                xform=wp.transform(p=pos, q=wp.quat_identity()),
+                label=f"ball_{i}",
+            )
+            robot_builder.add_shape_sphere(ball_body, radius=BALL_RADIUS, cfg=ball_cfg)
+
+    return _add_balls
+
+
 ###########################################################################
 # Example class
 ###########################################################################
@@ -104,6 +196,7 @@ def __init__(
         device: wp.DeviceLike = None,
         policy=None,
         headless: bool = False,
+        num_balls: int = 1,
     ):
         # Timing
         self.sim_dt = 0.02
@@ -114,7 +207,7 @@ def __init__(
         # USD model path
         USD_MODEL_PATH = os.path.join(_ASSETS_DIR, "bipedal", "bipedal_with_textures.usda")
 
-        # Create generic articulated body simulator
+        # Create generic articulated body simulator with rolling terrain
         self.sim_wrapper = RigidBodySim(
             usd_model_path=USD_MODEL_PATH,
             num_worlds=1,
@@ -128,6 +221,8 @@ def __init__(
                 specular_scale=0.3,
                 shadow_radius=10.0,
             ),
+            terrain_fn=_make_terrain_fn(),
+            scene_callback=_make_balls_fn(num_balls),
         )
 
         # Override PD gains
@@ -136,10 +231,12 @@ def __init__(
         self.sim_wrapper.sim.model.joints.a_j.fill_(0.004)
         self.sim_wrapper.sim.model.joints.b_j.fill_(0.0)
 
-        # Build normalization from simulator joint order
-        joint_pos_offset, joint_pos_scale = _build_normalization(self.sim_wrapper.joint_names)
+        # Build normalization from actuated joints only (excludes passive free joints
+        # such as the ball, which should not feed into the RL policy).
+        joint_pos_offset, joint_pos_scale = _build_normalization(self.sim_wrapper.actuated_joint_names)
         self.joint_pos_offset = torch.tensor(joint_pos_offset, device=self.torch_device)
         self.joint_pos_scale = torch.tensor(joint_pos_scale, device=self.torch_device)
+        self._act_idx = self.sim_wrapper.actuated_dof_indices_tensor
 
         # Observation builder
         self.obs = BipedalObservation(
@@ -167,8 +264,8 @@ def __init__(
         root_yaw = quat_to_projected_yaw(self.sim_wrapper.q_i[:, 0, 3:])
         self.joystick.reset(root_pos_2d=root_pos_2d, root_yaw=root_yaw)
 
-        # Action buffer
-        self.actions = self.sim_wrapper.q_j.clone()
+        # Action buffer (actuated joints only)
+        self.actions = self.sim_wrapper.q_j[:, self._act_idx].clone()
 
         # Pre-allocated command buffers (eliminates per-step torch.tensor())
         self._cmd_vel_buf = torch.zeros(1, 2, device=self.torch_device)
@@ -193,7 +290,7 @@ def reset(self):
         root_pos_2d = self.sim_wrapper.q_i[:, 0, :2]
         root_yaw = quat_to_projected_yaw(self.sim_wrapper.q_i[:, 0, 3:])
         self.joystick.reset(root_pos_2d=root_pos_2d, root_yaw=root_yaw)
-        self.actions[:] = self.sim_wrapper.q_j
+        self.actions[:] = self.sim_wrapper.q_j[:, self._act_idx]
 
     def step_once(self):
         """Single physics step (used by run_headless warm-up)."""
@@ -234,8 +331,8 @@ def sim_step(self):
             torch.mul(raw, self.joint_pos_scale, out=self.actions)
             self.actions.add_(self.joint_pos_offset)
 
-        # Write action targets to implicit PD controller
-        self.sim_wrapper.q_j_ref[:] = self.actions
+        # Write action targets to actuated joints only
+        self.sim_wrapper.q_j_ref[:, self._act_idx] = self.actions
 
         # Step physics
         for _ in range(self.control_decimation):
@@ -273,6 +370,12 @@ def render(self):
         default="sync",
         help="Sim loop mode: sync (default) or async",
     )
+    parser.add_argument(
+        "--num-balls",
+        type=int,
+        default=1,
+        help="Number of balls to add to the scene (max 5, default: 1)",
+    )
     parser.add_argument(
         "--render-fps",
         type=float,
@@ -305,6 +408,7 @@ def render(self):
         device=device,
         policy=policy,
         headless=args.headless,
+        num_balls=args.num_balls,
     )
 
     try:
diff --git a/newton/_src/solvers/kamino/examples/rl/simulation.py b/newton/_src/solvers/kamino/examples/rl/simulation.py
index 1de6ee4613..10659ef210 100644
--- a/newton/_src/solvers/kamino/examples/rl/simulation.py
+++ b/newton/_src/solvers/kamino/examples/rl/simulation.py
@@ -30,6 +30,7 @@
 from newton._src.solvers.kamino._src.core.types import transformf, vec6f
 from newton._src.solvers.kamino._src.geometry import CollisionDetector
 from newton._src.solvers.kamino._src.geometry.aggregation import ContactAggregation
+from newton._src.solvers.kamino._src.geometry.contacts import ContactsKamino, convert_contacts_newton_to_kamino
 from newton._src.solvers.kamino._src.solver_kamino_impl import SolverKaminoImpl
 from newton._src.solvers.kamino._src.utils import logger as msg
 from newton._src.solvers.kamino._src.utils.sim import Simulator
@@ -44,6 +45,11 @@ class SimulatorFromNewton:
     already-finalized :class:`newton.Model` instead of a ``ModelBuilderKamino``.
     Internally uses :meth:`ModelKamino.from_newton` to obtain Kamino-native
     model, state, control, and solver objects.
+
+    When *use_newton_collisions* is ``True`` (required for heightfield /
+    mesh terrain), Newton's own :meth:`~newton.Model.collide` pipeline
+    runs each step and the resulting contacts are converted to Kamino
+    format via :func:`convert_contacts_newton_to_kamino`.
     """
 
     def __init__(
@@ -51,6 +57,7 @@ def __init__(
         newton_model: newton.Model,
         config: Simulator.Config | None = None,
         device: wp.DeviceLike = None,
+        use_newton_collisions: bool = False,
     ):
         self._device = wp.get_device(device)
 
@@ -69,11 +76,27 @@ def __init__(
         self._control: ControlKamino = self._model.control(device=self._device)
 
         # Collision detection
-        self._collision_detector = CollisionDetector(
-            model=self._model,
-            config=config.collision_detector,
-        )
-        self._contacts = self._collision_detector.contacts
+        self._use_newton_collisions = use_newton_collisions
+        self._collision_detector: CollisionDetector | None = None
+
+        if use_newton_collisions:
+            self._newton_model = newton_model
+            self._newton_state = newton_model.state()
+            self._newton_contacts = newton_model.contacts()
+            per_world = max(1024, newton_model.rigid_contact_max // max(newton_model.world_count, 1))
+            if config.collision_detector.max_contacts_per_world is not None:
+                per_world = min(per_world, config.collision_detector.max_contacts_per_world)
+            world_max = [per_world] * newton_model.world_count
+            self._contacts = ContactsKamino(capacity=world_max, device=self._device)
+        else:
+            self._newton_model = None
+            self._newton_state = None
+            self._newton_contacts = None
+            self._collision_detector = CollisionDetector(
+                model=self._model,
+                config=config.collision_detector,
+            )
+            self._contacts = self._collision_detector.contacts
 
         # Solver
         self._solver = SolverKaminoImpl(
@@ -109,13 +132,28 @@ def contacts(self):
         return self._contacts
 
     @property
-    def collision_detector(self) -> CollisionDetector:
+    def collision_detector(self) -> CollisionDetector | None:
         return self._collision_detector
 
     @property
     def solver(self) -> SolverKaminoImpl:
         return self._solver
 
+    def _run_newton_collision(self, state_kamino: StateKamino):
+        """Convert COM poses to body-origin frame, run Newton collision, convert contacts."""
+        convert_body_com_to_origin(
+            body_com=self._model.bodies.i_r_com_i,
+            body_q_com=state_kamino.q_i,
+            body_q=self._newton_state.body_q,
+        )
+        self._newton_model.collide(self._newton_state, self._newton_contacts)
+        convert_contacts_newton_to_kamino(
+            self._newton_model,
+            self._newton_state,
+            self._newton_contacts,
+            self._contacts,
+        )
+
     def step(self):
         """Advance the simulation by one timestep.
 
@@ -124,13 +162,24 @@ def step(self):
         only for rendering via :meth:`RigidBodySim.render`.
         """
         self._state_p.copy_from(self._state_n)
-        self._solver.step(
-            state_in=self._state_p,
-            state_out=self._state_n,
-            control=self._control,
-            contacts=self._contacts,
-            detector=self._collision_detector,
-        )
+
+        if self._use_newton_collisions:
+            self._run_newton_collision(self._state_p)
+            self._solver.step(
+                state_in=self._state_p,
+                state_out=self._state_n,
+                control=self._control,
+                contacts=self._contacts,
+                detector=None,
+            )
+        else:
+            self._solver.step(
+                state_in=self._state_p,
+                state_out=self._state_n,
+                control=self._control,
+                contacts=self._contacts,
+                detector=self._collision_detector,
+            )
 
     def reset(self, **kwargs):
         """Reset the simulation state.
@@ -170,6 +219,12 @@ class RigidBodySim:
         use_cuda_graph: Capture CUDA graphs for step and reset (requires
             CUDA device with memory pool enabled).
         render_config: Viewer appearance settings.  ``None`` uses defaults.
+        terrain_fn: Optional callable ``fn(builder)`` that adds terrain
+            shapes to the multi-world :class:`~newton.ModelBuilder`.
+            When provided, replaces the default ground plane.
+        scene_callback: Optional callable ``fn(robot_builder)`` that adds
+            extra shapes (e.g. pushable objects) to the robot builder
+            before multi-world duplication.
     """
 
     def __init__(
@@ -188,8 +243,11 @@ def __init__(
         video_folder: str | None = None,
         async_save: bool = True,
         max_contacts_per_pair: int | None = None,
+        max_contacts_per_world: int | None = None,
         render_config: ViewerConfig | None = None,
         collapse_fixed_joints: bool = False,
+        terrain_fn: callable | None = None,
+        scene_callback: callable | None = None,
     ):
         # ----- Device setup -----
         self._device = wp.get_device(device)
@@ -227,36 +285,43 @@ def __init__(
             hide_collision_shapes=True,
         )
 
+        if scene_callback is not None:
+            scene_callback(robot_builder)
+
         # Create the multi-world model by duplicating the single-robot
         # builder for the specified number of worlds
         builder = newton.ModelBuilder(up_axis=newton.Axis.Z)
         for _ in range(num_worlds):
             builder.add_world(robot_builder)
 
-        # Add a global ground plane applied to all worlds
-        builder.add_ground_plane()
+        if terrain_fn is not None:
+            terrain_fn(builder)
+        elif add_ground:
+            builder.add_ground_plane()
 
         # Create the model from the builder
         self._newton_model = builder.finalize(skip_validation_joints=True)
 
-        # TODO remove after fixing bug
-        self._newton_model.shape_margin.fill_(0.0)
-        self._newton_model.shape_gap.fill_(1e-5)
-
         if enable_gravity:
             self._newton_model.set_gravity((0.0, 0.0, -9.81))
 
         # ----- Create Kamino simulator from Newton model -----
         msg.notif("Building Kamino simulator ...")
 
-        # Cap per-pair contact count to limit Delassus matrix size
+        # Cap contact counts to limit Delassus matrix size
         if max_contacts_per_pair is not None:
             settings.collision_detector.max_contacts_per_pair = max_contacts_per_pair
+        if max_contacts_per_world is not None:
+            settings.collision_detector.max_contacts_per_world = max_contacts_per_world
 
+        # Use Newton's collision pipeline when terrain_fn adds non-primitive
+        # shapes (heightfields, meshes) that Kamino's detector cannot handle.
+        use_newton_cd = terrain_fn is not None
         self.sim = SimulatorFromNewton(
             newton_model=self._newton_model,
             config=settings,
             device=self._device,
+            use_newton_collisions=use_newton_cd,
         )
         self.model: ModelKamino = self.sim.model
         msg.info(f"Model size: {self.sim.model.size}")
@@ -367,16 +432,18 @@ def apply_shape_colors(shape_colors: dict[int, Color3]):
     def _make_rl_interface(self):
         """Create zero-copy PyTorch views of simulator state, control and contact arrays."""
         nw = self.sim.model.size.num_worlds
+        njc = self.sim.model.size.max_of_num_joint_coords
         njd = self.sim.model.size.max_of_num_joint_dofs
         nb = self.sim.model.size.max_of_num_bodies
 
         # State tensors (read-only views into simulator)
-        self._q_j = wp.to_torch(self.sim.state.q_j).reshape(nw, njd)
+        # q_j uses generalized coordinates (njc), dq_j uses DOFs (njd)
+        self._q_j = wp.to_torch(self.sim.state.q_j).reshape(nw, njc)
         self._dq_j = wp.to_torch(self.sim.state.dq_j).reshape(nw, njd)
         self._q_i = wp.to_torch(self.sim.state.q_i).reshape(nw, nb, 7)
         self._u_i = wp.to_torch(self.sim.state.u_i).reshape(nw, nb, 6)
 
-        # Control tensors (writable views)
+        # Control tensors (writable views — all use DOF space)
         self._q_j_ref = wp.to_torch(self.sim.control.q_j_ref).reshape(nw, njd)
         self._dq_j_ref = wp.to_torch(self.sim.control.dq_j_ref).reshape(nw, njd)
         self._tau_j_ref = wp.to_torch(self.sim.control.tau_j_ref).reshape(nw, njd)
diff --git a/newton/_src/solvers/kamino/tests/test_geometry_mesh_heightfield.py b/newton/_src/solvers/kamino/tests/test_geometry_mesh_heightfield.py
new file mode 100644
index 0000000000..453e5f6513
--- /dev/null
+++ b/newton/_src/solvers/kamino/tests/test_geometry_mesh_heightfield.py
@@ -0,0 +1,604 @@
+# SPDX-FileCopyrightText: Copyright (c) 2025 The Newton Developers
+# SPDX-License-Identifier: Apache-2.0
+
+"""Unit tests for mesh and heightfield collision support in Kamino.
+
+Tests the unified collision pipeline, Newton-to-Kamino contact conversion,
+and solver integration with mesh and heightfield shapes via the
+``ModelKamino.from_newton()`` path.
+"""
+
+import unittest
+
+import numpy as np
+import warp as wp
+
+import newton
+from newton._src.solvers.kamino._src.core.bodies import convert_body_com_to_origin
+from newton._src.solvers.kamino._src.core.model import ModelKamino
+from newton._src.solvers.kamino._src.geometry.contacts import ContactsKamino, convert_contacts_newton_to_kamino
+from newton._src.solvers.kamino._src.geometry.unified import CollisionPipelineUnifiedKamino
+from newton._src.solvers.kamino._src.solver_kamino_impl import SolverKaminoImpl
+from newton._src.solvers.kamino._src.utils import logger as msg
+from newton._src.solvers.kamino.tests import setup_tests, test_context
+
+_cuda_available = wp.is_cuda_available()
+
+###
+# Scene Builders
+###
+
+SPHERE_RADIUS = 0.25
+BOX_HALF = 0.5
+
+
+def _build_sphere_on_heightfield(sphere_z=None) -> newton.ModelBuilder:
+    """Sphere resting on a flat heightfield (elevation = 0 everywhere)."""
+    builder = newton.ModelBuilder(up_axis=newton.Axis.Z)
+
+    nrow, ncol = 8, 8
+    elevation = np.zeros((nrow, ncol), dtype=np.float32)
+    hfield = newton.Heightfield(data=elevation, nrow=nrow, ncol=ncol, hx=4.0, hy=4.0)
+
+    cfg = newton.ModelBuilder.ShapeConfig()
+    cfg.margin = 0.0
+    cfg.gap = 1e-3
+
+    builder.add_shape_heightfield(heightfield=hfield, cfg=cfg)
+
+    z = sphere_z if sphere_z is not None else SPHERE_RADIUS
+    body = builder.add_body(xform=wp.transform(p=(0.0, 0.0, z), q=wp.quat_identity()))
+    builder.add_shape_sphere(body, radius=SPHERE_RADIUS, cfg=cfg)
+
+    return builder
+
+
+def _build_sphere_on_mesh_box(sphere_z=None) -> newton.ModelBuilder:
+    """Sphere resting on a box-shaped triangle mesh."""
+    builder = newton.ModelBuilder(up_axis=newton.Axis.Z)
+
+    mesh = newton.Mesh.create_box(BOX_HALF, BOX_HALF, BOX_HALF)
+    cfg = newton.ModelBuilder.ShapeConfig()
+    cfg.margin = 0.0
+    cfg.gap = 0.02
+
+    # Static mesh box centered at origin (top face at z = 0.5)
+    builder.add_shape_mesh(body=-1, mesh=mesh, cfg=cfg)
+
+    # Sphere slightly penetrating the mesh box top face
+    z = sphere_z if sphere_z is not None else (BOX_HALF + SPHERE_RADIUS - 0.005)
+    body = builder.add_body(xform=wp.transform(p=(0.0, 0.0, z), q=wp.quat_identity()))
+    builder.add_shape_sphere(body, radius=SPHERE_RADIUS, cfg=cfg)
+
+    return builder
+
+
+def _build_box_on_heightfield() -> newton.ModelBuilder:
+    """Box resting on a flat heightfield."""
+    builder = newton.ModelBuilder(up_axis=newton.Axis.Z)
+
+    nrow, ncol = 8, 8
+    elevation = np.zeros((nrow, ncol), dtype=np.float32)
+    hfield = newton.Heightfield(data=elevation, nrow=nrow, ncol=ncol, hx=4.0, hy=4.0)
+
+    cfg = newton.ModelBuilder.ShapeConfig()
+    cfg.margin = 0.0
+    cfg.gap = 1e-3
+
+    builder.add_shape_heightfield(heightfield=hfield, cfg=cfg)
+
+    body = builder.add_body(xform=wp.transform(p=(0.0, 0.0, BOX_HALF), q=wp.quat_identity()))
+    builder.add_shape_box(body, hx=BOX_HALF, hy=BOX_HALF, hz=BOX_HALF, cfg=cfg)
+
+    return builder
+
+
+def _build_mixed_scene() -> newton.ModelBuilder:
+    """Scene with both primitive shapes and a mesh — sphere on mesh box + sphere on ground plane."""
+    builder = newton.ModelBuilder(up_axis=newton.Axis.Z)
+
+    mesh = newton.Mesh.create_box(BOX_HALF, BOX_HALF, BOX_HALF)
+    cfg = newton.ModelBuilder.ShapeConfig()
+    cfg.margin = 0.0
+    cfg.gap = 0.02
+
+    # Static mesh box at x=2
+    builder.add_shape_mesh(
+        body=-1,
+        mesh=mesh,
+        xform=wp.transform(p=(2.0, 0.0, 0.0), q=wp.quat_identity()),
+        cfg=cfg,
+    )
+
+    # Ground plane
+    builder.add_ground_plane(cfg=cfg)
+
+    # Sphere on ground plane at origin (touching)
+    body_a = builder.add_body(xform=wp.transform(p=(0.0, 0.0, SPHERE_RADIUS), q=wp.quat_identity()))
+    builder.add_shape_sphere(body_a, radius=SPHERE_RADIUS, cfg=cfg)
+
+    # Sphere on mesh box at x=2 (slightly penetrating)
+    body_b = builder.add_body(
+        xform=wp.transform(p=(2.0, 0.0, BOX_HALF + SPHERE_RADIUS - 0.005), q=wp.quat_identity()),
+    )
+    builder.add_shape_sphere(body_b, radius=SPHERE_RADIUS, cfg=cfg)
+
+    return builder
+
+
+def _build_heightfield_terrain() -> newton.ModelBuilder:
+    """Sphere on a non-flat heightfield with sine-wave terrain."""
+    builder = newton.ModelBuilder(up_axis=newton.Axis.Z)
+
+    nrow, ncol = 20, 20
+    x = np.linspace(-2.0, 2.0, ncol)
+    y = np.linspace(-2.0, 2.0, nrow)
+    xx, yy = np.meshgrid(x, y)
+    elevation = (0.1 * np.sin(xx) * np.cos(yy)).astype(np.float32)
+    # Elevation at center (0,0) ≈ 0
+    hfield = newton.Heightfield(data=elevation, nrow=nrow, ncol=ncol, hx=2.0, hy=2.0)
+
+    cfg = newton.ModelBuilder.ShapeConfig()
+    cfg.margin = 0.0
+    cfg.gap = 1e-3
+
+    builder.add_shape_heightfield(heightfield=hfield, cfg=cfg)
+
+    # Sphere at the center, slightly above terrain surface (elevation ≈ 0)
+    body = builder.add_body(xform=wp.transform(p=(0.0, 0.0, SPHERE_RADIUS), q=wp.quat_identity()))
+    builder.add_shape_sphere(body, radius=SPHERE_RADIUS, cfg=cfg)
+
+    return builder
+
+
+def _build_multi_world_heightfield(num_worlds: int = 3) -> newton.ModelBuilder:
+    """Multi-world scene, each with sphere-on-flat-heightfield."""
+    single = newton.ModelBuilder(up_axis=newton.Axis.Z)
+
+    nrow, ncol = 8, 8
+    elevation = np.zeros((nrow, ncol), dtype=np.float32)
+    hfield = newton.Heightfield(data=elevation, nrow=nrow, ncol=ncol, hx=4.0, hy=4.0)
+
+    cfg = newton.ModelBuilder.ShapeConfig()
+    cfg.margin = 0.0
+    cfg.gap = 1e-3
+
+    body = single.add_body(xform=wp.transform(p=(0.0, 0.0, SPHERE_RADIUS), q=wp.quat_identity()))
+    single.add_shape_sphere(body, radius=SPHERE_RADIUS, cfg=cfg)
+
+    multi = newton.ModelBuilder(up_axis=newton.Axis.Z)
+    for _ in range(num_worlds):
+        multi.add_world(single)
+
+    multi.add_shape_heightfield(heightfield=hfield, cfg=cfg)
+
+    return multi
+
+
+###
+# Helpers
+###
+
+
+def _finalize_and_get_kamino(builder, device):
+    """Finalize Newton model, create Kamino model, data, and state."""
+    newton_model = builder.finalize(device=device)
+    model = ModelKamino.from_newton(newton_model)
+    data = model.data(device=device)
+    state = model.state(device=device)
+    return newton_model, model, data, state
+
+
+def _run_unified_pipeline(model, data, state, device):
+    """Create unified pipeline, allocate contacts, run collision detection."""
+    num_worlds = model.size.num_worlds
+    pipeline = CollisionPipelineUnifiedKamino(
+        model=model,
+        broadphase="nxn",
+        device=device,
+    )
+    contacts = ContactsKamino(capacity=[4096] * num_worlds, device=device)
+    contacts.clear()
+    pipeline.collide(data, state, contacts)
+    return contacts
+
+
+def _run_newton_cd_and_convert(newton_model, device):
+    """Run Newton's CD pipeline and convert contacts to Kamino format."""
+    # Normalize shape_world for single-world models
+    if newton_model.world_count == 1:
+        sw = newton_model.shape_world.numpy()
+        if np.any(sw < 0):
+            sw[sw < 0] = 0
+            newton_model.shape_world.assign(sw)
+
+    state = newton_model.state()
+    newton.eval_fk(newton_model, newton_model.joint_q, newton_model.joint_qd, state)
+    newton_contacts = newton_model.collide(state)
+
+    nc = int(newton_contacts.rigid_contact_count.numpy()[0])
+    kamino_contacts = ContactsKamino(capacity=[max(nc + 64, 256)], device=device)
+    convert_contacts_newton_to_kamino(newton_model, state, newton_contacts, kamino_contacts)
+    wp.synchronize()
+
+    return kamino_contacts, nc
+
+
+def _step_with_newton_cd(builder, device, num_steps=200, dt=0.005):
+    """Build scene, step solver with Newton CD, return final body positions (COM frame)."""
+    newton_model = builder.finalize(device=device)
+
+    # Normalize shape_world
+    if newton_model.world_count == 1:
+        sw = newton_model.shape_world.numpy()
+        if np.any(sw < 0):
+            sw[sw < 0] = 0
+            newton_model.shape_world.assign(sw)
+
+    newton_model.set_gravity((0.0, 0.0, -9.81))
+
+    model = ModelKamino.from_newton(newton_model)
+    model.time.set_uniform_timestep(dt)
+
+    state_p = model.state(device=device)
+    state_n = model.state(device=device)
+    control = model.control(device=device)
+
+    per_world = max(1024, newton_model.rigid_contact_max // max(newton_model.world_count, 1))
+    contacts = ContactsKamino(capacity=[per_world], device=device)
+
+    solver = SolverKaminoImpl(model=model, contacts=contacts)
+    solver.reset(state_out=state_n)
+    state_p.copy_from(state_n)
+
+    newton_state = newton_model.state()
+    newton_contacts = newton_model.contacts()
+
+    for _ in range(num_steps):
+        state_p.copy_from(state_n)
+
+        convert_body_com_to_origin(
+            body_com=model.bodies.i_r_com_i,
+            body_q_com=state_p.q_i,
+            body_q=newton_state.body_q,
+        )
+        newton_model.collide(newton_state, newton_contacts)
+        convert_contacts_newton_to_kamino(newton_model, newton_state, newton_contacts, contacts)
+
+        solver.step(
+            state_in=state_p,
+            state_out=state_n,
+            control=control,
+            contacts=contacts,
+            detector=None,
+        )
+
+    return state_n.q_i.numpy()
+
+
+###
+# Test Classes
+###
+
+
+class TestUnifiedPipelineMeshHeightfield(unittest.TestCase):
+    """Tests Kamino unified collision pipeline with heightfield shapes via from_newton().
+
+    The unified pipeline handles heightfield-vs-convex contacts directly.
+    Each test verifies exact contact counts, contact positions, normals,
+    and signed distances against analytically known values.
+    """
+
+    def setUp(self):
+        if not test_context.setup_done:
+            setup_tests(clear_cache=False)
+        self.default_device = wp.get_device(test_context.device)
+        self.verbose = test_context.verbose
+        if self.verbose:
+            msg.set_log_level(msg.LogLevel.DEBUG)
+        else:
+            msg.reset_log_level()
+
+    def tearDown(self):
+        self.default_device = None
+        if self.verbose:
+            msg.reset_log_level()
+
+    def test_01_sphere_on_flat_heightfield(self):
+        """Sphere touching flat heightfield: 2 contacts (one per cell triangle), normal=(0,0,1), position at z=0."""
+        _, model, data, state = _finalize_and_get_kamino(_build_sphere_on_heightfield(), self.default_device)
+        contacts = _run_unified_pipeline(model, data, state, self.default_device)
+
+        nc = int(contacts.model_active_contacts.numpy()[0])
+        # A sphere centered over a heightfield cell touches both triangles in that cell,
+        # producing 2 contacts on a flat surface.
+        self.assertEqual(nc, 2, f"Sphere-on-flat-heightfield should produce 2 contacts (1 per triangle), got {nc}")
+
+        gapfunc = contacts.gapfunc.numpy()[:nc]
+        pos_a = contacts.position_A.numpy()[:nc]
+
+        for i in range(nc):
+            normal = gapfunc[i, :3]
+            signed_dist = gapfunc[i, 3]
+
+            # Normal must be (0, 0, 1) for a flat heightfield
+            np.testing.assert_allclose(normal, [0.0, 0.0, 1.0], atol=0.05, err_msg=f"Contact {i}: normal must point up")
+
+            # Signed distance: sphere center is at z=R, surface at z=0, so distance ≈ 0
+            self.assertLessEqual(
+                signed_dist, 0.01, f"Contact {i}: signed distance should be near zero, got {signed_dist}"
+            )
+            self.assertGreaterEqual(
+                signed_dist, -0.01, f"Contact {i}: signed distance should be near zero, got {signed_dist}"
+            )
+
+            # Contact point on the heightfield side (position_A) should be near (0, 0, 0)
+            np.testing.assert_allclose(
+                pos_a[i, 2],
+                0.0,
+                atol=0.02,
+                err_msg=f"Contact {i}: heightfield contact z should be ≈ 0, got {pos_a[i, 2]}",
+            )
+
+    def test_02_box_on_flat_heightfield(self):
+        """Box resting on flat heightfield: >=4 contacts, all at z ≈ 0."""
+        _, model, data, state = _finalize_and_get_kamino(_build_box_on_heightfield(), self.default_device)
+        contacts = _run_unified_pipeline(model, data, state, self.default_device)
+
+        nc = int(contacts.model_active_contacts.numpy()[0])
+        self.assertGreaterEqual(nc, 4, f"Box face on heightfield should produce >=4 contacts, got {nc}")
+
+        gapfunc = contacts.gapfunc.numpy()[:nc]
+        for i in range(nc):
+            normal = gapfunc[i, :3]
+            signed_dist = gapfunc[i, 3]
+
+            # All normals should point up
+            np.testing.assert_allclose(
+                normal, [0.0, 0.0, 1.0], atol=0.1, err_msg=f"Contact {i}: normal should point up"
+            )
+            # Signed distance near zero (touching)
+            self.assertLessEqual(
+                abs(signed_dist), 0.02, f"Contact {i}: distance should be near zero, got {signed_dist}"
+            )
+
+        # All contact positions should be at z ≈ 0 and within the box footprint
+        pos_a = contacts.position_A.numpy()[:nc]
+        for i in range(nc):
+            self.assertAlmostEqual(pos_a[i, 2], 0.0, places=1, msg=f"Contact {i}: z should be ≈ 0")
+            self.assertLessEqual(abs(pos_a[i, 0]), BOX_HALF + 0.01, f"Contact {i}: x out of box bounds")
+            self.assertLessEqual(abs(pos_a[i, 1]), BOX_HALF + 0.01, f"Contact {i}: y out of box bounds")
+
+    def test_03_heightfield_terrain(self):
+        """Sphere on sine-wave terrain: contacts generated, normal has upward component."""
+        _, model, data, state = _finalize_and_get_kamino(_build_heightfield_terrain(), self.default_device)
+        contacts = _run_unified_pipeline(model, data, state, self.default_device)
+
+        nc = int(contacts.model_active_contacts.numpy()[0])
+        self.assertGreaterEqual(nc, 1, "Sphere on terrain must produce contacts")
+
+        gapfunc = contacts.gapfunc.numpy()[:nc]
+        for i in range(nc):
+            normal = gapfunc[i, :3]
+            norm_len = np.linalg.norm(normal)
+            self.assertTrue(np.isclose(norm_len, 1.0, atol=1e-4), f"Contact {i}: normal not unit")
+            # On gently undulating terrain near the center, normal should still be mostly upward
+            self.assertGreater(normal[2], 0.7, f"Contact {i}: normal z={normal[2]}, expected mostly up")
+
+    def test_04_multi_world_heightfield(self):
+        """Multi-world sphere-on-heightfield: each world gets exactly 2 contacts (1 per triangle)."""
+        num_worlds = 3
+        _, model, data, state = _finalize_and_get_kamino(
+            _build_multi_world_heightfield(num_worlds), self.default_device
+        )
+        contacts = _run_unified_pipeline(model, data, state, self.default_device)
+
+        nc = int(contacts.model_active_contacts.numpy()[0])
+        expected_total = 2 * num_worlds  # 2 contacts per sphere (one per cell triangle)
+        self.assertEqual(nc, expected_total, f"Expected {expected_total} contacts (2 per world), got {nc}")
+
+        world_counts = contacts.world_active_contacts.numpy()[:num_worlds]
+        for w in range(num_worlds):
+            self.assertEqual(int(world_counts[w]), 2, f"World {w}: expected 2 contacts, got {world_counts[w]}")
+
+    def test_05_no_contacts_when_separated(self):
+        """Sphere far above heightfield must produce zero contacts."""
+        _, model, data, state = _finalize_and_get_kamino(
+            _build_sphere_on_heightfield(sphere_z=SPHERE_RADIUS + 1.0), self.default_device
+        )
+        contacts = _run_unified_pipeline(model, data, state, self.default_device)
+
+        nc = int(contacts.model_active_contacts.numpy()[0])
+        self.assertEqual(nc, 0, f"Separated sphere should produce 0 contacts, got {nc}")
+
+
+class TestNewtonCollisionPathMeshHeightfield(unittest.TestCase):
+    """Tests Newton model.collide() -> convert_contacts_newton_to_kamino() path.
+
+    This is the primary path for mesh collisions in Kamino.  Tests verify
+    that contact data survives conversion with correct body indices,
+    physically plausible normals, positions, and signed distances.
+    """
+
+    def setUp(self):
+        if not test_context.setup_done:
+            setup_tests(clear_cache=False)
+        self.default_device = wp.get_device(test_context.device)
+        self.verbose = test_context.verbose
+        if self.verbose:
+            msg.set_log_level(msg.LogLevel.DEBUG)
+        else:
+            msg.reset_log_level()
+
+    def tearDown(self):
+        self.default_device = None
+        if self.verbose:
+            msg.reset_log_level()
+
+    def test_01_newton_to_kamino_heightfield(self):
+        """Heightfield contacts survive Newton->Kamino conversion with correct geometry."""
+        builder = _build_sphere_on_heightfield()
+        newton_model = builder.finalize(device=self.default_device)
+
+        kamino_contacts, newton_count = _run_newton_cd_and_convert(newton_model, self.default_device)
+        self.assertGreater(newton_count, 0, "Newton must produce contacts for sphere on heightfield")
+
+        nc = int(kamino_contacts.model_active_contacts.numpy()[0])
+        self.assertGreater(nc, 0, "Conversion must preserve contacts")
+
+        gapfunc = kamino_contacts.gapfunc.numpy()[:nc]
+        bid_AB = kamino_contacts.bid_AB.numpy()[:nc]
+        pos_a = kamino_contacts.position_A.numpy()[:nc]
+
+        for i in range(nc):
+            # A/B convention: bid_B must be dynamic (>= 0)
+            self.assertGreaterEqual(int(bid_AB[i, 1]), 0, f"Contact {i}: bid_B must be >= 0")
+
+            # Normal must be approximately upward
+            normal = gapfunc[i, :3]
+            np.testing.assert_allclose(
+                normal, [0.0, 0.0, 1.0], atol=0.1, err_msg=f"Contact {i}: normal should point up"
+            )
+
+            # Contact position on heightfield should be near z=0
+            self.assertAlmostEqual(pos_a[i, 2], 0.0, places=1, msg=f"Contact {i}: position z should be ≈ 0")
+
+            # Signed distance should be non-positive (penetrating or touching)
+            self.assertLessEqual(gapfunc[i, 3], 0.01, f"Contact {i}: distance should be <= 0")
+
+    @unittest.skipUnless(_cuda_available, "mesh collision requires CUDA")
+    def test_02_newton_to_kamino_mesh(self):
+        """Mesh box contacts survive Newton->Kamino conversion with correct geometry."""
+        builder = _build_sphere_on_mesh_box()
+        newton_model = builder.finalize(device=self.default_device)
+
+        kamino_contacts, newton_count = _run_newton_cd_and_convert(newton_model, self.default_device)
+        self.assertGreater(newton_count, 0, "Newton must produce contacts for sphere on mesh")
+
+        nc = int(kamino_contacts.model_active_contacts.numpy()[0])
+        self.assertGreater(nc, 0, "Conversion must preserve contacts")
+
+        gapfunc = kamino_contacts.gapfunc.numpy()[:nc]
+        bid_AB = kamino_contacts.bid_AB.numpy()[:nc]
+        pos_a = kamino_contacts.position_A.numpy()[:nc]
+
+        for i in range(nc):
+            self.assertGreaterEqual(int(bid_AB[i, 1]), 0, f"Contact {i}: bid_B must be >= 0")
+
+            normal = gapfunc[i, :3]
+            # Normal should point mostly upward (sphere on top of mesh box)
+            self.assertGreater(normal[2], 0.5, f"Contact {i}: normal z={normal[2]}, expected upward")
+
+            # Contact on mesh top face should be near z = BOX_HALF = 0.5
+            self.assertAlmostEqual(pos_a[i, 2], BOX_HALF, delta=0.1, msg=f"Contact {i}: z should be near mesh top face")
+
+    @unittest.skipUnless(_cuda_available, "mesh collision requires CUDA")
+    def test_03_newton_to_kamino_mixed(self):
+        """Mixed scene: both primitive-plane and mesh contacts converted correctly."""
+        builder = _build_mixed_scene()
+        newton_model = builder.finalize(device=self.default_device)
+
+        kamino_contacts, newton_count = _run_newton_cd_and_convert(newton_model, self.default_device)
+        self.assertGreater(newton_count, 0, "Newton must produce contacts")
+
+        nc = int(kamino_contacts.model_active_contacts.numpy()[0])
+        # Must have contacts for both spheres (one on plane, one on mesh)
+        self.assertGreaterEqual(nc, 2, f"Mixed scene should have >=2 contacts, got {nc}")
+
+        # Verify we got contacts involving different bodies
+        bid_AB = kamino_contacts.bid_AB.numpy()[:nc]
+        dynamic_bodies = {int(bid_AB[i, 1]) for i in range(nc)}
+        self.assertGreaterEqual(
+            len(dynamic_bodies), 2, f"Should have contacts for >=2 different bodies, got {dynamic_bodies}"
+        )
+
+    @unittest.skipUnless(_cuda_available, "mesh collision requires CUDA")
+    def test_04_no_contacts_when_separated(self):
+        """Sphere far above mesh box must produce zero contacts after conversion."""
+        builder = _build_sphere_on_mesh_box(sphere_z=BOX_HALF + SPHERE_RADIUS + 2.0)
+        newton_model = builder.finalize(device=self.default_device)
+
+        kamino_contacts, newton_count = _run_newton_cd_and_convert(newton_model, self.default_device)
+        self.assertEqual(newton_count, 0, "Separated shapes should produce 0 Newton contacts")
+
+        nc = int(kamino_contacts.model_active_contacts.numpy()[0])
+        self.assertEqual(nc, 0, "Separated shapes should produce 0 Kamino contacts")
+
+
+@unittest.skipUnless(_cuda_available, "Kamino solver requires CUDA")
+class TestSolverWithMeshHeightfield(unittest.TestCase):
+    """Tests Kamino solver produces physically correct behavior with mesh/heightfield contacts.
+
+    Drops objects onto surfaces and verifies they come to rest at the
+    analytically expected height rather than falling through or floating.
+    """
+
+    def setUp(self):
+        if not test_context.setup_done:
+            setup_tests(clear_cache=False)
+        self.default_device = wp.get_device(test_context.device)
+        self.verbose = test_context.verbose
+        if self.verbose:
+            msg.set_log_level(msg.LogLevel.DEBUG)
+        else:
+            msg.reset_log_level()
+
+    def tearDown(self):
+        self.default_device = None
+        if self.verbose:
+            msg.reset_log_level()
+
+    def test_01_sphere_falls_onto_heightfield(self):
+        """Sphere dropped from 0.5m above flat heightfield must rest at z ≈ SPHERE_RADIUS."""
+        drop_height = SPHERE_RADIUS + 0.5
+        builder = _build_sphere_on_heightfield(sphere_z=drop_height)
+
+        q_i = _step_with_newton_cd(builder, self.default_device, num_steps=500, dt=0.005)
+
+        # Sphere COM should be near SPHERE_RADIUS (resting on z=0 surface)
+        sphere_z = float(q_i[0, 2])
+        expected_z = SPHERE_RADIUS  # 0.25
+
+        # Tight tolerance: must be within 5cm of expected rest height
+        self.assertAlmostEqual(
+            sphere_z,
+            expected_z,
+            delta=0.05,
+            msg=f"Sphere should rest at z≈{expected_z}, got z={sphere_z:.4f}",
+        )
+
+    def test_02_sphere_falls_onto_mesh_box(self):
+        """Sphere dropped from 0.5m above mesh box must rest at z ≈ BOX_HALF + SPHERE_RADIUS."""
+        drop_height = BOX_HALF + SPHERE_RADIUS + 0.5
+        builder = _build_sphere_on_mesh_box(sphere_z=drop_height)
+
+        q_i = _step_with_newton_cd(builder, self.default_device, num_steps=500, dt=0.005)
+
+        sphere_z = float(q_i[0, 2])
+        expected_z = BOX_HALF + SPHERE_RADIUS  # 0.75
+
+        self.assertAlmostEqual(
+            sphere_z,
+            expected_z,
+            delta=0.05,
+            msg=f"Sphere should rest at z≈{expected_z}, got z={sphere_z:.4f}",
+        )
+
+    def test_03_sphere_does_not_fall_through_heightfield(self):
+        """Sphere placed at contact boundary must not fall below the surface after stepping."""
+        builder = _build_sphere_on_heightfield(sphere_z=SPHERE_RADIUS)
+
+        q_i = _step_with_newton_cd(builder, self.default_device, num_steps=200, dt=0.005)
+
+        sphere_z = float(q_i[0, 2])
+        # With gravity pulling down, if contacts aren't working the sphere goes negative.
+        # Allow a small margin for numerical settling but it must stay above the surface.
+        self.assertGreater(
+            sphere_z,
+            SPHERE_RADIUS - 0.02,
+            f"Sphere fell through heightfield: z={sphere_z:.4f}, min allowed={SPHERE_RADIUS - 0.02}",
+        )
+
+
+if __name__ == "__main__":
+    unittest.main()
diff --git a/newton/_src/solvers/kamino/tests/test_geometry_unified.py b/newton/_src/solvers/kamino/tests/test_geometry_unified.py
index 2d4fb56db0..e04ab1dcc2 100644
--- a/newton/_src/solvers/kamino/tests/test_geometry_unified.py
+++ b/newton/_src/solvers/kamino/tests/test_geometry_unified.py
@@ -629,7 +629,7 @@ def _make_two_sphere_builder(self, group_a=1, collides_a=1, group_b=1, collides_
     def test_00_nxn_sphere_on_plane_generates_contacts(self):
         """Sphere resting on a plane via NXN broadphase must produce contacts.
 
-        Validates that shape_collision_radius is populated correctly for
+        Validates that collision_radius is populated correctly for
         infinite planes (which need a large bounding-sphere radius for
         AABB-based broadphase modes to detect them).
         """
diff --git a/newton/_src/solvers/mujoco/kernels.py b/newton/_src/solvers/mujoco/kernels.py
index 375923f859..98af3a8188 100644
--- a/newton/_src/solvers/mujoco/kernels.py
+++ b/newton/_src/solvers/mujoco/kernels.py
@@ -27,9 +27,15 @@ def _import_contact_force_fn():
 
 # Constants
 MJ_MINVAL = 2.220446049250313e-16
+MJ_MINMU = 1e-5
 
 
 # Utility functions
+@wp.func
+def safe_div(x: float, y: float) -> float:
+    return x / wp.where(y != 0.0, y, MJ_MINVAL)
+
+
 @wp.func
 def orthogonals(a: wp.vec3):
     y = wp.vec3(0.0, 1.0, 0.0)
@@ -122,7 +128,7 @@ def contact_params(
     geoms: wp.vec2i,
     worldid: int,
 ):
-    # See function contact_params in mujoco_warp, file collision_primitive.py
+    # See function contact_params in mujoco_warp, file collision_core.py
 
     g1 = geoms[0]
     g2 = geoms[1]
@@ -130,32 +136,39 @@ def contact_params(
     p1 = geom_priority[g1]
     p2 = geom_priority[g2]
 
-    solmix1 = geom_solmix[worldid, g1]
-    solmix2 = geom_solmix[worldid, g2]
-
-    mix = solmix1 / (solmix1 + solmix2)
-    mix = wp.where((solmix1 < MJ_MINVAL) and (solmix2 < MJ_MINVAL), 0.5, mix)
-    mix = wp.where((solmix1 < MJ_MINVAL) and (solmix2 >= MJ_MINVAL), 0.0, mix)
-    mix = wp.where((solmix1 >= MJ_MINVAL) and (solmix2 < MJ_MINVAL), 1.0, mix)
-    mix = wp.where(p1 == p2, mix, wp.where(p1 > p2, 1.0, 0.0))
-
-    # Sum margins for consistency with thickness summing
-    margin = geom_margin[worldid, g1] + geom_margin[worldid, g2]
-    gap = geom_gap[worldid, g1] + geom_gap[worldid, g2]
-
     condim1 = geom_condim[g1]
     condim2 = geom_condim[g2]
-    condim = wp.where(p1 == p2, wp.max(condim1, condim2), wp.where(p1 > p2, condim1, condim2))
 
-    max_geom_friction = wp.max(geom_friction[worldid, g1], geom_friction[worldid, g2])
+    if p1 > p2:
+        mix = 1.0
+        condim = condim1
+        resolved_friction = geom_friction[worldid, g1]
+    elif p2 > p1:
+        mix = 0.0
+        condim = condim2
+        resolved_friction = geom_friction[worldid, g2]
+    else:
+        solmix1 = geom_solmix[worldid, g1]
+        solmix2 = geom_solmix[worldid, g2]
+        mix = safe_div(solmix1, solmix1 + solmix2)
+        mix = wp.where((solmix1 < MJ_MINVAL) and (solmix2 < MJ_MINVAL), 0.5, mix)
+        mix = wp.where((solmix1 < MJ_MINVAL) and (solmix2 >= MJ_MINVAL), 0.0, mix)
+        mix = wp.where((solmix1 >= MJ_MINVAL) and (solmix2 < MJ_MINVAL), 1.0, mix)
+        condim = wp.max(condim1, condim2)
+        resolved_friction = wp.max(geom_friction[worldid, g1], geom_friction[worldid, g2])
+
     friction = vec5(
-        max_geom_friction[0],
-        max_geom_friction[0],
-        max_geom_friction[1],
-        max_geom_friction[2],
-        max_geom_friction[2],
+        wp.max(MJ_MINMU, resolved_friction[0]),
+        wp.max(MJ_MINMU, resolved_friction[0]),
+        wp.max(MJ_MINMU, resolved_friction[1]),
+        wp.max(MJ_MINMU, resolved_friction[2]),
+        wp.max(MJ_MINMU, resolved_friction[2]),
     )
 
+    # Sum margins for consistency with thickness summing
+    margin = geom_margin[worldid, g1] + geom_margin[worldid, g2]
+    gap = geom_gap[worldid, g1] + geom_gap[worldid, g2]
+
     if geom_solref[worldid, g1].x > 0.0 and geom_solref[worldid, g2].x > 0.0:
         solref = mix * geom_solref[worldid, g1] + (1.0 - mix) * geom_solref[worldid, g2]
     else:
@@ -252,179 +265,240 @@ def convert_newton_contacts_to_mjwarp_kernel(
     # Values to clear - see _zero_collision_arrays kernel from mujoco_warp
     nworld_in: int,
     ncollision_out: wp.array[int],
+    # Fast-path generation tracking
+    contact_generation: wp.array[wp.int32],
+    last_contact_generation: wp.array[wp.int32],
+    tid_to_cid: wp.array[wp.int32],
+    last_nacon_count: wp.array[wp.int32],
 ):
-    # See kernel solve_body_contact_positions for reference
     # nacon_out must be zeroed before this kernel is launched so that
     # wp.atomic_add below produces the correct compacted count.
+    #
+    # When the contact set hasn't changed since the last full pass
+    # (contact_generation == last_contact_generation), the kernel takes a
+    # fast path that only recomputes the body-q-dependent fields (dist, pos)
+    # and resets efc_address.  All other MJWarp contact fields (frame,
+    # friction, solref, solimp, condim, geom, worldid, includemargin) are
+    # still valid from the previous full pass.
 
     tid = wp.tid()
 
     count = rigid_contact_count[0]
 
-    if tid == 0:
+    gen = contact_generation[0]
+    last_gen = last_contact_generation[0]
+    needs_full = gen != last_gen
+
+    if needs_full:
+        # ── FULL PATH ────────────────────────────────────────────────────
+        # Runs on the first substep after collision detection.  Identical to
+        # the original kernel plus recording the tid→cid mapping.
+
+        if tid == 0:
+            if count > naconmax:
+                wp.printf(
+                    "Number of Newton contacts (%d) exceeded MJWarp limit (%d). Increase nconmax.\n",
+                    count,
+                    naconmax,
+                )
+            ncollision_out[0] = 0
+
         if count > naconmax:
-            wp.printf(
-                "Number of Newton contacts (%d) exceeded MJWarp limit (%d). Increase nconmax.\n",
-                count,
-                naconmax,
-            )
-        ncollision_out[0] = 0
+            count = naconmax
 
-    if count > naconmax:
-        count = naconmax
+        if tid >= count:
+            tid_to_cid[tid] = -1
+            return
 
-    if tid >= count:
-        return
+        shape_a = rigid_contact_shape0[tid]
+        shape_b = rigid_contact_shape1[tid]
 
-    shape_a = rigid_contact_shape0[tid]
-    shape_b = rigid_contact_shape1[tid]
+        if shape_a < 0 or shape_b < 0:
+            tid_to_cid[tid] = -1
+            return
 
-    # Skip invalid contacts - both shapes must be specified
-    if shape_a < 0 or shape_b < 0:
-        return
+        geom_a = newton_shape_to_mjc_geom[shape_a]
+        geom_b = newton_shape_to_mjc_geom[shape_b]
 
-    # --- Filter contacts that would produce degenerate efc_D values ----------
-    # A body is "immovable" from the MuJoCo solver's perspective when it
-    # contributes zero (or near-zero) invweight.  Three cases:
-    #
-    #  1. Static shapes (body < 0) — no MuJoCo body at all.
-    #  2. Kinematic bodies (BodyFlags.KINEMATIC) — Newton sets armature=1e10
-    #     on their DOFs, giving near-zero invweight even though MuJoCo still
-    #     sees DOFs (body_weldid != 0).
-    #  3. Fixed-root bodies welded to the world body (body_weldid == 0) —
-    #     MuJoCo merges them into weld group 0, giving zero invweight.
-    #
-    # Each body is classified independently; a contact is skipped when both
-    # sides are immovable.
+        body_a = shape_body[shape_a]
+        body_b = shape_body[shape_b]
 
-    geom_a = newton_shape_to_mjc_geom[shape_a]
-    geom_b = newton_shape_to_mjc_geom[shape_b]
+        mj_body_a = geom_bodyid[geom_a]
+        mj_body_b = geom_bodyid[geom_b]
 
-    body_a = shape_body[shape_a]
-    body_b = shape_body[shape_b]
+        # A body is "immovable" in three cases:
+        #  1. body < 0 → static shape (no body)
+        #  2. BodyFlags.KINEMATIC → kinematic body (e.g. armature=1e10)
+        #  3. body_weldid == 0 → fixed root body (worldbody)
+        # Pairs where both sides are immovable produce degenerate efc_D values
+        # in MuJoCo's solver, so we skip them.
+        a_immovable = body_a < 0 or (body_flags[body_a] & BodyFlags.KINEMATIC) != 0 or body_weldid[mj_body_a] == 0
+        b_immovable = body_b < 0 or (body_flags[body_b] & BodyFlags.KINEMATIC) != 0 or body_weldid[mj_body_b] == 0
 
-    mj_body_a = geom_bodyid[geom_a]
-    mj_body_b = geom_bodyid[geom_b]
+        if a_immovable and b_immovable:
+            tid_to_cid[tid] = -1
+            return
 
-    a_immovable = body_a < 0 or (body_flags[body_a] & BodyFlags.KINEMATIC) != 0 or body_weldid[mj_body_a] == 0
-    b_immovable = body_b < 0 or (body_flags[body_b] & BodyFlags.KINEMATIC) != 0 or body_weldid[mj_body_b] == 0
+        X_wb_a = wp.transform_identity()
+        X_wb_b = wp.transform_identity()
+        if body_a >= 0:
+            X_wb_a = body_q[body_a]
+        if body_b >= 0:
+            X_wb_b = body_q[body_b]
+
+        bx_a = wp.transform_point(X_wb_a, rigid_contact_point0[tid])
+        bx_b = wp.transform_point(X_wb_b, rigid_contact_point1[tid])
+
+        # rigid_contact_margin0/1 = radius_eff + shape_margin per shape.
+        # Subtract shape_margin so dist is the surface-to-surface distance;
+        # shape_margin is handled by geom_margin (MuJoCo's includemargin).
+        radius_eff = (rigid_contact_margin0[tid] - shape_margin[shape_a]) + (
+            rigid_contact_margin1[tid] - shape_margin[shape_b]
+        )
 
-    if a_immovable and b_immovable:
-        return
+        n = rigid_contact_normal[tid]
+        dist = wp.dot(n, bx_b - bx_a) - radius_eff
+        pos = 0.5 * (bx_a + bx_b)
+
+        frame = make_frame(n)
+
+        geoms = wp.vec2i(geom_a, geom_b)
+
+        worldid = body_a // bodies_per_world
+        if body_a < 0:
+            worldid = body_b // bodies_per_world
+
+        margin, gap, condim, friction, solref, solreffriction, solimp = contact_params(
+            geom_condim,
+            geom_priority,
+            geom_solmix,
+            geom_solref,
+            geom_solimp,
+            geom_friction,
+            geom_margin,
+            geom_gap,
+            geoms,
+            worldid,
+        )
 
-    X_wb_a = wp.transform_identity()
-    X_wb_b = wp.transform_identity()
-    if body_a >= 0:
-        X_wb_a = body_q[body_a]
+        # Convert Newton per-contact stiffness/damping to MuJoCo solref
+        # (timeconst, dampratio).  solimp is set to approximate a linear
+        # force-displacement relationship at rest, compensating for impedance
+        # scaling.  See https://mujoco.readthedocs.io/en/latest/modeling.html#solver-parameters
+        if rigid_contact_stiffness:
+            contact_ke = rigid_contact_stiffness[tid]
+            if contact_ke > 0.0:
+                imp = solimp[1]
+                solimp = vec5(imp, imp, 0.001, 1.0, 0.5)
+                contact_ke = contact_ke * (1.0 - imp)
+                kd = rigid_contact_damping[tid]
+                if kd > 0.0:
+                    timeconst = 2.0 / kd
+                    dampratio = wp.sqrt(1.0 / (timeconst * timeconst * contact_ke))
+                else:
+                    timeconst = wp.sqrt(1.0 / contact_ke)
+                    dampratio = 1.0
+                solref = wp.vec2(timeconst, dampratio)
+
+            friction_scale = rigid_contact_friction[tid]
+            if friction_scale > 0.0:
+                friction = vec5(
+                    friction[0] * friction_scale,
+                    friction[1] * friction_scale,
+                    friction[2],
+                    friction[3],
+                    friction[4],
+                )
+
+        cid = wp.atomic_add(nacon_out, 0, 1)
+        if cid >= naconmax:
+            tid_to_cid[tid] = -1
+            return
 
-    if body_b >= 0:
-        X_wb_b = body_q[body_b]
+        tid_to_cid[tid] = cid
+
+        write_contact(
+            dist_in=dist,
+            pos_in=pos,
+            frame_in=frame,
+            margin_in=margin,
+            gap_in=gap,
+            condim_in=condim,
+            friction_in=friction,
+            solref_in=solref,
+            solreffriction_in=solreffriction,
+            solimp_in=solimp,
+            geoms_in=geoms,
+            worldid_in=worldid,
+            contact_id_in=cid,
+            contact_dist_out=contact_dist_out,
+            contact_pos_out=contact_pos_out,
+            contact_frame_out=contact_frame_out,
+            contact_includemargin_out=contact_includemargin_out,
+            contact_friction_out=contact_friction_out,
+            contact_solref_out=contact_solref_out,
+            contact_solreffriction_out=contact_solreffriction_out,
+            contact_solimp_out=contact_solimp_out,
+            contact_dim_out=contact_dim_out,
+            contact_geom_out=contact_geom_out,
+            contact_efc_address_out=contact_efc_address_out,
+            contact_worldid_out=contact_worldid_out,
+        )
+    else:
+        # ── FAST PATH ────────────────────────────────────────────────────
+        # Subsequent substeps with the same contact set.  Only dist, pos,
+        # and efc_address need updating; all other MJWarp fields are still
+        # valid from the full pass.
+        #
+        # NOTE: rigid_contact_normal is computed once by the narrow phase
+        # and is invariant across substeps.  The fast path is only correct
+        # when collide() has not been called since the last full pass.
 
-    bx_a = wp.transform_point(X_wb_a, rigid_contact_point0[tid])
-    bx_b = wp.transform_point(X_wb_b, rigid_contact_point1[tid])
+        if tid == 0:
+            ncollision_out[0] = 0
+            # Restore the compacted contact count from the full pass
+            nacon_out[0] = last_nacon_count[0]
 
-    # rigid_contact_margin0/1 = radius_eff + shape_margin per shape.
-    # Subtract only radius_eff so dist is the surface-to-surface distance.
-    # shape_margin is handled by geom_margin (MuJoCo's includemargin threshold).
-    radius_eff = (rigid_contact_margin0[tid] - shape_margin[shape_a]) + (
-        rigid_contact_margin1[tid] - shape_margin[shape_b]
-    )
+        cid = tid_to_cid[tid]
+        if cid < 0:
+            return
 
-    n = rigid_contact_normal[tid]
-    dist = wp.dot(n, bx_b - bx_a) - radius_eff
-
-    # Contact position: use midpoint between contact points (as in XPBD kernel)
-    pos = 0.5 * (bx_a + bx_b)
-
-    # Build contact frame
-    frame = make_frame(n)
-
-    geoms = wp.vec2i(geom_a, geom_b)
-
-    # Compute world ID from body indices (more reliable than shape mapping for static shapes)
-    # Static shapes like ground planes share the same Newton shape index across all worlds,
-    # so the inverse shape mapping may have the wrong world ID for them.
-    # Using body indices: body_index = world * bodies_per_world + body_in_world
-    worldid = body_a // bodies_per_world
-    if body_a < 0:
-        worldid = body_b // bodies_per_world
-
-    margin, gap, condim, friction, solref, solreffriction, solimp = contact_params(
-        geom_condim,
-        geom_priority,
-        geom_solmix,
-        geom_solref,
-        geom_solimp,
-        geom_friction,
-        geom_margin,
-        geom_gap,
-        geoms,
-        worldid,
-    )
+        shape_a = rigid_contact_shape0[tid]
+        shape_b = rigid_contact_shape1[tid]
+        body_a = shape_body[shape_a]
+        body_b = shape_body[shape_b]
 
-    if rigid_contact_stiffness:
-        # Use per-contact stiffness/damping parameters
-        contact_ke = rigid_contact_stiffness[tid]
-        if contact_ke > 0.0:
-            # set solimp to approximate linear force-to-displacement relationship at rest
-            # see https://mujoco.readthedocs.io/en/latest/modeling.html#solver-parameters
-            imp = solimp[1]
-            solimp = vec5(imp, imp, 0.001, 1.0, 0.5)
-            contact_ke = contact_ke * (1.0 - imp)  # compensate for impedance scaling
-            kd = rigid_contact_damping[tid]
-            # convert from stiffness/damping to MuJoCo's solref timeconst and dampratio
-            if kd > 0.0:
-                timeconst = 2.0 / kd
-                dampratio = wp.sqrt(1.0 / (timeconst * timeconst * contact_ke))
-            else:
-                # if no damping was set, use default damping ratio
-                timeconst = wp.sqrt(1.0 / contact_ke)
-                dampratio = 1.0
-
-            solref = wp.vec2(timeconst, dampratio)
-
-        friction_scale = rigid_contact_friction[tid]
-        if friction_scale > 0.0:
-            friction = vec5(
-                friction[0] * friction_scale,
-                friction[1] * friction_scale,
-                friction[2],
-                friction[3],
-                friction[4],
-            )
+        X_wb_a = wp.transform_identity()
+        X_wb_b = wp.transform_identity()
+        if body_a >= 0:
+            X_wb_a = body_q[body_a]
+        if body_b >= 0:
+            X_wb_b = body_q[body_b]
 
-    # Atomically claim a compacted output slot (contacts may be filtered above)
-    cid = wp.atomic_add(nacon_out, 0, 1)
-    if cid >= naconmax:
-        return
+        bx_a = wp.transform_point(X_wb_a, rigid_contact_point0[tid])
+        bx_b = wp.transform_point(X_wb_b, rigid_contact_point1[tid])
 
-    write_contact(
-        dist_in=dist,
-        pos_in=pos,
-        frame_in=frame,
-        margin_in=margin,
-        gap_in=gap,
-        condim_in=condim,
-        friction_in=friction,
-        solref_in=solref,
-        solreffriction_in=solreffriction,
-        solimp_in=solimp,
-        geoms_in=geoms,
-        worldid_in=worldid,
-        contact_id_in=cid,
-        contact_dist_out=contact_dist_out,
-        contact_pos_out=contact_pos_out,
-        contact_frame_out=contact_frame_out,
-        contact_includemargin_out=contact_includemargin_out,
-        contact_friction_out=contact_friction_out,
-        contact_solref_out=contact_solref_out,
-        contact_solreffriction_out=contact_solreffriction_out,
-        contact_solimp_out=contact_solimp_out,
-        contact_dim_out=contact_dim_out,
-        contact_geom_out=contact_geom_out,
-        contact_efc_address_out=contact_efc_address_out,
-        contact_worldid_out=contact_worldid_out,
-    )
+        radius_eff = (rigid_contact_margin0[tid] - shape_margin[shape_a]) + (
+            rigid_contact_margin1[tid] - shape_margin[shape_b]
+        )
+
+        n = rigid_contact_normal[tid]
+        contact_dist_out[cid] = wp.dot(n, bx_b - bx_a) - radius_eff
+        contact_pos_out[cid] = 0.5 * (bx_a + bx_b)
+
+        for i in range(contact_efc_address_out.shape[1]):
+            contact_efc_address_out[cid, i] = -1
+
+
+@wp.kernel(enable_backward=False)
+def _snapshot_nacon_count(
+    nacon: wp.array[wp.int32],
+    last_nacon_count: wp.array[wp.int32],
+    contact_generation: wp.array[wp.int32],
+    last_contact_generation: wp.array[wp.int32],
+):
+    last_nacon_count[0] = nacon[0]
+    last_contact_generation[0] = contact_generation[0]
 
 
 @wp.kernel
diff --git a/newton/_src/solvers/mujoco/solver_mujoco.py b/newton/_src/solvers/mujoco/solver_mujoco.py
index eb5d92804c..fc5e11d6ae 100644
--- a/newton/_src/solvers/mujoco/solver_mujoco.py
+++ b/newton/_src/solvers/mujoco/solver_mujoco.py
@@ -25,6 +25,7 @@
     ModelBuilder,
     State,
 )
+from ...sim.contacts import GENERATION_SENTINEL as _GENERATION_SENTINEL
 from ...sim.graph_coloring import color_graph, plot_graph
 from ...utils import topological_sort
 from ...utils.benchmark import event_scope
@@ -32,6 +33,7 @@
 from ..flags import SolverNotifyFlags
 from ..solver import SolverBase
 from .kernels import (
+    _snapshot_nacon_count,
     apply_mjc_body_f_kernel,
     apply_mjc_control_kernel,
     apply_mjc_free_joint_f_to_body_f_kernel,
@@ -2777,6 +2779,7 @@ def __init__(
         wind: tuple | None = None,
         magnetic: tuple | None = None,
         use_mujoco_cpu: bool = False,
+        enable_multiccd: bool = False,
         disable_contacts: bool = False,
         update_data_interval: int = 1,
         save_to_mjcf: str | None = None,
@@ -2815,6 +2818,7 @@ def __init__(
             wind: Wind velocity vector (x, y, z) for lift and drag forces. If None, uses model custom attribute or MuJoCo's default (0, 0, 0).
             magnetic: Global magnetic flux vector (x, y, z). If None, uses model custom attribute or MuJoCo's default (0, -0.5, 0).
             use_mujoco_cpu: If True, use the MuJoCo-C CPU backend instead of `mujoco_warp`.
+            enable_multiccd: If True, enable multi-CCD contact generation (up to 4 contact points per geom pair instead of 1). Note: geom pairs where either geom has ``margin > 0`` always produce a single contact regardless of this flag.
             disable_contacts: If True, disable contact computation in MuJoCo.
             update_data_interval: Frequency (in simulation steps) at which to update the MuJoCo Data object from the Newton state. If 0, Data is never updated after initialization.
             save_to_mjcf: Optional path to save the generated MJCF model file.
@@ -2913,15 +2917,28 @@ def __init__(
         self._viewer = None
         """Instance of the MuJoCo viewer for debugging."""
 
+        enableflags = 0
+        if enable_multiccd:
+            enableflags |= mujoco.mjtEnableBit.mjENBL_MULTICCD
         disableflags = 0
         if disable_contacts:
             disableflags |= mujoco.mjtDisableBit.mjDSBL_CONTACT
         self.use_mujoco_cpu = use_mujoco_cpu
         if separate_worlds is None:
             separate_worlds = not use_mujoco_cpu and model.world_count > 1
+        # Lazy-allocated buffers for the fast-path contact conversion optimisation.
+        # See _convert_contacts_to_mjwarp / convert_newton_contacts_to_mjwarp_kernel.
+        # Initialised before _convert_to_mjc because notify_model_changed (called
+        # during conversion) may call _invalidate_contact_fast_path.
+        self._contact_tid_to_cid: wp.array[wp.int32] | None = None
+        self._last_contact_generation: wp.array[wp.int32] | None = None
+        self._last_nacon_count: wp.array[wp.int32] | None = None
+        self._last_contacts_id: int | None = None
+
         with wp.ScopedTimer("convert_model_to_mujoco", active=False):
             self._convert_to_mjc(
                 model,
+                enableflags=enableflags,
                 disableflags=disableflags,
                 disable_contacts=disable_contacts,
                 separate_worlds=separate_worlds,
@@ -2999,19 +3016,51 @@ def _enable_rne_postconstraint(self, state_out: State):
                 print("Setting model.sensor_rne_postconstraint True")
             m.sensor_rne_postconstraint = True
 
+    def _invalidate_contact_fast_path(self):
+        """Force the next contact conversion to take the full path.
+
+        Called when cached MJWarp contact fields (friction, solref, solimp,
+        etc.) may be stale — e.g. after :meth:`notify_model_changed` updates
+        geom properties.
+        """
+        if self._last_contact_generation is not None:
+            self._last_contact_generation.fill_(_GENERATION_SENTINEL)
+            self._last_nacon_count.zero_()
+
     def _convert_contacts_to_mjwarp(self, model: Model, state_in: State, contacts: Contacts):
         # Ensure the inverse shape mapping exists (lazy creation)
         if self.newton_shape_to_mjc_geom is None:
             self._create_inverse_shape_mapping()
 
-        # Zero nacon before the kernel — the kernel uses atomic_add to count
-        # only the contacts that survive immovable-pair filtering.
+        # The kernel only produces valid output for tid < naconmax (the full
+        # path clamps count and rejects cid >= naconmax).  Launching more
+        # threads than naconmax wastes GPU resources, so cap the grid size.
+        launch_dim = min(contacts.rigid_contact_max, self.mjw_data.naconmax)
+
+        # Lazy-allocate fast-path buffers; reallocate if launch_dim grew
+        # (e.g. a different Contacts object with a larger rigid_contact_max).
+        # Also invalidate when the Contacts instance changes — a different
+        # object's contact_generation could coincidentally match our cached
+        # last_contact_generation while containing entirely different data.
+        contacts_id = id(contacts.contact_generation)
+        needs_realloc = self._contact_tid_to_cid is None or self._contact_tid_to_cid.shape[0] < launch_dim
+        contacts_changed = self._last_contacts_id != contacts_id
+
+        if needs_realloc or contacts_changed:
+            if needs_realloc:
+                self._contact_tid_to_cid = wp.full(launch_dim, -1, dtype=wp.int32, device=model.device)
+            self._last_contact_generation = wp.full(1, _GENERATION_SENTINEL, dtype=wp.int32, device=model.device)
+            self._last_nacon_count = wp.zeros(1, dtype=wp.int32, device=model.device)
+            self._last_contacts_id = contacts_id
+
+        # Zero nacon before the kernel — the full path uses atomic_add to count
+        # contacts; the fast path restores the count from last_nacon_count.
         self.mjw_data.nacon.zero_()
 
         bodies_per_world = self.model.body_count // self.model.world_count
         wp.launch(
             convert_newton_contacts_to_mjwarp_kernel,
-            dim=(contacts.rigid_contact_max,),
+            dim=(launch_dim,),
             inputs=[
                 state_in.body_q,
                 model.shape_body,
@@ -3059,6 +3108,30 @@ def _convert_contacts_to_mjwarp(self, model: Model, state_in: State, contacts: C
                 # Data to clear
                 self.mjw_data.nworld,
                 self.mjw_data.ncollision,
+                # Fast-path generation tracking
+                contacts.contact_generation,
+                self._last_contact_generation,
+                self._contact_tid_to_cid,
+                self._last_nacon_count,
+            ],
+            device=model.device,
+        )
+
+        # Snapshot the final nacon count and generation so the fast path can
+        # restore them on subsequent substeps.  Runs as a separate dim=1
+        # kernel AFTER the main kernel completes so that:
+        #  - nacon_out has its final value (from atomic_add on full path, or
+        #    restored from last_nacon_count on fast path)
+        #  - last_contact_generation is only updated after ALL threads in the
+        #    main kernel have read it (avoids a cross-block race)
+        wp.launch(
+            _snapshot_nacon_count,
+            dim=1,
+            inputs=[
+                self.mjw_data.nacon,
+                self._last_nacon_count,
+                contacts.contact_generation,
+                self._last_contact_generation,
             ],
             device=model.device,
         )
@@ -3077,6 +3150,7 @@ def notify_model_changed(self, flags: int) -> None:
             self._update_joint_properties()
         if flags & SolverNotifyFlags.BODY_PROPERTIES:
             self._update_body_properties()
+            self._invalidate_contact_fast_path()
             need_const_0 = True
         if flags & SolverNotifyFlags.JOINT_DOF_PROPERTIES:
             self._update_joint_dof_properties()
@@ -3085,6 +3159,7 @@ def notify_model_changed(self, flags: int) -> None:
         if flags & SolverNotifyFlags.SHAPE_PROPERTIES:
             self._update_geom_properties()
             self._update_pair_properties()
+            self._invalidate_contact_fast_path()
         if flags & SolverNotifyFlags.MODEL_PROPERTIES:
             self._update_model_properties()
         if flags & SolverNotifyFlags.CONSTRAINT_PROPERTIES:
@@ -3646,6 +3721,7 @@ def _convert_to_mjc(
         nconmax: int | None = None,
         solver: int | str | None = None,
         integrator: int | str | None = None,
+        enableflags: int = 0,
         disableflags: int = 0,
         disable_contacts: bool = False,
         impratio: float | None = None,
@@ -3686,6 +3762,7 @@ def _convert_to_mjc(
             nconmax: Maximum number of contacts.
             solver: Constraint solver type ("cg" or "newton"). If None, uses model custom attribute or Newton's default ("newton").
             integrator: Integration method ("euler", "rk4", "implicit", "implicitfast"). If None, uses model custom attribute or Newton's default ("implicitfast").
+            enableflags: MuJoCo enable flags bitmask.
             disableflags: MuJoCo disable flags bitmask.
             disable_contacts: If True, disable contact computation.
             impratio: Impedance ratio for contacts. If None, uses model custom attribute or MuJoCo default (1.0).
@@ -3857,6 +3934,7 @@ def resolve_vector_option(name: str, constructor_value):
             jacobian = mujoco.mjtJacobian.mjJAC_AUTO
 
         spec = mujoco.MjSpec()
+        spec.option.enableflags = enableflags
         spec.option.disableflags = disableflags
         spec.option.gravity = np.array([*model.gravity.numpy()[0]])
         spec.option.solver = solver
diff --git a/newton/_src/solvers/xpbd/kernels.py b/newton/_src/solvers/xpbd/kernels.py
index adffb8d892..0f1ae3f482 100644
--- a/newton/_src/solvers/xpbd/kernels.py
+++ b/newton/_src/solvers/xpbd/kernels.py
@@ -2078,6 +2078,7 @@ def solve_body_contact_positions(
     # outputs
     deltas: wp.array[wp.spatial_vector],
     contact_inv_weight: wp.array[float],
+    contact_impulse: wp.array[wp.spatial_vector],
 ):
     tid = wp.tid()
 
@@ -2285,6 +2286,104 @@ def solve_body_contact_positions(
     if body_b >= 0:
         wp.atomic_add(deltas, body_b, wp.spatial_vector(lin_delta_b, ang_delta_b))
 
+    if contact_impulse:
+        wp.atomic_add(contact_impulse, tid, wp.spatial_vector(lin_delta_a, ang_delta_a))
+
+
+@wp.kernel
+def accumulate_weighted_contact_impulse(
+    contact_count: wp.array[int],
+    contact_impulse_iter: wp.array[wp.spatial_vector],
+    contact_shape0: wp.array[int],
+    contact_shape1: wp.array[int],
+    shape_body: wp.array[int],
+    constraint_inv_weight: wp.array[float],
+    # output (accumulated across iterations)
+    contact_impulse: wp.array[wp.spatial_vector],
+):
+    """Scale per-contact impulse from one iteration by 1/N and accumulate.
+
+    ``constraint_inv_weight[body]`` holds the number of active contacts on
+    each body for the current iteration.  ``apply_body_deltas`` divides the
+    positional correction by that count, so the raw impulse stored per contact
+    is N times too large relative to what was actually applied.
+
+    When only one body is dynamic (the other is kinematic / ground), the
+    weight is simply ``1/N_dynamic``.  When both bodies are dynamic the
+    solver applies ``1/N_a`` to body A and ``1/N_b`` to body B, so there is
+    no single exact scalar.  We use the harmonic mean ``2/(N_a + N_b)`` which
+    is symmetric with respect to body ordering and reduces to ``1/N`` when
+    both counts are equal.
+    """
+    tid = wp.tid()
+    count = contact_count[0]
+    if tid >= count:
+        return
+
+    impulse = contact_impulse_iter[tid]
+
+    weight = 1.0
+    if constraint_inv_weight:
+        n_a = 0.0
+        n_b = 0.0
+        shape_a = contact_shape0[tid]
+        if shape_a >= 0:
+            body_a = shape_body[shape_a]
+            if body_a >= 0:
+                n_a = constraint_inv_weight[body_a]
+        shape_b = contact_shape1[tid]
+        if shape_b >= 0:
+            body_b = shape_body[shape_b]
+            if body_b >= 0:
+                n_b = constraint_inv_weight[body_b]
+        n_sum = n_a + n_b
+        if n_sum > 0.0:
+            if n_a == 0.0:
+                weight = 1.0 / n_b
+            elif n_b == 0.0:
+                weight = 1.0 / n_a
+            else:
+                weight = 2.0 / n_sum
+
+    scaled = wp.spatial_vector(
+        wp.spatial_top(impulse) * weight,
+        wp.spatial_bottom(impulse) * weight,
+    )
+    wp.atomic_add(contact_impulse, tid, scaled)
+
+
+@wp.kernel
+def convert_contact_impulse_to_force(
+    contact_count: wp.array[int],
+    contact_impulse: wp.array[wp.spatial_vector],
+    dt: float,
+    # output
+    contact_force: wp.array[wp.spatial_vector],
+):
+    """Convert accumulated per-contact spatial impulse to ``contacts.force`` spatial vectors.
+
+    The XPBD lambda convention used in this solver already absorbs one power
+    of ``dt`` (see ``compute_contact_constraint_delta``), so dividing the
+    accumulated impulse by the substep ``dt`` yields force [N] and torque [N·m].
+    The linear component includes normal and friction forces; the angular
+    component includes torsional and rolling friction torques.
+
+    The impulse is expected to already include the 1/N contact-weighting
+    correction (applied by ``accumulate_weighted_contact_impulse`` each
+    iteration).
+    """
+    tid = wp.tid()
+    count = contact_count[0]
+    if tid >= count:
+        contact_force[tid] = wp.spatial_vector()
+        return
+
+    inv_dt = 1.0 / dt
+    impulse = contact_impulse[tid]
+    f = wp.spatial_top(impulse) * inv_dt
+    tau = wp.spatial_bottom(impulse) * inv_dt
+    contact_force[tid] = wp.spatial_vector(f, tau)
+
 
 @wp.kernel
 def update_body_velocities(
diff --git a/newton/_src/solvers/xpbd/solver_xpbd.py b/newton/_src/solvers/xpbd/solver_xpbd.py
index a921c1a25b..29121888a4 100644
--- a/newton/_src/solvers/xpbd/solver_xpbd.py
+++ b/newton/_src/solvers/xpbd/solver_xpbd.py
@@ -8,6 +8,7 @@
 from ..flags import SolverNotifyFlags
 from ..solver import SolverBase
 from .kernels import (
+    accumulate_weighted_contact_impulse,
     apply_body_delta_velocities,
     apply_body_deltas,
     apply_joint_forces,
@@ -15,6 +16,7 @@
     apply_particle_shape_restitution,
     apply_rigid_restitution,
     bending_constraint,
+    convert_contact_impulse_to_force,
     copy_kinematic_body_state_kernel,
     solve_body_contact_positions,
     solve_body_joints,
@@ -37,6 +39,16 @@ class SolverXPBD(SolverBase):
     After constructing :class:`Model`, :class:`State`, and :class:`Control` (optional) objects, this time-integrator
     may be used to advance the simulation state forward in time.
 
+    Limitations:
+        **Momentum conservation** -- When ``rigid_contact_con_weighting`` is
+        enabled (the default), each body's positional correction is divided by
+        its number of active contacts.  This improves convergence for stacking
+        scenarios but means the solver does not conserve momentum at contacts.
+        Reported per-contact forces (see :meth:`update_contacts`) are
+        approximate: for contacts between two dynamic bodies the force is
+        computed using the harmonic mean of the two bodies' contact counts,
+        which is symmetric but not exact.
+
     Joint limitations:
         - Supported joint types: PRISMATIC, REVOLUTE, BALL, FIXED, FREE, DISTANCE, D6.
           CABLE joints are not supported.
@@ -249,11 +261,20 @@ def step(self, state_in: State, state_out: State, control: Control, contacts: Co
 
         rigid_contact_inv_weight = None
 
+        contact_impulse = None
+        contact_impulse_iter = None
+
         if contacts:
             if self.rigid_contact_con_weighting:
                 rigid_contact_inv_weight = wp.zeros(model.body_count, dtype=float, device=model.device)
             rigid_contact_inv_weight_init = None
 
+            if contacts.force is not None:
+                contact_impulse = wp.zeros(contacts.rigid_contact_max, dtype=wp.spatial_vector, device=model.device)
+                contact_impulse_iter = wp.zeros(
+                    contacts.rigid_contact_max, dtype=wp.spatial_vector, device=model.device
+                )
+
         if control is None:
             control = model.control(clone_variables=False)
 
@@ -471,6 +492,9 @@ def step(self, state_in: State, state_out: State, control: Control, contacts: Co
                         if self.rigid_contact_con_weighting:
                             rigid_contact_inv_weight.zero_()
 
+                        if contact_impulse_iter is not None:
+                            contact_impulse_iter.zero_()
+
                         wp.launch(
                             kernel=solve_body_contact_positions,
                             dim=contacts.rigid_contact_max,
@@ -501,10 +525,27 @@ def step(self, state_in: State, state_out: State, control: Control, contacts: Co
                             outputs=[
                                 body_deltas,
                                 rigid_contact_inv_weight,
+                                contact_impulse_iter,
                             ],
                             device=model.device,
                         )
 
+                        if contact_impulse_iter is not None:
+                            wp.launch(
+                                kernel=accumulate_weighted_contact_impulse,
+                                dim=contacts.rigid_contact_max,
+                                inputs=[
+                                    contacts.rigid_contact_count,
+                                    contact_impulse_iter,
+                                    contacts.rigid_contact_shape0,
+                                    contacts.rigid_contact_shape1,
+                                    model.shape_body,
+                                    rigid_contact_inv_weight,
+                                ],
+                                outputs=[contact_impulse],
+                                device=model.device,
+                            )
+
                         # if model.rigid_contact_count.numpy()[0] > 0:
                         #     print("rigid_contact_count:", model.rigid_contact_count.numpy().flatten())
                         #     # print("rigid_active_contact_distance:", rigid_active_contact_distance.numpy().flatten())
@@ -567,6 +608,10 @@ def step(self, state_in: State, state_out: State, control: Control, contacts: Co
 
                         body_q, body_qd = self._apply_body_deltas(model, state_in, state_out, body_deltas, dt)
 
+            self._contact_impulse = contact_impulse
+            self._contact_impulse_capacity = contacts.rigid_contact_max if contacts is not None else 0
+            self._last_dt = dt
+
             if model.particle_count:
                 if particle_q.ptr != state_out.particle_q.ptr:
                     state_out.particle_q.assign(particle_q)
@@ -675,3 +720,60 @@ def step(self, state_in: State, state_out: State, control: Control, contacts: Co
 
             if model.body_count:
                 self.copy_kinematic_body_state(model, state_in, state_out)
+
+    @override
+    def update_contacts(self, contacts: Contacts, state: State | None = None) -> None:
+        """Populate ``contacts.force`` from XPBD contact impulses accumulated during the last :meth:`step`.
+
+        Both force [N] and torque [N·m] components are written.  The torque
+        includes torsional and rolling friction contributions that cannot be
+        reconstructed from the linear force alone.
+
+        When ``rigid_contact_con_weighting`` is enabled, the raw per-contact
+        impulse is scaled to reflect the ``1/N`` correction that
+        ``apply_body_deltas`` applies.  For contacts between a dynamic and a
+        kinematic body, ``N`` is the dynamic body's contact count.  For
+        contacts between two dynamic bodies, the harmonic mean
+        ``2/(N_a + N_b)`` is used so that the reported force is symmetric with
+        respect to body ordering.  This is an approximation -- the solver
+        applies ``1/N_a`` and ``1/N_b`` independently to each side, so no
+        single scalar can exactly represent both.
+
+        Args:
+            contacts: :class:`Contacts` object whose :attr:`~Contacts.force` buffer will be written.
+                Must have been created with ``"force"`` in its requested attributes and must
+                match the :class:`Contacts` instance (same ``rigid_contact_max``) passed to
+                the preceding :meth:`step`.
+            state: Unused (accepted for API compatibility with :class:`SolverBase`).
+
+        Raises:
+            ValueError: If ``contacts.force`` is ``None`` (not requested), if no step has been run yet,
+                or if the contacts capacity does not match the one used in the last :meth:`step`.
+        """
+        if contacts.force is None:
+            raise ValueError(
+                "contacts.force is not allocated. Call model.request_contact_attributes('force') "
+                "before creating the Contacts object."
+            )
+        if not hasattr(self, "_contact_impulse") or self._contact_impulse is None:
+            raise ValueError("No contact impulse data available. Call step() before update_contacts().")
+        if contacts.rigid_contact_max != self._contact_impulse_capacity:
+            raise ValueError(
+                f"Contacts capacity mismatch: update_contacts() received rigid_contact_max="
+                f"{contacts.rigid_contact_max}, but step() used {self._contact_impulse_capacity}. "
+                f"Pass the same Contacts instance to both step() and update_contacts()."
+            )
+
+        contacts.force.zero_()
+
+        wp.launch(
+            kernel=convert_contact_impulse_to_force,
+            dim=contacts.rigid_contact_max,
+            inputs=[
+                contacts.rigid_contact_count,
+                self._contact_impulse,
+                self._last_dt,
+            ],
+            outputs=[contacts.force],
+            device=self.model.device,
+        )
diff --git a/newton/_src/utils/import_usd.py b/newton/_src/utils/import_usd.py
index 2e0eae9355..3e9c47c242 100644
--- a/newton/_src/utils/import_usd.py
+++ b/newton/_src/utils/import_usd.py
@@ -4,6 +4,7 @@
 from __future__ import annotations
 
 import collections
+import copy
 import datetime
 import inspect
 import itertools
@@ -18,6 +19,8 @@
 if TYPE_CHECKING:
     from pxr import Usd
 
+    from ..geometry.types import TetMesh
+
     UsdStage = Usd.Stage
 else:
     UsdStage = Any
@@ -87,7 +90,7 @@ def parse_usd(
     force_position_velocity_actuation: bool = False,
     override_root_xform: bool = False,
 ) -> dict[str, Any]:
-    """Parses a Universal Scene Description (USD) stage containing UsdPhysics schema definitions for rigid-body articulations and adds the bodies, shapes and joints to the given ModelBuilder.
+    """Parses a Universal Scene Description (USD) stage and adds rigid bodies, soft bodies, shapes, and joints to the given ModelBuilder.
 
     The USD description has to be either a path (file name or URL), or an existing USD stage instance that implements the `Stage <https://openusd.org/dev/api/class_usd_stage.html>`_ interface.
 
@@ -349,10 +352,14 @@ class PhysicsMaterial:
     path_shape_scale: dict[str, wp.vec3] = {}
     # mapping from prim path to joint index in ModelBuilder
     path_joint_map: dict[str, int] = {}
+    # DOF offset within a merged D6 joint for each original prim path (only populated for merged joints)
+    merged_dof_offset: dict[str, int] = {}
     # cache for resolved material properties (keyed by prim path)
     material_props_cache: dict[str, dict[str, Any]] = {}
     # cache for mesh data loaded from USD prims
     mesh_cache: dict[tuple[str, bool, bool], Mesh] = {}
+    # cache for TetMesh data loaded from USD prims
+    tetmesh_cache: dict[str, TetMesh] = {}
 
     physics_scene_prim = None
     physics_dt = None
@@ -443,6 +450,18 @@ def _get_mesh_with_visual_material(prim: Usd.Prim, *, path_name: str) -> Mesh:
             mesh.metallic = material_props["metallic"]
         return mesh
 
+    def _get_tetmesh_cached(prim: Usd.Prim) -> TetMesh:
+        """Load and cache TetMesh data to avoid repeated USD extraction."""
+        prim_path = str(prim.GetPath())
+        if prim_path not in tetmesh_cache:
+            tetmesh_cache[prim_path] = usd.get_tetmesh(prim)
+        return tetmesh_cache[prim_path]
+
+    def _is_uniform_scale(scale: wp.vec3) -> bool:
+        """Return whether a decomposed scale vector is effectively uniform."""
+        scale_np = np.array(scale, dtype=np.float32)
+        return bool(np.allclose(scale_np, scale_np[0], rtol=1e-6, atol=1e-6))
+
     def _has_visual_material_properties(material_props: dict[str, Any]) -> bool:
         # Require PBR-like material cues to avoid promoting generic displayColor-only colliders.
         return any(material_props.get(key) is not None for key in ("texture", "roughness", "metallic"))
@@ -629,7 +648,7 @@ def _load_visual_shapes_impl(
                     cfg=visual_shape_cfg,
                     label=path_name,
                 )
-            elif len(type_name) > 0 and type_name != "xform" and verbose:
+            elif len(type_name) > 0 and type_name not in {"xform", "tetmesh"} and verbose:
                 print(f"Warning: Unsupported geometry type {type_name} at {path_name} while loading visual shapes.")
 
             if shape_id >= 0:
@@ -1174,6 +1193,322 @@ def define_joint_targets(dof, joint_desc):
 
         return joint_index
 
+    def parse_merged_joints(
+        joint_paths: list[str],
+        incoming_xform: wp.transform | None = None,
+    ) -> int | None:
+        """Combine multiple single-DOF joints between the same two bodies into one D6 joint.
+
+        This handles USD files where multi-DOF MuJoCo joints are represented as
+        separate PhysicsRevoluteJoint / PhysicsPrismaticJoint prims connecting the
+        same parent and child bodies.  The individual joints are merged into a
+        single :func:`~newton.ModelBuilder.add_joint_d6` call, following the same
+        pattern used by the MJCF importer.
+
+        Args:
+            joint_paths: Prim paths of the joints to merge (all must share the
+                same body pair).
+            incoming_xform: Optional world-space transform applied to the parent
+                frame of the first joint.
+
+        Returns:
+            The builder joint index of the newly created D6 joint, or ``None`` if
+            all joints in the group are disabled.
+        """
+        linear_axes: list[ModelBuilder.JointDofConfig] = []
+        angular_axes: list[ModelBuilder.JointDofConfig] = []
+        # Track prim paths and initial state separately for linear/angular DOFs
+        # because add_joint_d6 orders linear DOFs first, then angular
+        linear_prim_paths: list[str] = []
+        angular_prim_paths: list[str] = []
+        linear_initial_pos: list[float | None] = []
+        linear_initial_vel: list[float | None] = []
+        angular_initial_pos: list[float | None] = []
+        angular_initial_vel: list[float | None] = []
+        enabled_count = 0
+
+        # Find the first enabled joint to use as representative for transforms and metadata
+        first_desc = None
+        first_prim = None
+        for jp in joint_paths:
+            jd = joint_descriptions[jp]
+            if not jd.jointEnabled and only_load_enabled_joints:
+                continue
+            first_desc = jd
+            first_prim = stage.GetPrimAtPath(jd.primPath)
+            break
+        if first_desc is None:
+            return None  # all joints disabled
+
+        parent_id, child_id, parent_tf, child_tf = resolve_joint_parent_child(  # pyright: ignore[reportAssignmentType]
+            first_desc, path_body_map, get_transforms=True
+        )
+        if incoming_xform is not None:
+            parent_tf = incoming_xform * parent_tf
+
+        # Warn if any sibling joint has a different anchor position.
+        # Different local rotations are expected (they encode different DOF axis directions)
+        # and are handled by remapping axes into the representative frame.
+        for jp in joint_paths:
+            jd = joint_descriptions[jp]
+            if jd is first_desc:
+                continue
+            _, _, other_parent_tf, other_child_tf = resolve_joint_parent_child(  # pyright: ignore[reportAssignmentType]
+                jd, path_body_map, get_transforms=True
+            )
+            parent_pos_match = np.allclose(parent_tf.p, other_parent_tf.p, atol=1e-6)
+            child_pos_match = np.allclose(child_tf.p, other_child_tf.p, atol=1e-6)
+            if not (parent_pos_match and child_pos_match):
+                warnings.warn(
+                    f"Merged joint {jp} has different anchor positions than representative "
+                    f"{first_desc.primPath}; using representative positions for the D6 joint.",
+                    stacklevel=2,
+                )
+                break
+
+        # Split custom attributes into joint-level (one value per joint) and
+        # per-DOF (one value per DOF).  Joint-level attrs come from the
+        # representative prim; per-DOF attrs are collected from each sibling.
+        joint_freq_attrs = [a for a in builder_custom_attr_joint if a.frequency == AttributeFrequency.JOINT]
+        dof_freq_attrs = [
+            a
+            for a in builder_custom_attr_joint
+            if a.frequency in (AttributeFrequency.JOINT_DOF, AttributeFrequency.JOINT_COORD)
+        ]
+        joint_custom_attrs = usd.get_custom_attribute_values(first_prim, joint_freq_attrs, context={"builder": builder})
+        # Per-DOF custom attributes accumulated separately for linear / angular
+        # so we can reorder to D6 DOF order (linear first, then angular).
+        linear_dof_custom: list[dict[str, Any]] = []
+        angular_dof_custom: list[dict[str, Any]] = []
+
+        # Cache the representative parent-side rotation for axis remapping
+        rep_parent_rot = np.array(parent_tf.q, dtype=float)
+
+        for jp in joint_paths:
+            jd = joint_descriptions[jp]
+            if not jd.jointEnabled and only_load_enabled_joints:
+                continue
+            jp_prim = stage.GetPrimAtPath(jd.primPath)
+            if collect_schema_attrs:
+                R.collect_prim_attrs(jp_prim)
+
+            key = jd.type
+            if key not in (UsdPhysics.ObjectType.RevoluteJoint, UsdPhysics.ObjectType.PrismaticJoint):
+                raise ValueError(
+                    f"Cannot merge joint {jp} of type {key} into a D6 joint. "
+                    "Only RevoluteJoint and PrismaticJoint are supported for merging."
+                )
+
+            is_revolute = key == UsdPhysics.ObjectType.RevoluteJoint
+            if is_revolute:
+                limit_gains_scaling = DegreesToRadian
+            else:
+                limit_gains_scaling = 1.0
+
+            j_armature = R.get_value(
+                jp_prim, prim_type=PrimType.JOINT, key="armature", default=default_joint_armature, verbose=verbose
+            )
+            j_friction = R.get_value(
+                jp_prim, prim_type=PrimType.JOINT, key="friction", default=default_joint_friction, verbose=verbose
+            )
+            j_velocity_limit = R.get_value(
+                jp_prim, prim_type=PrimType.JOINT, key="velocity_limit", default=None, verbose=verbose
+            )
+
+            limit_ke = R.get_value(
+                jp_prim,
+                prim_type=PrimType.JOINT,
+                key="limit_angular_ke" if is_revolute else "limit_linear_ke",
+                default=default_joint_limit_ke * limit_gains_scaling,
+                verbose=verbose,
+            )
+            limit_kd = R.get_value(
+                jp_prim,
+                prim_type=PrimType.JOINT,
+                key="limit_angular_kd" if is_revolute else "limit_linear_kd",
+                default=default_joint_limit_kd * limit_gains_scaling,
+                verbose=verbose,
+            )
+
+            limit_lower = jd.limit.lower
+            limit_upper = jd.limit.upper
+
+            # Build drive params
+            target_pos = 0.0
+            target_vel = 0.0
+            target_ke = 0.0
+            target_kd = 0.0
+            effort_limit = np.inf
+            actuator_mode = JointTargetMode.NONE
+            if jd.drive.enabled:
+                target_vel = jd.drive.targetVelocity
+                target_pos = jd.drive.targetPosition
+                target_ke = jd.drive.stiffness
+                target_kd = jd.drive.damping
+                effort_limit = jd.drive.forceLimit
+                actuator_mode = JointTargetMode.from_gains(
+                    target_ke, target_kd, force_position_velocity_actuation, has_drive=True
+                )
+
+            # Read initial joint state
+            initial_position = None
+            initial_velocity = None
+            if is_revolute:
+                initial_position = R.get_value(
+                    jp_prim, PrimType.JOINT, "angular_position", default=None, verbose=verbose
+                )
+                initial_velocity = R.get_value(
+                    jp_prim, PrimType.JOINT, "angular_velocity", default=None, verbose=verbose
+                )
+            else:
+                initial_position = R.get_value(
+                    jp_prim, PrimType.JOINT, "linear_position", default=None, verbose=verbose
+                )
+                initial_velocity = R.get_value(
+                    jp_prim, PrimType.JOINT, "linear_velocity", default=None, verbose=verbose
+                )
+
+            # Unit conversion for revolute joints
+            if is_revolute:
+                limit_lower *= DegreesToRadian
+                limit_upper *= DegreesToRadian
+                limit_ke /= DegreesToRadian
+                limit_kd /= DegreesToRadian
+                if jd.drive.enabled:
+                    target_pos *= DegreesToRadian
+                    target_vel *= DegreesToRadian
+                    target_kd /= DegreesToRadian / joint_drive_gains_scaling
+                    target_ke /= DegreesToRadian / joint_drive_gains_scaling
+                if j_velocity_limit is not None:
+                    j_velocity_limit *= DegreesToRadian
+                if initial_position is not None:
+                    initial_position *= DegreesToRadian
+
+            # Compute the DOF axis in the representative joint's frame.
+            # Each USD joint may have a different localRot that orients its fixed axis
+            # (X, Y, or Z) to the physical DOF direction.  We remap into the rep frame.
+            _, _, jp_parent_tf, _ = resolve_joint_parent_child(  # pyright: ignore[reportAssignmentType]
+                jd, path_body_map, get_transforms=True
+            )
+            jp_parent_rot = np.array(jp_parent_tf.q, dtype=float)
+            # q and -q represent the same rotation
+            if abs(np.dot(rep_parent_rot, jp_parent_rot)) > 1.0 - 1e-6:
+                # Same rotation — use the original axis directly
+                dof_axis = usd_axis_to_axis[jd.axis]
+            else:
+                # Different rotation — transform axis into rep frame
+                rep_q_inv = wp.quat_inverse(wp.quat(*rep_parent_rot.tolist()))
+                jp_q = wp.quat(*jp_parent_rot.tolist())
+                relative_q = wp.mul(rep_q_inv, jp_q)
+                # Axis enum value: 0=X, 1=Y, 2=Z → unit vector
+                axis_idx = int(usd_axis_to_axis[jd.axis])
+                axis_unit = [0.0, 0.0, 0.0]
+                axis_unit[axis_idx] = 1.0
+                rotated = wp.quat_rotate(relative_q, wp.vec3(axis_unit[0], axis_unit[1], axis_unit[2]))
+                dof_axis = (float(rotated[0]), float(rotated[1]), float(rotated[2]))
+
+            ax = ModelBuilder.JointDofConfig(
+                axis=dof_axis,
+                limit_lower=limit_lower,
+                limit_upper=limit_upper,
+                limit_ke=limit_ke,
+                limit_kd=limit_kd,
+                target_pos=target_pos,
+                target_vel=target_vel,
+                target_ke=target_ke,
+                target_kd=target_kd,
+                armature=j_armature,
+                friction=j_friction,
+                effort_limit=effort_limit,
+                velocity_limit=j_velocity_limit if j_velocity_limit is not None else default_joint_velocity_limit,
+                actuator_mode=actuator_mode,
+            )
+
+            # Collect per-DOF custom attributes from this sibling prim
+            sibling_dof_attrs = usd.get_custom_attribute_values(jp_prim, dof_freq_attrs, context={"builder": builder})
+
+            if is_revolute:
+                angular_axes.append(ax)
+                angular_prim_paths.append(jp)
+                angular_initial_pos.append(initial_position)
+                angular_initial_vel.append(initial_velocity)
+                angular_dof_custom.append(sibling_dof_attrs)
+            else:
+                linear_axes.append(ax)
+                linear_prim_paths.append(jp)
+                linear_initial_pos.append(initial_position)
+                linear_initial_vel.append(initial_velocity)
+                linear_dof_custom.append(sibling_dof_attrs)
+
+            enabled_count += 1
+
+        if enabled_count == 0:
+            return None
+
+        # D6 DOF order: linear first, then angular
+        dof_prim_paths = linear_prim_paths + angular_prim_paths
+        dof_initial_pos = linear_initial_pos + angular_initial_pos
+        dof_initial_vel = linear_initial_vel + angular_initial_vel
+        ordered_dof_custom = linear_dof_custom + angular_dof_custom
+
+        # Merge per-DOF custom attributes into DOF-indexed dicts for add_joint_d6.
+        # Each entry in ordered_dof_custom is a dict of {attr_key: value} from one sibling prim.
+        # We assemble {attr_key: {dof_index: value}} so _process_joint_custom_attributes
+        # assigns each DOF its own value instead of broadcasting from the representative.
+        for dof_idx, dof_attrs in enumerate(ordered_dof_custom):
+            for attr_key, value in dof_attrs.items():
+                if attr_key not in joint_custom_attrs:
+                    joint_custom_attrs[attr_key] = {}
+                existing = joint_custom_attrs[attr_key]
+                if not isinstance(existing, dict):
+                    # First per-DOF value for an attr that was already set as a scalar
+                    # from the representative — convert to a dict to allow per-DOF override.
+                    joint_custom_attrs[attr_key] = {dof_idx: value}
+                else:
+                    existing[dof_idx] = value
+
+        # Use the representative (first enabled) joint path as the D6 joint label
+        label = str(first_desc.primPath)
+
+        # Register original prim paths as DOF labels so MjcActuator targets resolve correctly
+        if "mujoco:joint_dof_label" in builder.custom_attributes:
+            joint_custom_attrs["mujoco:joint_dof_label"] = dof_prim_paths
+
+        joint_index = builder.add_joint_d6(
+            parent=parent_id,
+            child=child_id,
+            linear_axes=linear_axes if linear_axes else None,
+            angular_axes=angular_axes if angular_axes else None,
+            parent_xform=parent_tf,
+            child_xform=child_tf,
+            label=label,
+            enabled=first_desc.jointEnabled,
+            custom_attributes=joint_custom_attrs,
+        )
+
+        # Register all original joint prim paths in path_joint_map and track per-path DOF offsets
+        for jp in joint_paths:
+            path_joint_map[jp] = joint_index
+        for dof_idx, dof_path in enumerate(dof_prim_paths):
+            merged_dof_offset[dof_path] = dof_idx
+
+        # Apply initial positions/velocities
+        q_start = builder.joint_q_start[joint_index]
+        qd_start = builder.joint_qd_start[joint_index]
+        for dof_idx, (pos, vel) in enumerate(zip(dof_initial_pos, dof_initial_vel, strict=True)):
+            if pos is not None:
+                builder.joint_q[q_start + dof_idx] = pos
+            if vel is not None:
+                builder.joint_qd[qd_start + dof_idx] = vel
+
+        if verbose:
+            print(
+                f"Merged {len(joint_paths)} joints into D6 joint {joint_index}: "
+                f"{len(linear_axes)} linear + {len(angular_axes)} angular DOFs"
+            )
+
+        return joint_index
+
     # Looking for and parsing the attributes on PhysicsScene prims
     scene_attributes = {}
     physics_scene_prim = None
@@ -1518,6 +1853,11 @@ def warn_invalid_desc(path, descriptor) -> bool:
             joint_edges: list[tuple[int, int]] = []
             # keys of joints that are excluded from the articulation (loop joints)
             joint_excluded: set[str] = set()
+            # Groups of joints that share the same body pair (multi-DOF joints from MuJoCo USD).
+            # Maps the representative joint path (first encountered) to all joint paths in the group.
+            merged_joint_groups: dict[str, list[str]] = {}
+            # Track which body pair maps to which representative joint path
+            body_pair_to_representative: dict[tuple[int, int], str] = {}
             for p in desc.articulatedJoints:
                 joint_path = str(p)
                 joint_desc = joint_descriptions[joint_path]
@@ -1534,8 +1874,17 @@ def warn_invalid_desc(path, descriptor) -> bool:
                 if joint_desc.excludeFromArticulation:
                     joint_excluded.add(joint_path)
                 else:
-                    joint_edges.append((parent_id, child_id))
-                    joint_names.append(joint_path)
+                    body_pair = (parent_id, child_id)
+                    if body_pair in body_pair_to_representative:
+                        # Another joint between the same bodies — merge into existing group
+                        rep = body_pair_to_representative[body_pair]
+                        merged_joint_groups[rep].append(joint_path)
+                    else:
+                        # First joint for this body pair
+                        body_pair_to_representative[body_pair] = joint_path
+                        merged_joint_groups[joint_path] = [joint_path]
+                        joint_edges.append(body_pair)
+                        joint_names.append(joint_path)
 
             articulation_joint_indices = []
 
@@ -1758,17 +2107,30 @@ def warn_invalid_desc(path, descriptor) -> bool:
                             else wp.transform_identity()
                         )
                         root_incoming_xform = incoming_world_xform * root_frame_xform * world_body_xform
-                        joint = parse_joint(
-                            joint_descriptions[joint_names[i]],
-                            incoming_xform=root_incoming_xform,
-                        )
+                        group = merged_joint_groups.get(joint_names[i])
+                        if group is not None and len(group) > 1:
+                            joint = parse_merged_joints(group, incoming_xform=root_incoming_xform)
+                        else:
+                            joint = parse_joint(
+                                joint_descriptions[joint_names[i]],
+                                incoming_xform=root_incoming_xform,
+                            )
                     else:
-                        joint = parse_joint(
-                            joint_descriptions[joint_names[i]],
-                        )
+                        group = merged_joint_groups.get(joint_names[i])
+                        if group is not None and len(group) > 1:
+                            joint = parse_merged_joints(group)
+                        else:
+                            joint = parse_joint(
+                                joint_descriptions[joint_names[i]],
+                            )
                     if joint is not None:
                         articulation_joint_indices.append(joint)
                         processed_joints.add(joint_names[i])
+                        # Mark all paths in the group as processed
+                        group = merged_joint_groups.get(joint_names[i])
+                        if group is not None:
+                            for gp in group:
+                                processed_joints.add(gp)
 
                 # insert loop joints
                 for joint_path in joint_excluded:
@@ -2368,6 +2730,57 @@ def _build_mass_info_from_shape_geometry(
                     for shape2 in builder.body_shapes[body2]:
                         builder.add_shape_collision_filter_pair(shape1, shape2)
 
+    root_prim = stage.GetPrimAtPath(root_path)
+    if root_prim and root_prim.IsValid():
+        for prim in Usd.PrimRange(root_prim, Usd.TraverseInstanceProxies()):
+            if not prim.IsA(UsdGeom.TetMesh):
+                continue
+
+            path = str(prim.GetPath())
+            if path.startswith("/Prototypes/"):
+                continue
+            if any(re.match(pattern, path) for pattern in ignore_paths):
+                continue
+
+            if collect_schema_attrs:
+                R.collect_prim_attrs(prim)
+
+            tetmesh = _get_tetmesh_cached(prim)
+            tetmesh_for_builder = tetmesh
+            if tetmesh.custom_attributes:
+                filtered_custom_attributes = {
+                    k: v for k, v in tetmesh.custom_attributes.items() if k in builder.custom_attributes
+                }
+                if len(filtered_custom_attributes) != len(tetmesh.custom_attributes):
+                    # Preserve the cached TetMesh while keeping add_usd's
+                    # current behavior of dropping unregistered import attrs.
+                    tetmesh_for_builder = copy.copy(tetmesh)
+                    tetmesh_for_builder.custom_attributes = filtered_custom_attributes
+
+            soft_mesh_mat = _get_prim_world_mat(prim, None, incoming_world_xform)
+            soft_mesh_pos, soft_mesh_rot, soft_mesh_scale = wp.transform_decompose(soft_mesh_mat)
+
+            add_soft_mesh_kwargs = {
+                "pos": soft_mesh_pos,
+                "rot": soft_mesh_rot,
+                "scale": 1.0,
+                "vel": wp.vec3(0.0, 0.0, 0.0),
+                "mesh": tetmesh_for_builder,
+            }
+            if _is_uniform_scale(soft_mesh_scale):
+                add_soft_mesh_kwargs["scale"] = float(np.array(soft_mesh_scale, dtype=np.float32)[0])
+            else:
+                add_soft_mesh_kwargs["vertices"] = tetmesh_for_builder.vertices * np.array(
+                    soft_mesh_scale, dtype=np.float32
+                )
+
+            builder.add_soft_mesh(**add_soft_mesh_kwargs)
+
+            if verbose:
+                print(
+                    f"Added soft mesh {path} with {tetmesh.vertex_count} vertices and {tetmesh.tet_count} tetrahedra."
+                )
+
     # Load Gaussian splat prims that weren't already captured as children of rigid bodies.
     if load_visual_shapes:
         prims = iter(Usd.PrimRange(stage.GetPrimAtPath(root_path), Usd.TraverseInstanceProxies()))
@@ -2609,6 +3022,7 @@ def _get_collision_mass_information(collider_prim: Usd.Prim):
     # collapsing fixed joints to reduce the number of simulated bodies connected by fixed joints.
     collapse_results = None
     path_body_relative_transform = {}
+    builder_joint_labels_before_collapse = list(builder.joint_label)
     if scene_attributes.get("newton:collapse_fixed_joints", collapse_fixed_joints):
         collapse_results = builder.collapse_fixed_joints()
         body_merged_parent = collapse_results["body_merged_parent"]
@@ -2632,7 +3046,21 @@ def _get_collision_mass_information(collider_prim: Usd.Prim):
             path_body_map[path] = new_id
 
         # Joint indices may have shifted after collapsing fixed joints; refresh the joint path map accordingly.
-        path_joint_map = {label: idx for idx, label in enumerate(builder.joint_label)}
+        # First rebuild the canonical label→index map, then re-add merged joint aliases.
+        new_label_to_idx = {label: idx for idx, label in enumerate(builder.joint_label)}
+        old_path_joint_map = path_joint_map
+        path_joint_map = dict(new_label_to_idx)
+        for path, old_idx in old_path_joint_map.items():
+            if path in path_joint_map:
+                continue  # already mapped via joint_label
+            # Find the new index for this merged alias via the representative label
+            old_label = (
+                builder_joint_labels_before_collapse[old_idx]
+                if old_idx < len(builder_joint_labels_before_collapse)
+                else None
+            )
+            if old_label is not None and old_label in new_label_to_idx:
+                path_joint_map[path] = new_label_to_idx[old_label]
 
     # Mimic constraints from PhysxMimicJointAPI (run after collapse so joint indices are final).
     # PhysxMimicJointAPI is an instance-applied schema (e.g. PhysxMimicJointAPI:rotZ)
@@ -2760,7 +3188,7 @@ def _get_collision_mass_information(collider_prim: Usd.Prim):
     actuator_count = 0
     if parse_actuator_prim is not None:
         path_to_dof = {
-            path: builder.joint_qd_start[idx]
+            path: builder.joint_qd_start[idx] + merged_dof_offset.get(path, 0)
             for path, idx in path_joint_map.items()
             if idx < len(builder.joint_qd_start)
         }
diff --git a/newton/_src/viewer/gl/newton_envmap.jpg b/newton/_src/viewer/gl/newton_envmap.jpg
index 26493412f25b3dee6b1c4a7d68f4588d1d615632..d9dccf61397f101de1dfd2c14c785c0b2e7ee59f 100644
GIT binary patch
literal 105653
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
Gv;Wx>4fEIl

literal 187281
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%0D2_0GecAG(^%W
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

diff --git a/newton/_src/viewer/gl/opengl.py b/newton/_src/viewer/gl/opengl.py
index b2c4afc0c8..a23ca97783 100644
--- a/newton/_src/viewer/gl/opengl.py
+++ b/newton/_src/viewer/gl/opengl.py
@@ -15,8 +15,8 @@
 from ...utils.texture import normalize_texture
 from .shaders import (
     FrameShader,
+    ShaderArrow,
     ShaderLine,
-    ShaderLineWireframe,
     ShaderShape,
     ShaderSky,
     ShadowShader,
@@ -972,6 +972,8 @@ def __init__(self, title="Newton", screen_width=1920, screen_height=1080, vsync=
         self.draw_shadows = True
         self.draw_wireframe = False
         self.wireframe_line_width = 1.5  # pixels
+        self.line_width = 1.5  # pixels, for all log_lines batches
+        self.arrow_scale = 1.0  # uniform scale for arrow line width and head size
 
         self.background_color = (68.0 / 255.0, 161.0 / 255.0, 255.0 / 255.0)
 
@@ -1138,8 +1140,8 @@ def __init__(self, title="Newton", screen_width=1920, screen_height=1080, vsync=
         self._shape_shader = ShaderShape(gl)
         self._frame_shader = FrameShader(gl)
         self._sky_shader = ShaderSky(gl)
-        self._line_shader = ShaderLine(gl)
-        self._wireframe_shader = ShaderLineWireframe(gl)
+        self._wireframe_shader = ShaderLine(gl)
+        self._arrow_shader = ShaderArrow(gl)
 
         if not headless:
             self._setup_window_callbacks()
@@ -1201,7 +1203,7 @@ def update(self):
                 # This is a non-fatal error that can be safely ignored
                 pass
 
-    def render(self, camera, objects, lines=None, wireframe_shapes=None):
+    def render(self, camera, objects, lines=None, wireframe_shapes=None, arrows=None):
         gl = RendererGL.gl
         self._make_current()
 
@@ -1265,6 +1267,9 @@ def render(self, camera, objects, lines=None, wireframe_shapes=None):
         if lines:
             self._render_lines(lines)
 
+        if arrows:
+            self._render_arrows(arrows)
+
         if wireframe_shapes:
             self._render_wireframe_shapes(wireframe_shapes)
 
@@ -1838,15 +1843,62 @@ def _render_scene(self, objects):
         check_gl_error()
 
     def _render_lines(self, lines):
-        """Render all line objects using the line shader."""
-        # Set up line shader once for all line objects
-        self._line_shader.update(self._view_matrix, self._projection_matrix)
+        """Render all line objects using the geometry-shader wide-line pipeline."""
+        gl = RendererGL.gl
+        inv_asp = float(self._screen_height) / float(max(self._screen_width, 1))
+        clip_width = max(0.0, self.line_width) * 2.0 / max(self._screen_height, 1)
 
-        with self._line_shader:
+        gl.glEnable(gl.GL_DEPTH_TEST)
+        gl.glDisable(gl.GL_CULL_FACE)
+        gl.glEnable(gl.GL_BLEND)
+        gl.glBlendFunc(gl.GL_SRC_ALPHA, gl.GL_ONE_MINUS_SRC_ALPHA)
+
+        identity = np.eye(4, dtype=np.float32)
+        with self._wireframe_shader:
+            self._wireframe_shader.update_frame(
+                self._view_matrix,
+                self._projection_matrix,
+                inv_asp,
+                line_width=clip_width,
+                alpha=1.0,
+            )
+            self._wireframe_shader.set_world(identity)
             for line_obj in lines.values():
                 if hasattr(line_obj, "render"):
                     line_obj.render()
 
+        gl.glDisable(gl.GL_BLEND)
+        check_gl_error()
+
+    def _render_arrows(self, arrows):
+        """Render arrow batches (wide line + arrowhead triangle per segment)."""
+        gl = RendererGL.gl
+        inv_asp = float(self._screen_height) / float(max(self._screen_width, 1))
+        scale = max(0.0, self.arrow_scale)
+        clip_width = (2.0 * scale) * 2.0 / max(self._screen_height, 1)
+        clip_arrow = (8.0 * scale) * 2.0 / max(self._screen_height, 1)
+
+        gl.glEnable(gl.GL_DEPTH_TEST)
+        gl.glDisable(gl.GL_CULL_FACE)
+        gl.glEnable(gl.GL_BLEND)
+        gl.glBlendFunc(gl.GL_SRC_ALPHA, gl.GL_ONE_MINUS_SRC_ALPHA)
+
+        identity = np.eye(4, dtype=np.float32)
+        with self._arrow_shader:
+            self._arrow_shader.update_frame(
+                self._view_matrix,
+                self._projection_matrix,
+                inv_asp,
+                line_width=clip_width,
+                arrow_size=clip_arrow,
+                alpha=1.0,
+            )
+            self._arrow_shader.set_world(identity)
+            for arrow_obj in arrows.values():
+                if hasattr(arrow_obj, "render"):
+                    arrow_obj.render()
+
+        gl.glDisable(gl.GL_BLEND)
         check_gl_error()
 
     def _render_wireframe_shapes(self, wireframe_shapes):
diff --git a/newton/_src/viewer/gl/shaders.py b/newton/_src/viewer/gl/shaders.py
index 2b26614103..27b831444b 100644
--- a/newton/_src/viewer/gl/shaders.py
+++ b/newton/_src/viewer/gl/shaders.py
@@ -31,35 +31,6 @@
 """
 
 
-line_vertex_shader = """
-#version 330 core
-layout (location = 0) in vec3 aPos;
-layout (location = 1) in vec3 aColor;
-
-uniform mat4 view;
-uniform mat4 projection;
-
-out vec3 vertexColor;
-
-void main()
-{
-    vertexColor = aColor;
-    gl_Position = projection * view * vec4(aPos, 1.0);
-}
-"""
-
-line_fragment_shader = """
-#version 330 core
-in vec3 vertexColor;
-out vec4 FragColor;
-
-void main()
-{
-    FragColor = vec4(vertexColor, 1.0);
-}
-"""
-
-
 shape_vertex_shader = """
 #version 330 core
 layout (location = 0) in vec3 aPos;
@@ -367,10 +338,12 @@
     if (up_axis == 2) up = vec3(0.0, 0.0, 1.0);
     float sky_fac = dot(N, up) * 0.5 + 0.5;
     vec3 ambient = mix(ground_color, sky_color, sky_fac) * albedo * 0.7;
-    // Fresnel-weighted ambient specular for metallics
+    // Fresnel-weighted ambient specular — only significant for metals
+    // (dielectrics need a prefiltered IBL for correct ambient specular)
     vec3 F_ambient = F0 + (F_max - F0) * pow(1.0 - NdotV, 5.0);
     vec3 kD_ambient = (1.0 - F_ambient) * (1.0 - metallic);
-    ambient = kD_ambient * ambient + F_ambient * mix(ground_color, sky_color, sky_fac) * 0.35;
+    vec3 ambient_spec = F_ambient * mix(ground_color, sky_color, sky_fac) * 0.35;
+    ambient = kD_ambient * ambient + ambient_spec * metallic;
 
     // shadows
     float shadow = ShadowCalculation();
@@ -723,30 +696,6 @@ def update(self, texture_unit: int = 0):
             self._gl.glUniform1i(self.loc_texture, texture_unit)
 
 
-class ShaderLine(ShaderGL):
-    """Simple shader for rendering lines with per-vertex colors."""
-
-    def __init__(self, gl):
-        super().__init__()
-        from pyglet.graphics.shader import Shader, ShaderProgram
-
-        self._gl = gl
-        self.shader_program = ShaderProgram(
-            Shader(line_vertex_shader, "vertex"), Shader(line_fragment_shader, "fragment")
-        )
-
-        # Get uniform locations
-        with self:
-            self.loc_view = self._get_uniform_location("view")
-            self.loc_projection = self._get_uniform_location("projection")
-
-    def update(self, view_matrix: np.ndarray, projection_matrix: np.ndarray):
-        """Update view and projection matrices for line rendering."""
-        with self:
-            self._gl.glUniformMatrix4fv(self.loc_view, 1, self._gl.GL_FALSE, arr_pointer(view_matrix))
-            self._gl.glUniformMatrix4fv(self.loc_projection, 1, self._gl.GL_FALSE, arr_pointer(projection_matrix))
-
-
 wireframe_vertex_shader = """
 #version 330 core
 layout (location = 0) in vec3 aPos;
@@ -790,9 +739,13 @@ def update(self, view_matrix: np.ndarray, projection_matrix: np.ndarray):
     float s_depth = s.z / s.w;
     float e_depth = e.z / e.w;
 
-    vec2 dir = e_ndc - s_ndc;
-    vec2 right = normalize(vec2(dir.y, -dir.x));
-    right.x = right.x * inv_asp_ratio;
+    // Compute perpendicular in screen (aspect-corrected) space so line
+    // width is uniform on non-square viewports.
+    float safe_asp = max(inv_asp_ratio, 1e-6);
+    vec2 dir_ndc = e_ndc - s_ndc;
+    vec2 dir_scr = vec2(dir_ndc.x / safe_asp, dir_ndc.y);
+    vec2 right_scr = normalize(vec2(dir_scr.y, -dir_scr.x));
+    vec2 right = vec2(right_scr.x * safe_asp, right_scr.y);
 
     vec3 color = 0.5 * (vertexColor[0] + vertexColor[1]);
     vec2 xy = 0.5 * line_width * right;
@@ -829,7 +782,7 @@ def update(self, view_matrix: np.ndarray, projection_matrix: np.ndarray):
 """
 
 
-class ShaderLineWireframe(ShaderGL):
+class ShaderLine(ShaderGL):
     """Geometry-shader-based line renderer that expands GL_LINES into screen-space quads."""
 
     def __init__(self, gl):
@@ -869,3 +822,125 @@ def update_frame(
     def set_world(self, world: np.ndarray):
         """Set the per-shape world matrix uniform."""
         self._gl.glUniformMatrix4fv(self.loc_world, 1, self._gl.GL_FALSE, arr_pointer(world))
+
+
+arrow_geometry_shader = """
+#version 330 core
+layout (lines) in;
+layout (triangle_strip, max_vertices = 9) out;
+
+in vec3 vertexColor[2];
+out vec3 lineColor;
+
+uniform float inv_asp_ratio;
+uniform float line_width;
+uniform float arrow_size;
+
+void main()
+{
+    vec4 s = gl_in[0].gl_Position;
+    vec4 e = gl_in[1].gl_Position;
+    if (s.w <= 0.0 || e.w <= 0.0) return;
+
+    vec2 s_ndc = s.xy / s.w;
+    vec2 e_ndc = e.xy / e.w;
+    float s_depth = s.z / s.w;
+    float e_depth = e.z / e.w;
+
+    // Work in screen space (aspect-corrected) so arrows look correct on
+    // non-square viewports.  screen_x = ndc_x / inv_asp_ratio.
+    float safe_asp = max(inv_asp_ratio, 1e-6);
+    vec2 dir_ndc = e_ndc - s_ndc;
+    vec2 dir_scr = vec2(dir_ndc.x / safe_asp, dir_ndc.y);
+    float len = length(dir_scr);
+
+    vec3 color = 0.5 * (vertexColor[0] + vertexColor[1]);
+
+    // Degenerate case: line points into/out of screen
+    if (len < 1e-6) {
+        float r = arrow_size * 0.4;
+        vec2 up = vec2(0.0, r);
+        vec2 rt = vec2(r * safe_asp, 0.0);
+        gl_Position = vec4(e_ndc + up, e_depth, 1); lineColor = color; EmitVertex();
+        gl_Position = vec4(e_ndc - rt, e_depth, 1); lineColor = color; EmitVertex();
+        gl_Position = vec4(e_ndc + rt, e_depth, 1); lineColor = color; EmitVertex();
+        EndPrimitive();
+        return;
+    }
+
+    // fwd/right in screen space, then convert offsets back to NDC (scale x by safe_asp)
+    vec2 fwd_scr = dir_scr / len;
+    vec2 right_scr = vec2(fwd_scr.y, -fwd_scr.x);
+    vec2 fwd   = vec2(fwd_scr.x * safe_asp, fwd_scr.y);
+    vec2 right = vec2(right_scr.x * safe_asp, right_scr.y);
+
+    // Shorten the line body so it ends at the arrowhead base
+    vec2 xy = 0.5 * line_width * right;
+    vec2 e_body = e_ndc - fwd * arrow_size;
+
+    gl_Position = vec4(s_ndc  - xy, s_depth, 1); lineColor = color; EmitVertex();
+    gl_Position = vec4(e_body + xy, e_depth, 1); lineColor = color; EmitVertex();
+    gl_Position = vec4(s_ndc  + xy, s_depth, 1); lineColor = color; EmitVertex();
+    EndPrimitive();
+
+    gl_Position = vec4(s_ndc  - xy, s_depth, 1); lineColor = color; EmitVertex();
+    gl_Position = vec4(e_body - xy, e_depth, 1); lineColor = color; EmitVertex();
+    gl_Position = vec4(e_body + xy, e_depth, 1); lineColor = color; EmitVertex();
+    EndPrimitive();
+
+    // Triangle 3: arrowhead with tip exactly at the endpoint
+    vec2 tip    = e_ndc;
+    vec2 base_l = e_body - right * arrow_size * 0.5;
+    vec2 base_r = e_body + right * arrow_size * 0.5;
+
+    gl_Position = vec4(tip,    e_depth, 1); lineColor = color; EmitVertex();
+    gl_Position = vec4(base_l, e_depth, 1); lineColor = color; EmitVertex();
+    gl_Position = vec4(base_r, e_depth, 1); lineColor = color; EmitVertex();
+    EndPrimitive();
+}
+"""
+
+
+class ShaderArrow(ShaderGL):
+    """Geometry-shader-based arrow renderer: wide line + arrowhead triangle per segment."""
+
+    def __init__(self, gl):
+        super().__init__()
+        from pyglet.graphics.shader import Shader, ShaderProgram
+
+        self._gl = gl
+        self.shader_program = ShaderProgram(
+            Shader(wireframe_vertex_shader, "vertex"),
+            Shader(arrow_geometry_shader, "geometry"),
+            Shader(wireframe_fragment_shader, "fragment"),
+        )
+
+        with self:
+            self.loc_view = self._get_uniform_location("view")
+            self.loc_projection = self._get_uniform_location("projection")
+            self.loc_world = self._get_uniform_location("world")
+            self.loc_inv_asp_ratio = self._get_uniform_location("inv_asp_ratio")
+            self.loc_line_width = self._get_uniform_location("line_width")
+            self.loc_arrow_size = self._get_uniform_location("arrow_size")
+            self.loc_alpha = self._get_uniform_location("alpha")
+
+    def update_frame(
+        self,
+        view_matrix: np.ndarray,
+        projection_matrix: np.ndarray,
+        inv_asp_ratio: float,
+        line_width: float = 0.003,
+        arrow_size: float = 0.01,
+        alpha: float = 1.0,
+    ):
+        """Set per-frame uniforms (call once before rendering all arrow batches)."""
+        self._gl.glUniformMatrix4fv(self.loc_view, 1, self._gl.GL_FALSE, arr_pointer(view_matrix))
+        self._gl.glUniformMatrix4fv(self.loc_projection, 1, self._gl.GL_FALSE, arr_pointer(projection_matrix))
+        self._gl.glUniform1f(self.loc_inv_asp_ratio, float(inv_asp_ratio))
+        self._gl.glUniform1f(self.loc_line_width, float(line_width))
+        self._gl.glUniform1f(self.loc_arrow_size, float(arrow_size))
+        self._gl.glUniform1f(self.loc_alpha, float(alpha))
+
+    def set_world(self, world: np.ndarray):
+        """Set the per-shape world matrix uniform."""
+        self._gl.glUniformMatrix4fv(self.loc_world, 1, self._gl.GL_FALSE, arr_pointer(world))
diff --git a/newton/_src/viewer/kernels.py b/newton/_src/viewer/kernels.py
index 94cc9c6c01..14f1083272 100644
--- a/newton/_src/viewer/kernels.py
+++ b/newton/_src/viewer/kernels.py
@@ -21,6 +21,7 @@ class PickingState:
     picking_target_world: wp.vec3
     pick_stiffness: float
     pick_damping: float
+    pick_max_acceleration: float
 
 
 @wp.kernel
@@ -71,6 +72,7 @@ def apply_picking_force_kernel(
     body_flags: wp.array[int],
     body_com: wp.array[wp.vec3],
     body_mass: wp.array[float],
+    pick_effective_mass: wp.array[float],
 ):
     pick_body = pick_body_arr[0]
     if pick_body < 0:
@@ -107,6 +109,16 @@ def apply_picking_force_kernel(
         pick_state[0].pick_stiffness * (pick_target_world - pick_pos_world)
         - (pick_state[0].pick_damping * vel_at_offset)
     )
+
+    # Clamp force magnitude to prevent runaway divergence on light objects (#2361).
+    # Uses the effective mass (total articulation mass for linked bodies,
+    # own mass for free bodies) so picking a light robot link still allows
+    # enough force to move the whole chain.
+    max_force = pick_state[0].pick_max_acceleration * 9.81 * pick_effective_mass[pick_body]
+    force_mag = wp.length(force_at_offset)
+    if force_mag > max_force:
+        force_at_offset = force_at_offset * (max_force / force_mag)
+
     # Compute the resulting torque given the offset from COM to the picked point.
     torque_at_offset = wp.cross(offset, force_at_offset)
 
diff --git a/newton/_src/viewer/picking.py b/newton/_src/viewer/picking.py
index 9c8387c0ce..459deedc6f 100644
--- a/newton/_src/viewer/picking.py
+++ b/newton/_src/viewer/picking.py
@@ -24,6 +24,7 @@ def __init__(
         model: newton.Model,
         pick_stiffness: float = 50.0,
         pick_damping: float = 5.0,
+        pick_max_acceleration: float = 5.0,
         world_offsets: wp.array | None = None,
     ) -> None:
         """
@@ -33,6 +34,9 @@ def __init__(
             model: The model to pick from.
             pick_stiffness: The stiffness that will be used to compute the force applied to the picked body.
             pick_damping: The damping that will be used to compute the force applied to the picked body.
+            pick_max_acceleration: Maximum picking acceleration in multiples of g [9.81 m/s^2].
+                Clamps the picking force to prevent runaway divergence on light objects
+                near stiff contacts.
             world_offsets: Optional warp array of world offsets (dtype=wp.vec3) for multi-world picking support.
         """
         self.model = model
@@ -58,6 +62,7 @@ def __init__(
         pick_state_np = np.empty(1, dtype=PickingState.numpy_dtype())
         pick_state_np[0]["pick_stiffness"] = pick_stiffness
         pick_state_np[0]["pick_damping"] = pick_damping
+        pick_state_np[0]["pick_max_acceleration"] = pick_max_acceleration
         self.pick_state = wp.array(pick_state_np, dtype=PickingState, device=model.device if model else "cpu", ndim=1)
 
         self.pick_dist = 0.0
@@ -65,6 +70,12 @@ def __init__(
 
         self._default_on_mouse_drag = None
 
+        # Pre-compute effective mass per body for picking force clamping.
+        # For articulated bodies, use the total articulation mass so that
+        # picking a light link (e.g. fingertip) still allows enough force
+        # to move the whole chain. Free bodies use their own mass.
+        self._pick_effective_mass = self._compute_effective_mass(model)
+
     def _apply_picking_force(self, state: newton.State) -> None:
         """
         Applies a force to the picked body.
@@ -88,10 +99,51 @@ def _apply_picking_force(self, state: newton.State) -> None:
                 self.model.body_flags,
                 self.model.body_com,
                 self.model.body_mass,
+                self._pick_effective_mass,
             ],
             device=self.model.device,
         )
 
+    @staticmethod
+    def _compute_effective_mass(model: newton.Model) -> wp.array:
+        """Compute per-body effective mass for picking force clamping.
+
+        For bodies in an articulation, returns the total mass of that
+        articulation so that picking a light link still allows enough
+        force to move the whole chain.  Free bodies get their own mass.
+        """
+        if model is None:
+            return wp.zeros(1, dtype=float)
+
+        body_mass_np = model.body_mass.numpy()
+        effective = body_mass_np.copy()
+
+        if model.joint_count > 0:
+            joint_child_np = model.joint_child.numpy()
+            joint_art_np = model.joint_articulation.numpy()
+
+            # Map each body to its articulation index (-1 if free)
+            body_art = np.full(model.body_count, -1, dtype=np.int32)
+            for j in range(model.joint_count):
+                child = joint_child_np[j]
+                if child >= 0:
+                    body_art[child] = joint_art_np[j]
+
+            # Sum mass per articulation
+            art_mass = {}
+            for b in range(model.body_count):
+                a = body_art[b]
+                if a >= 0:
+                    art_mass[a] = art_mass.get(a, 0.0) + body_mass_np[b]
+
+            # Assign total articulation mass to each body in that articulation
+            for b in range(model.body_count):
+                a = body_art[b]
+                if a >= 0:
+                    effective[b] = art_mass[a]
+
+        return wp.array(effective, dtype=float, device=model.device)
+
     def is_picking(self) -> bool:
         """Checks if picking is active.
 
diff --git a/newton/_src/viewer/viewer.py b/newton/_src/viewer/viewer.py
index 98ddd86fea..469b53b25f 100644
--- a/newton/_src/viewer/viewer.py
+++ b/newton/_src/viewer/viewer.py
@@ -597,8 +597,11 @@ def _log_non_shape_state(self, state: newton.State):
         self._log_com(state)
 
     def log_contacts(self, contacts: newton.Contacts, state: newton.State):
-        """
-        Creates line segments along contact normals for rendering.
+        """Render contact normals as arrows.
+
+        Each active rigid contact is drawn as an arrow from the contact point
+        along the contact normal.  When ``show_contacts`` is ``False`` the
+        arrow batch is cleared.
 
         Args:
             contacts: The contacts to render.
@@ -606,8 +609,7 @@ def log_contacts(self, contacts: newton.Contacts, state: newton.State):
         """
 
         if not self.show_contacts:
-            # Pass None to hide joints - renderer will handle creating empty arrays
-            self.log_lines("/contacts", None, None, None)
+            self.log_arrows("/contacts", None, None, None)
             return
 
         # Get contact count, clamped to buffer size (counter may exceed max on overflow)
@@ -647,7 +649,7 @@ def log_contacts(self, contacts: newton.Contacts, state: newton.State):
                 device=self.device,
             )
 
-        # Always call log_lines to update the renderer (handles zero contacts gracefully)
+        # Always call log_arrows to update the renderer (handles zero contacts gracefully)
         if num_contacts > 0:
             # Slice arrays to only include active contacts
             starts = self._contact_points0[:num_contacts]
@@ -657,10 +659,9 @@ def log_contacts(self, contacts: newton.Contacts, state: newton.State):
             starts = wp.array([], dtype=wp.vec3, device=self.device)
             ends = wp.array([], dtype=wp.vec3, device=self.device)
 
-        # Use green color for contact normals
         colors = (0.0, 1.0, 0.0)
 
-        self.log_lines("/contacts", starts, ends, colors)
+        self.log_arrows("/contacts", starts, ends, colors)
 
     def log_hydro_contact_surface(
         self,
@@ -1085,19 +1086,52 @@ def log_lines(
         width: float = 0.01,
         hidden: bool = False,
     ):
-        """
-        Log line segments for rendering.
+        """Log line segments for rendering.
+
+        Lines are rendered as screen-space quads whose pixel width is
+        controlled by the renderer (e.g. ``RendererGL.line_width``).
+        The *width* parameter is currently unused and reserved for
+        future world-space width support.
 
         Args:
             name: Unique path/name for the line batch.
             starts: Optional line start points as a Warp vec3 array.
             ends: Optional line end points as a Warp vec3 array.
             colors: Per-line colors as a Warp array, or a single RGB triplet.
-            width: Line width in rendered scene units.
+            width: Reserved for future use (world-space line width).
+                Currently ignored; line width is set in screen-space pixels
+                via the renderer.
             hidden: Whether the line batch should be hidden.
         """
         pass
 
+    def log_arrows(
+        self,
+        name: str,
+        starts: wp.array[wp.vec3] | None,
+        ends: wp.array[wp.vec3] | None,
+        colors: (wp.array[wp.vec3] | wp.array[wp.float32] | tuple[float, float, float] | list[float] | None),
+        width: float = 0.01,
+        hidden: bool = False,
+    ):
+        """Log arrow segments (line + arrowhead) for rendering.
+
+        The GL viewer renders these with a dedicated arrow shader that draws
+        a screen-space quad line body plus a triangular arrowhead per segment.
+        Other backends fall back to :meth:`log_lines`.
+
+        Args:
+            name: Unique path/name for the arrow batch.
+            starts: Optional arrow start points as a Warp vec3 array.
+            ends: Optional arrow end points (arrowhead tip) as a Warp vec3 array.
+            colors: Per-arrow colors as a Warp array, or a single RGB triplet.
+            width: Reserved for future use (world-space line width).
+                Currently ignored; arrow size is set in screen-space pixels
+                via the renderer (e.g. ``RendererGL.arrow_scale``).
+            hidden: Whether the arrow batch should be hidden.
+        """
+        self.log_lines(name, starts, ends, colors, width=width, hidden=hidden)
+
     def log_wireframe_shape(  # noqa: B027
         self,
         name: str,
@@ -2004,7 +2038,6 @@ def _log_joints(self, state: newton.State):
             state: Current simulation state
         """
         if not self.show_joints:
-            # Pass None to hide joints - renderer will handle creating empty arrays
             self.log_lines("/model/joints", None, None, None)
             return
 
diff --git a/newton/_src/viewer/viewer_gl.py b/newton/_src/viewer/viewer_gl.py
index 002f823f0b..4bff11831d 100644
--- a/newton/_src/viewer/viewer_gl.py
+++ b/newton/_src/viewer/viewer_gl.py
@@ -406,8 +406,16 @@ def clear_model(self):
         and whenever the current model is discarded.
         """
         # Render object and line caches (path -> GL object)
+        for obj in getattr(self, "objects", {}).values():
+            if hasattr(obj, "destroy"):
+                obj.destroy()
         self.objects = {}
+        for obj in getattr(self, "lines", {}).values():
+            obj.destroy()
         self.lines = {}
+        for obj in getattr(self, "arrows", {}).values():
+            obj.destroy()
+        self.arrows = {}
         self._destroy_all_wireframes()
         self.wireframe_shapes = {}
         self._wireframe_vbo_owners: dict[int, WireframeShapeGL] = {}
@@ -580,7 +588,8 @@ def _rebuild_gl_shape_caches(self):
         current_names = {s.name for s in self._shape_instances.values()}
         stale = [k for k, v in self.objects.items() if isinstance(v, MeshInstancerGL) and k not in current_names]
         for k in stale:
-            del self.objects[k]
+            obj = self.objects.pop(k)
+            del obj
 
         shape_scale = self.model.shape_scale
         if shape_scale.device != self.device:
@@ -727,8 +736,10 @@ def log_instances(
             resized = True
         elif transform_count > instancer.num_instances:
             new_capacity = max(transform_count, instancer.num_instances * 2)
+            old = instancer
             instancer = MeshInstancerGL(new_capacity, self.objects[mesh])
             self.objects[name] = instancer
+            del old
             resized = True
 
         needs_update = resized or not hidden
@@ -839,15 +850,20 @@ def log_lines(
         width: float = 0.01,
         hidden: bool = False,
     ):
-        """
-        Log line data for rendering.
+        """Log line data for rendering.
+
+        Lines are drawn as screen-space quads whose pixel width is set by
+        :attr:`RendererGL.line_width`.  The *width* parameter is currently
+        unused and reserved for future world-space width support.
 
         Args:
             name: Unique identifier for the line batch.
             starts: Array of line start positions (shape: [N, 3]) or None for empty.
             ends: Array of line end positions (shape: [N, 3]) or None for empty.
             colors: Array of line colors (shape: [N, 3]) or tuple/list of RGB or None for empty.
-            width: The width of the lines.
+            width: Reserved for future use (world-space line width).
+                Currently ignored; pixel width is controlled by
+                ``RendererGL.line_width``.
             hidden: Whether the lines are initially hidden.
         """
         # Handle empty logs by resetting the LinesGL object
@@ -870,6 +886,8 @@ def log_lines(
             else:
                 # Handle zero lines case
                 colors = wp.array([], dtype=wp.vec3, device=self.device)
+        elif isinstance(colors, wp.array) and colors.dtype == wp.float32:
+            colors = colors.reshape((num_lines, 3)).view(dtype=wp.vec3)
 
         assert isinstance(colors, wp.array)
         assert len(colors) == num_lines, "Number of line colors must match line begins"
@@ -886,6 +904,66 @@ def log_lines(
             self.lines[name] = LinesGL(max_lines, self.device, hidden=hidden)
 
         self.lines[name].update(starts, ends, colors)
+        self.lines[name].hidden = hidden
+
+    @override
+    def log_arrows(
+        self,
+        name: str,
+        starts: wp.array[wp.vec3] | None,
+        ends: wp.array[wp.vec3] | None,
+        colors: (wp.array[wp.vec3] | wp.array[wp.float32] | tuple[float, float, float] | list[float] | None),
+        width: float = 0.01,
+        hidden: bool = False,
+    ):
+        """Log arrow data for rendering (screen-space quad line + arrowhead per segment).
+
+        Arrow size is controlled in screen-space pixels by
+        ``RendererGL.arrow_scale``.
+
+        Args:
+            name: Unique identifier for the arrow batch.
+            starts: Array of arrow start positions (shape: [N, 3]) or None for empty.
+            ends: Array of arrow end positions / arrowhead tips (shape: [N, 3]) or None for empty.
+            colors: Array of arrow colors (shape: [N, 3]) or tuple/list of RGB or None for empty.
+            width: Reserved for future use (world-space line width).
+                Currently ignored; pixel dimensions are controlled by
+                ``RendererGL.arrow_scale``.
+            hidden: Whether the arrows are initially hidden.
+        """
+        if starts is None or ends is None or colors is None:
+            if name in self.arrows:
+                self.arrows[name].update(None, None, None)
+            return
+
+        assert isinstance(starts, wp.array)
+        assert isinstance(ends, wp.array)
+        num_arrows = len(starts)
+        assert len(ends) == num_arrows, "Number of arrow ends must match arrow begins"
+
+        if isinstance(colors, tuple | list):
+            if num_arrows > 0:
+                color_vec = wp.vec3(*colors)
+                colors = wp.zeros(num_arrows, dtype=wp.vec3, device=self.device)
+                colors.fill_(color_vec)
+            else:
+                colors = wp.array([], dtype=wp.vec3, device=self.device)
+        elif isinstance(colors, wp.array) and colors.dtype == wp.float32:
+            colors = colors.reshape((num_arrows, 3)).view(dtype=wp.vec3)
+
+        assert isinstance(colors, wp.array)
+        assert len(colors) == num_arrows, "Number of arrow colors must match arrow begins"
+
+        if name not in self.arrows:
+            max_arrows = max(num_arrows, 1000)
+            self.arrows[name] = LinesGL(max_arrows, self.device, hidden=hidden)
+        elif num_arrows > self.arrows[name].max_lines:
+            self.arrows[name].destroy()
+            max_arrows = max(num_arrows, self.arrows[name].max_lines * 2)
+            self.arrows[name] = LinesGL(max_arrows, self.device, hidden=hidden)
+
+        self.arrows[name].update(starts, ends, colors)
+        self.arrows[name].hidden = hidden
 
     @override
     def log_wireframe_shape(
@@ -980,6 +1058,7 @@ def log_points(
             old = self.objects[name]
             new_capacity = max(num_points, old.num_instances * 2)
             self.objects[name] = MeshInstancerGL(new_capacity, self._point_mesh)
+            del old
             object_recreated = True
 
         if radii is None:
@@ -1084,8 +1163,10 @@ def log_gaussian(
             self.objects[name].cast_shadow = False
             recreated = True
         elif n > self.objects[name].num_instances:
-            self.objects[name] = MeshInstancerGL(max(n, self.objects[name].num_instances * 2), self._gaussian_mesh)
+            old = self.objects[name]
+            self.objects[name] = MeshInstancerGL(max(n, old.num_instances * 2), self._gaussian_mesh)
             self.objects[name].cast_shadow = False
+            del old
             recreated = True
 
         instancer = self.objects[name]
@@ -1383,7 +1464,7 @@ def _update(self):
             return
 
         # Render the scene and present it
-        self.renderer.render(self.camera, self.objects, self.lines, self.wireframe_shapes)
+        self.renderer.render(self.camera, self.objects, self.lines, self.wireframe_shapes, self.arrows)
 
         # Always update FPS tracking, even if UI is hidden
         self._update_fps()
@@ -2104,6 +2185,11 @@ def _render_left_panel(self):
                     show_contacts = self.show_contacts
                     changed, self.show_contacts = imgui.checkbox("Show Contacts", show_contacts)
 
+                    if self.show_contacts:
+                        _, self.renderer.arrow_scale = imgui.slider_float(
+                            "Arrow Scale", self.renderer.arrow_scale, 0.25, 5.0
+                        )
+
                     # Particle visualization
                     show_particles = self.show_particles
                     changed, self.show_particles = imgui.checkbox("Show Particles", show_particles)
@@ -2131,7 +2217,7 @@ def _render_left_panel(self):
 
                     if self.sdf_margin_mode != self.SDFMarginMode.OFF:
                         _, self.renderer.wireframe_line_width = imgui.slider_float(
-                            "Line Width (px)", self.renderer.wireframe_line_width, 0.5, 5.0
+                            "Wireframe Width (px)", self.renderer.wireframe_line_width, 0.5, 5.0
                         )
 
                     # Visual geometry toggle
diff --git a/newton/_src/viewer/viewer_viser.py b/newton/_src/viewer/viewer_viser.py
index 27bb8f38d0..3135bf6cbb 100644
--- a/newton/_src/viewer/viewer_viser.py
+++ b/newton/_src/viewer/viewer_viser.py
@@ -3,6 +3,7 @@
 
 from __future__ import annotations
 
+import collections
 import inspect
 import os
 import warnings
@@ -103,6 +104,7 @@ def __init__(
         verbose: bool = True,
         share: bool = False,
         record_to_viser: str | None = None,
+        plot_history_size: int = 250,
     ):
         """
         Initialize the ViewerViser backend for Newton using the viser visualization library.
@@ -117,9 +119,25 @@ def __init__(
             share: If True, create a publicly accessible URL via viser's share feature.
             record_to_viser: Path to record the viewer to a ``*.viser`` recording file
                 (e.g. "my_recording.viser"). If None, the viewer will not record to a file.
+            plot_history_size: Maximum number of samples kept per
+                :meth:`log_scalar` signal for the live time-series plots.
         """
+        if not isinstance(plot_history_size, int) or isinstance(plot_history_size, bool):
+            raise TypeError("plot_history_size must be an integer")
+        if plot_history_size <= 0:
+            raise ValueError("plot_history_size must be > 0")
+
         viser = self._get_viser()
 
+        # Rolling buffers for log_scalar() time-series plots.
+        self._scalar_buffers: dict[str, collections.deque] = {}
+        self._scalar_accumulators: dict[str, list[float]] = {}
+        self._scalar_smoothing: dict[str, int] = {}
+        self._scalar_dirty: set[str] = set()
+        self._plot_handles: dict[str, Any] = {}
+        self._plot_folder: Any = None
+        self._plot_history_size = plot_history_size
+
         super().__init__()
 
         self._running = True
@@ -164,6 +182,29 @@ def __init__(
         if self._serializer is not None and verbose:
             print(f"Recording to: {record_to_viser}")
 
+    @override
+    def clear_model(self):
+        """Reset model-dependent state, including scalar plot buffers."""
+        # Remove plot handles from the GUI.
+        for handle in self._plot_handles.values():
+            try:
+                handle.remove()
+            except Exception:
+                pass
+        self._plot_handles.clear()
+        if self._plot_folder is not None:
+            try:
+                self._plot_folder.remove()
+            except Exception:
+                pass
+            self._plot_folder = None
+        self._scalar_buffers.clear()
+        self._scalar_accumulators.clear()
+        self._scalar_smoothing.clear()
+        self._scalar_dirty.clear()
+
+        super().clear_model()
+
     def _setup_scene(self):
         """Set up the default scene configuration."""
 
@@ -578,7 +619,9 @@ def log_instances(
         if batched_colors is None:
             batched_colors = np.full((num_instances, 3), 180, dtype=np.uint8)
 
-        # Create new batched mesh
+        # Create new batched mesh.
+        # LOD is disabled because viser's automatic mesh simplification creates
+        # holes in complex geometry (e.g. terrain), causing popping artifacts.
         if use_trimesh:
             handle = self._call_scene_method(
                 self._server.scene.add_batched_meshes_trimesh,
@@ -587,7 +630,7 @@ def log_instances(
                 batched_positions=positions,
                 batched_wxyzs=quats_wxyz,
                 batched_scales=batched_scales,
-                lod="auto",
+                lod="off",
             )
         else:
             handle = self._call_scene_method(
@@ -599,7 +642,7 @@ def log_instances(
                 batched_wxyzs=quats_wxyz,
                 batched_scales=batched_scales,
                 batched_colors=batched_colors,
-                lod="auto",
+                lod="off",
             )
 
         self._scene_handles[name] = handle
@@ -627,11 +670,54 @@ def end_frame(self):
         End the current frame.
 
         If recording is active, inserts a sleep command for playback timing.
+        Updates scalar plots if any data changed since last frame.
         """
+        self._update_scalar_plots()
+
         if self._serializer is not None:
             # Insert sleep for frame timing during recording
             self._serializer.insert_sleep(self._frame_dt)
 
+    def _update_scalar_plots(self):
+        """Create or update uPlot chart handles for dirty scalar signals."""
+        if not self._scalar_dirty:
+            return
+
+        try:
+            from viser import uplot
+
+            # Create the plots folder on first use.
+            if self._plot_folder is None:
+                self._plot_folder = self._server.gui.add_folder("Plots")
+
+            n = self._plot_history_size
+            x = np.arange(n, dtype=np.float64)
+
+            for name in self._scalar_dirty:
+                buf = self._scalar_buffers[name]
+                y = np.full(n, np.nan, dtype=np.float64)
+                y[n - len(buf) :] = np.array(buf, dtype=np.float64)
+
+                handle = self._plot_handles.get(name)
+                if handle is None:
+                    with self._plot_folder:
+                        handle = self._server.gui.add_uplot(
+                            data=(x, y),
+                            series=(
+                                uplot.Series(label="step"),
+                                uplot.Series(label=name, stroke="#3b82f6", width=2),
+                            ),
+                            scales={"x": uplot.Scale(time=False)},
+                            aspect=2.0,
+                        )
+                    self._plot_handles[name] = handle
+                else:
+                    handle.data = (x, y)
+        except Exception:
+            pass
+
+        self._scalar_dirty.clear()
+
     @override
     def is_running(self) -> bool:
         """
@@ -903,16 +989,56 @@ def log_array(self, name: str, array: wp.array[Any] | np.ndarray):
         pass
 
     @override
-    def log_scalar(self, name: str, value: int | float | bool | np.number, *, clear: bool = False, smoothing: int = 1):
-        """Viser viewer does not visualize scalar signals.
+    def log_scalar(
+        self,
+        name: str,
+        value: int | float | bool | np.number,
+        *,
+        clear: bool = False,
+        smoothing: int = 1,
+    ):
+        """
+        Log a scalar value as a live time-series plot.
+
+        Each unique *name* creates a separate uPlot chart in a "Plots"
+        folder in the GUI sidebar.  Values are stored in a rolling
+        buffer of the last ``plot_history_size`` samples.
 
         Args:
             name: Unique path/name for the scalar signal.
-            value: Scalar value to visualize.
-            clear: Ignored by this backend.
-            smoothing: Ignored by this backend.
+            value: Scalar value to record.
+            clear: If ``True``, discard previously recorded samples for
+                *name* before logging the new value.
+            smoothing: Number of raw samples to average before committing
+                a point to the plot history.  Defaults to ``1`` (no smoothing).
         """
-        pass
+        if smoothing < 1:
+            raise ValueError("smoothing must be >= 1")
+        val = float(value.item() if hasattr(value, "item") else value)
+        buf = self._scalar_buffers.get(name)
+        if buf is None:
+            buf = collections.deque(maxlen=self._plot_history_size)
+            self._scalar_buffers[name] = buf
+        elif clear:
+            buf.clear()
+            self._scalar_accumulators.pop(name, None)
+
+        if self._scalar_smoothing.get(name, smoothing) != smoothing:
+            self._scalar_accumulators.pop(name, None)
+        self._scalar_smoothing[name] = smoothing
+        if smoothing <= 1:
+            buf.append(val)
+        else:
+            acc = self._scalar_accumulators.get(name)
+            if acc is None:
+                acc = []
+                self._scalar_accumulators[name] = acc
+            acc.append(val)
+            if len(acc) >= smoothing:
+                buf.append(sum(acc) / len(acc))
+                acc.clear()
+
+        self._scalar_dirty.add(name)
 
     def show_notebook(self, width: int | str = "100%", height: int | str = 400):
         """
diff --git a/newton/examples/__init__.py b/newton/examples/__init__.py
index 649b8280f6..92b5701436 100644
--- a/newton/examples/__init__.py
+++ b/newton/examples/__init__.py
@@ -471,6 +471,12 @@ def create_parser():
         metavar="KEY=VALUE",
         help="Override a warp.config attribute (repeatable).",
     )
+    parser.add_argument(
+        "--realtime",
+        action="store_true",
+        default=False,
+        help="Use the most aggressive process priority in benchmark mode.",
+    )
 
     return parser
 
@@ -566,6 +572,48 @@ def _apply_warp_config(parser, args):
         setattr(wp.config, key, value)
 
 
+def _raise_benchmark_priority(realtime=False):
+    """Raise process/thread priority for stable benchmark measurements.
+
+    When *realtime* is True, try to use the most aggressive process priority; failure to raise priority is a fatal error.
+    """
+    import sys  # noqa: PLC0415
+
+    def _fail(msg):
+        if realtime:
+            raise SystemExit(f"Error: {msg}")
+        print(f"Warning: Benchmark running at default process priority. Results may vary. {msg}")
+
+    if sys.platform == "win32":
+        try:
+            import psutil  # noqa: PLC0415
+
+            priority = psutil.REALTIME_PRIORITY_CLASS if realtime else psutil.HIGH_PRIORITY_CLASS
+            psutil.Process().nice(priority)
+        except ModuleNotFoundError:
+            _fail("Install 'psutil' to automatically raise priority.")
+    elif sys.platform == "linux":
+        try:
+            os.nice(-20 if realtime else -15)
+        except PermissionError:
+            _fail("Run with elevated privileges to automatically raise priority.")
+    elif sys.platform == "darwin":
+        import ctypes  # noqa: PLC0415
+        import ctypes.util  # noqa: PLC0415
+
+        try:
+            libsystem = ctypes.CDLL(ctypes.util.find_library("System"))
+            # From <sys/qos.h>
+            QOS_CLASS_USER_INITIATED = 0x19
+            QOS_CLASS_USER_INTERACTIVE = 0x21
+            qos = QOS_CLASS_USER_INTERACTIVE if realtime else QOS_CLASS_USER_INITIATED
+            rc = libsystem.pthread_set_qos_class_self_np(qos, 0)
+            if rc != 0:
+                _fail(f"Failed to automatically raise priority (error {rc}).")
+        except OSError as e:
+            _fail(f"Failed to automatically raise priority: {e}")
+
+
 def init(parser=None):
     """Initialize Newton example components from parsed arguments.
 
@@ -604,9 +652,10 @@ def init(parser=None):
     if args.device:
         wp.set_device(args.device)
 
-    # Benchmark mode forces null viewer
+    # Benchmark mode forces null viewer and raises process/thread priority
     if args.benchmark is not False:
         args.viewer = "null"
+        _raise_benchmark_priority(realtime=args.realtime)
 
     # Create viewer based on type
     if args.viewer == "gl":
diff --git a/newton/examples/basic/example_basic_conveyor.py b/newton/examples/basic/example_basic_conveyor.py
index 81e1244796..b807f50146 100644
--- a/newton/examples/basic/example_basic_conveyor.py
+++ b/newton/examples/basic/example_basic_conveyor.py
@@ -220,7 +220,7 @@ def __init__(self, viewer, args=None):
             z_max=BELT_HALF_THICKNESS - RAIL_BASE_OVERLAP + RAIL_HEIGHT,
             segments=BELT_MESH_SEGMENTS,
             color=(0.66, 0.69, 0.74),  # brushed metal
-            roughness=0.24,
+            roughness=0.5,
             metallic=0.9,
         )
         rail_outer_mesh = create_annular_prism_mesh(
@@ -230,7 +230,7 @@ def __init__(self, viewer, args=None):
             z_max=BELT_HALF_THICKNESS - RAIL_BASE_OVERLAP + RAIL_HEIGHT,
             segments=BELT_MESH_SEGMENTS,
             color=(0.66, 0.69, 0.74),  # brushed metal
-            roughness=0.24,
+            roughness=0.5,
             metallic=0.9,
         )
 
diff --git a/newton/examples/cloth/example_cloth_franka.py b/newton/examples/cloth/example_cloth_franka.py
index 6aeb1e4ee9..9772dfcce2 100644
--- a/newton/examples/cloth/example_cloth_franka.py
+++ b/newton/examples/cloth/example_cloth_franka.py
@@ -28,7 +28,6 @@
 import newton.usd
 import newton.utils
 from newton import Model, ModelBuilder, State, eval_fk
-from newton.math import transform_twist
 from newton.solvers import SolverFeatherstone, SolverVBD
 
 
@@ -68,72 +67,6 @@ def compute_ee_delta(
     ee_delta[world_id] = wp.spatial_vector(pos_diff[0], pos_diff[1], pos_diff[2], ang_diff[0], ang_diff[1], ang_diff[2])
 
 
-def compute_body_jacobian(
-    model: Model,
-    joint_q: wp.array,
-    joint_qd: wp.array,
-    body_id: int | str,  # Can be either body index or body name
-    offset: wp.transform | None = None,
-    velocity: bool = True,
-    include_rotation: bool = False,
-):
-    if isinstance(body_id, str):
-        body_id = model.body_name.get(body_id)
-    if offset is None:
-        offset = wp.transform_identity()
-
-    joint_q.requires_grad = True
-    joint_qd.requires_grad = True
-
-    if velocity:
-
-        @wp.kernel
-        def compute_body_out(body_qd: wp.array[wp.spatial_vector], body_out: wp.array[float]):
-            mv = transform_twist(offset, body_qd[body_id])
-            if wp.static(include_rotation):
-                for i in range(6):
-                    body_out[i] = mv[i]
-            else:
-                for i in range(3):
-                    body_out[i] = mv[3 + i]
-
-        in_dim = model.joint_dof_count
-        out_dim = 6 if include_rotation else 3
-    else:
-
-        @wp.kernel
-        def compute_body_out(body_q: wp.array[wp.transform], body_out: wp.array[float]):
-            tf = body_q[body_id] * offset
-            if wp.static(include_rotation):
-                for i in range(7):
-                    body_out[i] = tf[i]
-            else:
-                for i in range(3):
-                    body_out[i] = tf[i]
-
-        in_dim = model.joint_coord_count
-        out_dim = 7 if include_rotation else 3
-
-    out_state = model.state(requires_grad=True)
-    body_out = wp.empty(out_dim, dtype=float, requires_grad=True)
-    tape = wp.Tape()
-    with tape:
-        eval_fk(model, joint_q, joint_qd, out_state)
-        wp.launch(compute_body_out, 1, inputs=[out_state.body_qd if velocity else out_state.body_q], outputs=[body_out])
-
-    def onehot(i):
-        x = np.zeros(out_dim, dtype=np.float32)
-        x[i] = 1.0
-        return wp.array(x)
-
-    J = np.empty((out_dim, in_dim), dtype=wp.float32)
-    for i in range(out_dim):
-        tape.backward(grads={body_out: onehot(i)})
-        J[i] = joint_qd.grad.numpy() if velocity else joint_q.grad.numpy()
-        tape.zero()
-    return J.astype(np.float32)
-
-
 class Example:
     def __init__(self, viewer, args):
         # parameters
@@ -384,11 +317,31 @@ def onehot(i, out_dim):
         self.Jacobian_one_hots = [onehot(i, out_dim) for i in range(out_dim)]
 
         @wp.kernel
-        def compute_body_out(body_qd: wp.array[wp.spatial_vector], body_out: wp.array[float]):
-            # TODO verify transform twist
-            mv = transform_twist(wp.static(self.endeffector_offset), body_qd[wp.static(self.endeffector_id)])
-            for i in range(6):
-                body_out[i] = mv[i]
+        def compute_body_out(
+            body_q: wp.array[wp.transform],
+            body_qd: wp.array[wp.spatial_vector],
+            body_com: wp.array[wp.vec3],
+            body_out: wp.array[float],
+        ):
+            # body_qd is COM-referenced (linear velocity at body COM, world
+            # frame).  Compute EE tip velocity in world frame, consistent with
+            # compute_ee_delta which measures the tip position as
+            # transform_point(body_q, ee_offset).
+            ee_id = wp.static(self.endeffector_id)
+            ee_offset = wp.static(wp.vec3(*self.endeffector_offset.p))
+            X_wb = body_q[ee_id]
+            # Vector from COM to EE tip, rotated to world frame
+            r_world = wp.transform_vector(X_wb, ee_offset - body_com[ee_id])
+            qd = body_qd[ee_id]
+            omega = wp.spatial_bottom(qd)
+            v_com = wp.spatial_top(qd)
+            v_tip = v_com + wp.cross(omega, r_world)
+            body_out[0] = v_tip[0]
+            body_out[1] = v_tip[1]
+            body_out[2] = v_tip[2]
+            body_out[3] = omega[0]
+            body_out[4] = omega[1]
+            body_out[5] = omega[2]
 
         self.compute_body_out_kernel = compute_body_out
         self.temp_state_for_jacobian = self.model.state(requires_grad=True)
@@ -414,7 +367,7 @@ def create_articulation(self, builder):
         builder.add_urdf(
             str(asset_path / "urdf" / "fr3_franka_hand.urdf"),
             xform=wp.transform(
-                (-50.0, -50.0, -10.0),
+                (-50.0, -50.0, 0.0),
                 wp.quat_identity(),
             ),
             floating=False,
@@ -431,43 +384,45 @@ def create_articulation(self, builder):
         self.robot_key_poses = np.array(
             [
                 # translation_duration, gripper transform (3D position [cm], 4D quaternion), gripper activation
+                # descend to working height before approaching the cloth
+                [4, 31.0, -60.0, 40.0, 0.8536, -0.3536, 0.3536, -0.1464, clamp_open_activation_val],
                 # top left
-                [2.5, 31.0, -60.0, 23.0, 1, 0.0, 0.0, 0.0, clamp_open_activation_val],
-                [2, 31.0, -60.0, 23.0, 1, 0.0, 0.0, 0.0, clamp_close_activation_val],
-                [2, 26.0, -60.0, 26.0, 1, 0.0, 0.0, 0.0, clamp_close_activation_val],
-                [2, 12.0, -60.0, 31.0, 1, 0.0, 0.0, 0.0, clamp_close_activation_val],
-                [3, -6.0, -60.0, 31.0, 1, 0.0, 0.0, 0.0, clamp_close_activation_val],
-                [1, -6.0, -60.0, 31.0, 1, 0.0, 0.0, 0.0, clamp_open_activation_val],
+                [2, 31.0, -60.0, 20.0, 0.8536, -0.3536, 0.3536, -0.1464, clamp_open_activation_val],
+                [2, 31.0, -60.0, 20.0, 0.8536, -0.3536, 0.3536, -0.1464, clamp_close_activation_val],
+                [2, 26.0, -60.0, 26.0, 0.8536, -0.3536, 0.3536, -0.1464, clamp_close_activation_val],
+                [2, 12.0, -60.0, 31.0, 0.8536, -0.3536, 0.3536, -0.1464, clamp_close_activation_val],
+                [3, -6.0, -60.0, 31.0, 0.8536, -0.3536, 0.3536, -0.1464, clamp_close_activation_val],
+                [1, -6.0, -60.0, 31.0, 0.8536, -0.3536, 0.3536, -0.1464, clamp_open_activation_val],
                 # bottom left
-                [2, 15.0, -33.0, 31.0, 1, 0.0, 0.0, 0.0, clamp_open_activation_val],
-                [3, 15.0, -33.0, 21.0, 1, 0.0, 0.0, 0.0, clamp_open_activation_val],
-                [3, 15.0, -33.0, 21.0, 1, 0.0, 0.0, 0.0, clamp_close_activation_val],
-                [2, 15.0, -33.0, 28.0, 1, 0.0, 0.0, 0.0, clamp_close_activation_val],
-                [3, -2.0, -33.0, 28.0, 1, 0.0, 0.0, 0.0, clamp_close_activation_val],
-                [1, -2.0, -33.0, 28.0, 1, 0.0, 0.0, 0.0, clamp_open_activation_val],
+                [2, 15.0, -33.0, 31.0, 0.8536, -0.3536, 0.3536, -0.1464, clamp_open_activation_val],
+                [3, 15.0, -33.0, 21.0, 0.8536, -0.3536, 0.3536, -0.1464, clamp_open_activation_val],
+                [3, 15.0, -33.0, 21.0, 0.8536, -0.3536, 0.3536, -0.1464, clamp_close_activation_val],
+                [2, 15.0, -33.0, 28.0, 0.8536, -0.3536, 0.3536, -0.1464, clamp_close_activation_val],
+                [3, -2.0, -33.0, 28.0, 0.8536, -0.3536, 0.3536, -0.1464, clamp_close_activation_val],
+                [1, -2.0, -33.0, 28.0, 0.8536, -0.3536, 0.3536, -0.1464, clamp_open_activation_val],
                 # top right
-                [2, -28.0, -60.0, 28.0, 1, 0.0, 0.0, 0.0, clamp_open_activation_val],
-                [2, -28.0, -60.0, 20.0, 1, 0.0, 0.0, 0.0, clamp_open_activation_val],
-                [2, -28.0, -60.0, 20.0, 1, 0.0, 0.0, 0.0, clamp_close_activation_val],
-                [2, -18.0, -60.0, 31.0, 1, 0.0, 0.0, 0.0, clamp_close_activation_val],
-                [3, 5.0, -60.0, 31.0, 1, 0.0, 0.0, 0.0, clamp_close_activation_val],
-                [1, 5.0, -60.0, 31.0, 1, 0.0, 0.0, 0.0, clamp_open_activation_val],
+                [2, -28.0, -60.0, 28.0, 0.9239, -0.3827, 0.0, 0.0, clamp_open_activation_val],
+                [2, -28.0, -60.0, 20.0, 0.9239, -0.3827, 0.0, 0.0, clamp_open_activation_val],
+                [2, -28.0, -60.0, 20.0, 0.9239, -0.3827, 0.0, 0.0, clamp_close_activation_val],
+                [2, -18.0, -60.0, 31.0, 0.9239, -0.3827, 0.0, 0.0, clamp_close_activation_val],
+                [3, 5.0, -60.0, 31.0, 0.9239, -0.3827, 0.0, 0.0, clamp_close_activation_val],
+                [1, 5.0, -60.0, 31.0, 0.9239, -0.3827, 0.0, 0.0, clamp_open_activation_val],
                 # bottom right
-                [3, -18.0, -30.0, 20.5, 1, 0.0, 0.0, 0.0, clamp_open_activation_val],
-                [3, -18.0, -30.0, 20.5, 1, 0.0, 0.0, 0.0, clamp_close_activation_val],
-                [2, -3.0, -30.0, 31.0, 1, 0.0, 0.0, 0.0, clamp_close_activation_val],
-                [3, -3.0, -30.0, 31.0, 1, 0.0, 0.0, 0.0, clamp_close_activation_val],
-                [2, -3.0, -30.0, 31.0, 1, 0.0, 0.0, 0.0, clamp_open_activation_val],
+                [3, -18.0, -30.0, 20.5, 0.9239, -0.3827, 0.0, 0.0, clamp_open_activation_val],
+                [3, -18.0, -30.0, 20.5, 0.9239, -0.3827, 0.0, 0.0, clamp_close_activation_val],
+                [2, -3.0, -30.0, 31.0, 0.9239, -0.3827, 0.0, 0.0, clamp_close_activation_val],
+                [3, -3.0, -30.0, 31.0, 0.9239, -0.3827, 0.0, 0.0, clamp_close_activation_val],
+                [2, -3.0, -30.0, 31.0, 0.9239, -0.3827, 0.0, 0.0, clamp_open_activation_val],
                 # bottom
-                [2, 0.0, -20.0, 30.0, 1, 0.0, 0.0, 0.0, clamp_open_activation_val],
-                [2, 0.0, -20.0, 19.5, 1, 0.0, 0.0, 0.0, clamp_open_activation_val],
-                [2, 0.0, -20.0, 19.5, 1, 0.0, 0.0, 0.0, clamp_close_activation_val],
-                [2, 0.0, -20.0, 35.0, 1, 0.0, 0.0, 0.0, clamp_close_activation_val],
-                [1, 0.0, -30.0, 35.0, 1, 0.0, 0.0, 0.0, clamp_close_activation_val],
-                [1.5, 0.0, -30.0, 35.0, 1, 0.0, 0.0, 0.0, clamp_close_activation_val],
-                [1.5, 0.0, -40.0, 35.0, 1, 0.0, 0.0, 0.0, clamp_close_activation_val],
-                [1.5, 0.0, -40.0, 35.0, 1, 0.0, 0.0, 0.0, clamp_open_activation_val],
-                [2, -28.0, -60.0, 28.0, 1, 0.0, 0.0, 0.0, clamp_open_activation_val],
+                [2, 0.0, -20.0, 30.0, 0.9239, -0.3827, 0.0, 0.0, clamp_open_activation_val],
+                [2, 0.0, -20.0, 19.5, 0.9239, -0.3827, 0.0, 0.0, clamp_open_activation_val],
+                [2, 0.0, -20.0, 19.5, 0.9239, -0.3827, 0.0, 0.0, clamp_close_activation_val],
+                [2, 0.0, -20.0, 35.0, 0.9239, -0.3827, 0.0, 0.0, clamp_close_activation_val],
+                [1, 0.0, -30.0, 35.0, 0.9239, -0.3827, 0.0, 0.0, clamp_close_activation_val],
+                [1.5, 0.0, -30.0, 35.0, 0.9239, -0.3827, 0.0, 0.0, clamp_close_activation_val],
+                [1.5, 0.0, -40.0, 35.0, 0.9239, -0.3827, 0.0, 0.0, clamp_close_activation_val],
+                [1.5, 0.0, -40.0, 35.0, 0.9239, -0.3827, 0.0, 0.0, clamp_open_activation_val],
+                [2, -28.0, -60.0, 28.0, 0.9239, -0.3827, 0.0, 0.0, clamp_open_activation_val],
             ],
             dtype=np.float32,
         )
@@ -508,7 +463,14 @@ def compute_body_jacobian(
         with tape:
             eval_fk(model, joint_q, joint_qd, self.temp_state_for_jacobian)
             wp.launch(
-                self.compute_body_out_kernel, 1, inputs=[self.temp_state_for_jacobian.body_qd], outputs=[self.body_out]
+                self.compute_body_out_kernel,
+                1,
+                inputs=[
+                    self.temp_state_for_jacobian.body_q,
+                    self.temp_state_for_jacobian.body_qd,
+                    self.model.body_com,
+                ],
+                outputs=[self.body_out],
             )
 
         for i in range(out_dim):
diff --git a/newton/examples/robot/example_robot_panda_hydro.py b/newton/examples/robot/example_robot_panda_hydro.py
index cb01f866e8..f09ece7b90 100644
--- a/newton/examples/robot/example_robot_panda_hydro.py
+++ b/newton/examples/robot/example_robot_panda_hydro.py
@@ -431,21 +431,7 @@ def test_final(self):
                 f"max lift={max_lift:.3f} (expected > {min_lift_height})"
             )
 
-        # Verify that the object ended up in the cup
-        if self.put_in_cup:
-            body_q = self.state_0.body_q.numpy()
-            cup_x, cup_y, cup_z = self.cup_pos
-            tolerance_xy = 0.05
-            min_z = cup_z - 0.05
-
-            for world_idx in range(self.world_count):
-                object_body_idx = world_idx * self.bodies_per_world + self.object_body_local
-                x, y, z = body_q[object_body_idx][:3]
-                assert abs(x - cup_x) < tolerance_xy and abs(y - cup_y) < tolerance_xy and z > min_z, (
-                    f"World {world_idx}: Object is not in the cup. "
-                    f"Object pos=({x:.3f}, {y:.3f}, {z:.3f}), "
-                    f"cup pos=({cup_x:.3f}, {cup_y:.3f}, {cup_z:.3f})"
-                )
+        # NOTE: in-cup placement check removed due to flaky failures (see #1345)
 
     def setup_ik(self):
         self.ee_index = 10
diff --git a/newton/tests/assets/humanoid_mjc.usda b/newton/tests/assets/humanoid_mjc.usda
new file mode 100644
index 0000000000..ac7b207b19
--- /dev/null
+++ b/newton/tests/assets/humanoid_mjc.usda
@@ -0,0 +1,1878 @@
+#usda 1.0
+(
+    customLayerData = {
+        string creator = "MuJoCo USD Converter v0.1.0a5"
+    }
+    defaultPrim = "humanoid"
+    doc = """Generated from Composed Stage of root layer C:\\Users\\eric-\\AppData\\Local\\Temp\\tmpowzafb7r\\humanoid.usdc
+
+
+Generated from Composed Stage of root layer C:\\Users\\eric-\\source\\repos\\mujoco-usd-converter\\humanoid.usda\\humanoid.usdc
+"""
+    kilogramsPerUnit = 1
+    metersPerUnit = 1
+    upAxis = "Z"
+)
+
+def Xform "humanoid" (
+    apiSchemas = ["GeomModelAPI"]
+    assetInfo = {
+        string name = "humanoid"
+    }
+    kind = "component"
+)
+{
+    float3[] extentsHint = [(-100, -100, -1.2882077), (100, 100, 0.28), (3.4028235e38, 3.4028235e38, 3.4028235e38), (-3.4028235e38, -3.4028235e38, -3.4028235e38), (3.4028235e38, 3.4028235e38, 3.4028235e38), (-3.4028235e38, -3.4028235e38, -3.4028235e38), (-0.12106484, -0.3955004, -1.2915409), (0.40130424, 0.3955004, 0.1318431)]
+
+    def Scope "Geometry"
+    {
+        def Plane "floor" (
+            apiSchemas = ["PhysicsCollisionAPI", "MjcCollisionAPI", "MaterialBindingAPI"]
+        )
+        {
+            uniform token axis = "Z"
+            float3[] extent = [(-100, -100, -0), (100, 100, 0)]
+            double length = 200
+            rel material:binding:physics = </humanoid/Physics/PhysicsMaterial>
+            color3f[] primvars:displayColor = [(0.5, 0.5, 0.5)] (
+                interpolation = "constant"
+            )
+            int[] primvars:displayColor:indices = None
+            float[] primvars:displayOpacity = [1] (
+                interpolation = "constant"
+            )
+            int[] primvars:displayOpacity:indices = None
+            double width = 200
+            quatf xformOp:orient = (1, 0, 0, 0)
+            float3 xformOp:scale = (1, 1, 1)
+            double3 xformOp:translate = (0, 0, 0)
+            uniform token[] xformOpOrder = ["xformOp:translate", "xformOp:orient", "xformOp:scale"]
+        }
+
+        def Xform "torso" (
+            apiSchemas = ["PhysicsRigidBodyAPI", "PhysicsArticulationRootAPI"]
+        )
+        {
+            quatf xformOp:orient = (1, 0, 0, 0)
+            float3 xformOp:scale = (1, 1, 1)
+            double3 xformOp:translate = (0, 0, 0)
+            uniform token[] xformOpOrder = ["xformOp:translate", "xformOp:orient", "xformOp:scale"]
+
+            def Capsule "torso" (
+                apiSchemas = ["PhysicsCollisionAPI", "MjcCollisionAPI", "MaterialBindingAPI"]
+            )
+            {
+                uniform token axis = "Z"
+                float3[] extent = [(-0.07, -0.07, -0.14), (0.07, 0.07, 0.14)]
+                double height = 0.14
+                rel material:binding:physics = </humanoid/Physics/PhysicsMaterial_1>
+                uniform int mjc:condim = 1
+                uniform double[] mjc:solimp = [0.9, 0.99, 0.003, 0.5, 2]
+                uniform double[] mjc:solref = [0.015, 1]
+                color3f[] primvars:displayColor = [(0.5, 0.5, 0.5)] (
+                    interpolation = "constant"
+                )
+                int[] primvars:displayColor:indices = None
+                float[] primvars:displayOpacity = [1] (
+                    interpolation = "constant"
+                )
+                int[] primvars:displayOpacity:indices = None
+                double radius = 0.07
+                quatf xformOp:orient = (0.7071068, -0.7071067, 0, 0)
+                float3 xformOp:scale = (1, 1, 1)
+                double3 xformOp:translate = (0, 0, 0)
+                uniform token[] xformOpOrder = ["xformOp:translate", "xformOp:orient", "xformOp:scale"]
+            }
+
+            def Capsule "upper_waist" (
+                apiSchemas = ["PhysicsCollisionAPI", "MjcCollisionAPI", "MaterialBindingAPI"]
+            )
+            {
+                uniform token axis = "Z"
+                float3[] extent = [(-0.06, -0.06, -0.12), (0.06, 0.06, 0.12)]
+                double height = 0.12
+                rel material:binding:physics = </humanoid/Physics/PhysicsMaterial_1>
+                uniform int mjc:condim = 1
+                uniform double[] mjc:solimp = [0.9, 0.99, 0.003, 0.5, 2]
+                uniform double[] mjc:solref = [0.015, 1]
+                color3f[] primvars:displayColor = [(0.5, 0.5, 0.5)] (
+                    interpolation = "constant"
+                )
+                int[] primvars:displayColor:indices = None
+                float[] primvars:displayOpacity = [1] (
+                    interpolation = "constant"
+                )
+                int[] primvars:displayOpacity:indices = None
+                double radius = 0.06
+                quatf xformOp:orient = (0.7071068, -0.7071067, 0, 0)
+                float3 xformOp:scale = (1, 1, 1)
+                double3 xformOp:translate = (-0.01, 0, -0.12)
+                uniform token[] xformOpOrder = ["xformOp:translate", "xformOp:orient", "xformOp:scale"]
+            }
+
+            def Sphere "head" (
+                apiSchemas = ["PhysicsCollisionAPI", "MjcCollisionAPI", "MaterialBindingAPI"]
+            )
+            {
+                float3[] extent = [(-0.09, -0.09, -0.09), (0.09, 0.09, 0.09)]
+                rel material:binding:physics = </humanoid/Physics/PhysicsMaterial_1>
+                uniform int mjc:condim = 1
+                uniform double[] mjc:solimp = [0.9, 0.99, 0.003, 0.5, 2]
+                uniform double[] mjc:solref = [0.015, 1]
+                color3f[] primvars:displayColor = [(0.5, 0.5, 0.5)] (
+                    interpolation = "constant"
+                )
+                int[] primvars:displayColor:indices = None
+                float[] primvars:displayOpacity = [1] (
+                    interpolation = "constant"
+                )
+                int[] primvars:displayOpacity:indices = None
+                double radius = 0.09
+                quatf xformOp:orient = (1, 0, 0, 0)
+                float3 xformOp:scale = (1, 1, 1)
+                double3 xformOp:translate = (0, 0, 0.19)
+                uniform token[] xformOpOrder = ["xformOp:translate", "xformOp:orient", "xformOp:scale"]
+            }
+
+            def Cube "root" (
+                apiSchemas = ["MjcSiteAPI"]
+            )
+            {
+                float3[] extent = [(-1, -1, -1), (1, 1, 1)]
+                uniform int mjc:group = 3
+                color3f[] primvars:displayColor = [(1, 0, 0)] (
+                    interpolation = "constant"
+                )
+                int[] primvars:displayColor:indices = None
+                float[] primvars:displayOpacity = [1] (
+                    interpolation = "constant"
+                )
+                int[] primvars:displayOpacity:indices = None
+                uniform token purpose = "guide"
+                double size = 2
+                quatf xformOp:orient = (1, 0, 0, 0)
+                float3 xformOp:scale = (0.01, 0.01, 0.02)
+                double3 xformOp:translate = (0, 0, 0)
+                uniform token[] xformOpOrder = ["xformOp:translate", "xformOp:orient", "xformOp:scale"]
+            }
+
+            def Cube "torso_1" (
+                apiSchemas = ["MjcSiteAPI"]
+                displayName = "torso"
+            )
+            {
+                float3[] extent = [(-1, -1, -1), (1, 1, 1)]
+                uniform int mjc:group = 3
+                color3f[] primvars:displayColor = [(0, 0, 1)] (
+                    interpolation = "constant"
+                )
+                int[] primvars:displayColor:indices = None
+                float[] primvars:displayOpacity = [0.3] (
+                    interpolation = "constant"
+                )
+                int[] primvars:displayOpacity:indices = None
+                uniform token purpose = "guide"
+                double size = 2
+                quatf xformOp:orient = (1, 0, 0, 0)
+                float3 xformOp:scale = (0.075, 0.14, 0.13)
+                double3 xformOp:translate = (0, 0, -0.05)
+                uniform token[] xformOpOrder = ["xformOp:translate", "xformOp:orient", "xformOp:scale"]
+            }
+
+            def Xform "lower_waist" (
+                apiSchemas = ["PhysicsRigidBodyAPI"]
+            )
+            {
+                quatf xformOp:orient = (0.999998, 0, -0.0020132342, 0)
+                float3 xformOp:scale = (1, 1, 1)
+                double3 xformOp:translate = (-0.01, 0, -0.26)
+                uniform token[] xformOpOrder = ["xformOp:translate", "xformOp:orient", "xformOp:scale"]
+
+                def Capsule "lower_waist" (
+                    apiSchemas = ["PhysicsCollisionAPI", "MjcCollisionAPI", "MaterialBindingAPI"]
+                )
+                {
+                    uniform token axis = "Z"
+                    float3[] extent = [(-0.06, -0.06, -0.12), (0.06, 0.06, 0.12)]
+                    double height = 0.12
+                    rel material:binding:physics = </humanoid/Physics/PhysicsMaterial_1>
+                    uniform int mjc:condim = 1
+                    uniform double[] mjc:solimp = [0.9, 0.99, 0.003, 0.5, 2]
+                    uniform double[] mjc:solref = [0.015, 1]
+                    color3f[] primvars:displayColor = [(0.5, 0.5, 0.5)] (
+                        interpolation = "constant"
+                    )
+                    int[] primvars:displayColor:indices = None
+                    float[] primvars:displayOpacity = [1] (
+                        interpolation = "constant"
+                    )
+                    int[] primvars:displayOpacity:indices = None
+                    double radius = 0.06
+                    quatf xformOp:orient = (0.7071068, -0.7071067, 0, 0)
+                    float3 xformOp:scale = (1, 1, 1)
+                    double3 xformOp:translate = (0, 0, 0)
+                    uniform token[] xformOpOrder = ["xformOp:translate", "xformOp:orient", "xformOp:scale"]
+                }
+
+                def Capsule "lower_waist_1" (
+                    apiSchemas = ["MjcSiteAPI"]
+                    displayName = "lower_waist"
+                )
+                {
+                    uniform token axis = "Z"
+                    float3[] extent = [(-0.061, -0.061, -0.121), (0.061, 0.061, 0.121)]
+                    double height = 0.12
+                    uniform int mjc:group = 3
+                    color3f[] primvars:displayColor = [(0, 0, 1)] (
+                        interpolation = "constant"
+                    )
+                    int[] primvars:displayColor:indices = None
+                    float[] primvars:displayOpacity = [0.3] (
+                        interpolation = "constant"
+                    )
+                    int[] primvars:displayOpacity:indices = None
+                    uniform token purpose = "guide"
+                    double radius = 0.061
+                    quatf xformOp:orient = (0.7071068, -0.7071067, 0, 0)
+                    float3 xformOp:scale = (1, 1, 1)
+                    double3 xformOp:translate = (0, 0, 0)
+                    uniform token[] xformOpOrder = ["xformOp:translate", "xformOp:orient", "xformOp:scale"]
+                }
+
+                def Xform "pelvis" (
+                    apiSchemas = ["PhysicsRigidBodyAPI"]
+                )
+                {
+                    quatf xformOp:orient = (0.999998, 0, -0.0020132342, 0)
+                    float3 xformOp:scale = (1, 1, 1)
+                    double3 xformOp:translate = (0, 0, -0.165)
+                    uniform token[] xformOpOrder = ["xformOp:translate", "xformOp:orient", "xformOp:scale"]
+
+                    def Capsule "butt" (
+                        apiSchemas = ["PhysicsCollisionAPI", "MjcCollisionAPI", "MaterialBindingAPI"]
+                    )
+                    {
+                        uniform token axis = "Z"
+                        float3[] extent = [(-0.09, -0.09, -0.16), (0.09, 0.09, 0.16)]
+                        double height = 0.14
+                        rel material:binding:physics = </humanoid/Physics/PhysicsMaterial_1>
+                        uniform int mjc:condim = 1
+                        uniform double[] mjc:solimp = [0.9, 0.99, 0.003, 0.5, 2]
+                        uniform double[] mjc:solref = [0.015, 1]
+                        color3f[] primvars:displayColor = [(0.5, 0.5, 0.5)] (
+                            interpolation = "constant"
+                        )
+                        int[] primvars:displayColor:indices = None
+                        float[] primvars:displayOpacity = [1] (
+                            interpolation = "constant"
+                        )
+                        int[] primvars:displayOpacity:indices = None
+                        double radius = 0.09
+                        quatf xformOp:orient = (0.7071068, -0.7071067, 0, 0)
+                        float3 xformOp:scale = (1, 1, 1)
+                        double3 xformOp:translate = (-0.02, 0, 0)
+                        uniform token[] xformOpOrder = ["xformOp:translate", "xformOp:orient", "xformOp:scale"]
+                    }
+
+                    def Capsule "butt_1" (
+                        apiSchemas = ["MjcSiteAPI"]
+                        displayName = "butt"
+                    )
+                    {
+                        uniform token axis = "Z"
+                        float3[] extent = [(-0.091, -0.091, -0.161), (0.091, 0.091, 0.161)]
+                        double height = 0.14
+                        uniform int mjc:group = 3
+                        color3f[] primvars:displayColor = [(0, 0, 1)] (
+                            interpolation = "constant"
+                        )
+                        int[] primvars:displayColor:indices = None
+                        float[] primvars:displayOpacity = [0.3] (
+                            interpolation = "constant"
+                        )
+                        int[] primvars:displayOpacity:indices = None
+                        uniform token purpose = "guide"
+                        double radius = 0.091
+                        quatf xformOp:orient = (0.7071068, -0.7071067, 0, 0)
+                        float3 xformOp:scale = (1, 1, 1)
+                        double3 xformOp:translate = (-0.02, 0, 0)
+                        uniform token[] xformOpOrder = ["xformOp:translate", "xformOp:orient", "xformOp:scale"]
+                    }
+
+                    def Xform "right_thigh" (
+                        apiSchemas = ["PhysicsRigidBodyAPI"]
+                    )
+                    {
+                        quatf xformOp:orient = (1, 0, 0, 0)
+                        float3 xformOp:scale = (1, 1, 1)
+                        double3 xformOp:translate = (0, -0.1, -0.04)
+                        uniform token[] xformOpOrder = ["xformOp:translate", "xformOp:orient", "xformOp:scale"]
+
+                        def Capsule "right_thigh" (
+                            apiSchemas = ["PhysicsCollisionAPI", "MjcCollisionAPI", "MaterialBindingAPI"]
+                        )
+                        {
+                            uniform token axis = "Z"
+                            float3[] extent = [(-0.06, -0.06, -0.23007351), (0.06, 0.06, 0.23007351)]
+                            double height = 0.340147027033899
+                            rel material:binding:physics = </humanoid/Physics/PhysicsMaterial_1>
+                            uniform int mjc:condim = 1
+                            uniform double[] mjc:solimp = [0.9, 0.99, 0.003, 0.5, 2]
+                            uniform double[] mjc:solref = [0.015, 1]
+                            color3f[] primvars:displayColor = [(0.5, 0.5, 0.5)] (
+                                interpolation = "constant"
+                            )
+                            int[] primvars:displayColor:indices = None
+                            float[] primvars:displayOpacity = [1] (
+                                interpolation = "constant"
+                            )
+                            int[] primvars:displayOpacity:indices = None
+                            double radius = 0.06
+                            quatf xformOp:orient = (-0.014701115, 0.99989194, 0, 0)
+                            float3 xformOp:scale = (1, 1, 1)
+                            double3 xformOp:translate = (0, 0.005, -0.17)
+                            uniform token[] xformOpOrder = ["xformOp:translate", "xformOp:orient", "xformOp:scale"]
+                        }
+
+                        def Cube "right_hip" (
+                            apiSchemas = ["MjcSiteAPI"]
+                        )
+                        {
+                            float3[] extent = [(-1, -1, -1), (1, 1, 1)]
+                            uniform int mjc:group = 3
+                            color3f[] primvars:displayColor = [(1, 0, 0)] (
+                                interpolation = "constant"
+                            )
+                            int[] primvars:displayColor:indices = None
+                            float[] primvars:displayOpacity = [1] (
+                                interpolation = "constant"
+                            )
+                            int[] primvars:displayOpacity:indices = None
+                            uniform token purpose = "guide"
+                            double size = 2
+                            quatf xformOp:orient = (1, 0, 0, 0)
+                            float3 xformOp:scale = (0.01, 0.01, 0.02)
+                            double3 xformOp:translate = (0, 0, 0)
+                            uniform token[] xformOpOrder = ["xformOp:translate", "xformOp:orient", "xformOp:scale"]
+                        }
+
+                        def Capsule "right_thigh_1" (
+                            apiSchemas = ["MjcSiteAPI"]
+                            displayName = "right_thigh"
+                        )
+                        {
+                            uniform token axis = "Z"
+                            float3[] extent = [(-0.061, -0.061, -0.231), (0.061, 0.061, 0.231)]
+                            double height = 0.34
+                            uniform int mjc:group = 3
+                            color3f[] primvars:displayColor = [(0, 0, 1)] (
+                                interpolation = "constant"
+                            )
+                            int[] primvars:displayColor:indices = None
+                            float[] primvars:displayOpacity = [0.3] (
+                                interpolation = "constant"
+                            )
+                            int[] primvars:displayOpacity:indices = None
+                            uniform token purpose = "guide"
+                            double radius = 0.061
+                            quatf xformOp:orient = (0.99989194, 0.014700842, 0, 0)
+                            float3 xformOp:scale = (1, 1, 1)
+                            double3 xformOp:translate = (0, 0.005, -0.17)
+                            uniform token[] xformOpOrder = ["xformOp:translate", "xformOp:orient", "xformOp:scale"]
+                        }
+
+                        def Xform "right_shin" (
+                            apiSchemas = ["PhysicsRigidBodyAPI"]
+                        )
+                        {
+                            quatf xformOp:orient = (1, 0, 0, 0)
+                            float3 xformOp:scale = (1, 1, 1)
+                            double3 xformOp:translate = (0, 0.01, -0.403)
+                            uniform token[] xformOpOrder = ["xformOp:translate", "xformOp:orient", "xformOp:scale"]
+
+                            def Capsule "right_shin" (
+                                apiSchemas = ["PhysicsCollisionAPI", "MjcCollisionAPI", "MaterialBindingAPI"]
+                            )
+                            {
+                                uniform token axis = "Z"
+                                float3[] extent = [(-0.049, -0.049, -0.199), (0.049, 0.049, 0.199)]
+                                double height = 0.3
+                                rel material:binding:physics = </humanoid/Physics/PhysicsMaterial_1>
+                                uniform int mjc:condim = 1
+                                uniform double[] mjc:solimp = [0.9, 0.99, 0.003, 0.5, 2]
+                                uniform double[] mjc:solref = [0.015, 1]
+                                color3f[] primvars:displayColor = [(0.5, 0.5, 0.5)] (
+                                    interpolation = "constant"
+                                )
+                                int[] primvars:displayColor:indices = None
+                                float[] primvars:displayOpacity = [1] (
+                                    interpolation = "constant"
+                                )
+                                int[] primvars:displayOpacity:indices = None
+                                double radius = 0.049
+                                quatf xformOp:orient = (6.123234e-17, 1, 0, 0)
+                                float3 xformOp:scale = (1, 1, 1)
+                                double3 xformOp:translate = (0, 0, -0.15)
+                                uniform token[] xformOpOrder = ["xformOp:translate", "xformOp:orient", "xformOp:scale"]
+                            }
+
+                            def Cube "right_knee" (
+                                apiSchemas = ["MjcSiteAPI"]
+                            )
+                            {
+                                float3[] extent = [(-1, -1, -1), (1, 1, 1)]
+                                uniform int mjc:group = 3
+                                color3f[] primvars:displayColor = [(1, 0, 0)] (
+                                    interpolation = "constant"
+                                )
+                                int[] primvars:displayColor:indices = None
+                                float[] primvars:displayOpacity = [1] (
+                                    interpolation = "constant"
+                                )
+                                int[] primvars:displayOpacity:indices = None
+                                uniform token purpose = "guide"
+                                double size = 2
+                                quatf xformOp:orient = (1, 0, 0, 0)
+                                float3 xformOp:scale = (0.01, 0.01, 0.02)
+                                double3 xformOp:translate = (0, 0, 0.02)
+                                uniform token[] xformOpOrder = ["xformOp:translate", "xformOp:orient", "xformOp:scale"]
+                            }
+
+                            def Capsule "right_shin_1" (
+                                apiSchemas = ["MjcSiteAPI"]
+                                displayName = "right_shin"
+                            )
+                            {
+                                uniform token axis = "Z"
+                                float3[] extent = [(-0.05, -0.05, -0.2), (0.05, 0.05, 0.2)]
+                                double height = 0.3
+                                uniform int mjc:group = 3
+                                color3f[] primvars:displayColor = [(0, 0, 1)] (
+                                    interpolation = "constant"
+                                )
+                                int[] primvars:displayColor:indices = None
+                                float[] primvars:displayOpacity = [0.3] (
+                                    interpolation = "constant"
+                                )
+                                int[] primvars:displayOpacity:indices = None
+                                uniform token purpose = "guide"
+                                double radius = 0.05
+                                quatf xformOp:orient = (1, 0, 0, 0)
+                                float3 xformOp:scale = (1, 1, 1)
+                                double3 xformOp:translate = (0, 0, -0.15)
+                                uniform token[] xformOpOrder = ["xformOp:translate", "xformOp:orient", "xformOp:scale"]
+                            }
+
+                            def Xform "right_foot" (
+                                apiSchemas = ["PhysicsRigidBodyAPI"]
+                            )
+                            {
+                                quatf xformOp:orient = (1, 0, 0, 0)
+                                float3 xformOp:scale = (1, 1, 1)
+                                double3 xformOp:translate = (0, 0, -0.39)
+                                uniform token[] xformOpOrder = ["xformOp:translate", "xformOp:orient", "xformOp:scale"]
+
+                                def Capsule "right_right_foot" (
+                                    apiSchemas = ["PhysicsCollisionAPI", "MjcCollisionAPI", "MaterialBindingAPI"]
+                                )
+                                {
+                                    uniform token axis = "Z"
+                                    float3[] extent = [(-0.027, -0.027, -0.13247512), (0.027, 0.027, 0.13247512)]
+                                    double height = 0.2109502310972899
+                                    rel material:binding:physics = </humanoid/Physics/PhysicsMaterial_1>
+                                    uniform int mjc:condim = 1
+                                    uniform double[] mjc:solimp = [0.9, 0.99, 0.003, 0.5, 2]
+                                    uniform double[] mjc:solref = [0.015, 1]
+                                    color3f[] primvars:displayColor = [(0.5, 0.5, 0.5)] (
+                                        interpolation = "constant"
+                                    )
+                                    int[] primvars:displayColor:indices = None
+                                    float[] primvars:displayOpacity = [1] (
+                                        interpolation = "constant"
+                                    )
+                                    int[] primvars:displayOpacity:indices = None
+                                    double radius = 0.027
+                                    quatf xformOp:orient = (0.70710677, 0.06704015, 0.7039216, 0)
+                                    float3 xformOp:scale = (1, 1, 1)
+                                    double3 xformOp:translate = (0.035, -0.03, 0)
+                                    uniform token[] xformOpOrder = ["xformOp:translate", "xformOp:orient", "xformOp:scale"]
+                                }
+
+                                def Capsule "left_right_foot" (
+                                    apiSchemas = ["PhysicsCollisionAPI", "MjcCollisionAPI", "MaterialBindingAPI"]
+                                )
+                                {
+                                    uniform token axis = "Z"
+                                    float3[] extent = [(-0.027, -0.027, -0.13247512), (0.027, 0.027, 0.13247512)]
+                                    double height = 0.2109502310972899
+                                    rel material:binding:physics = </humanoid/Physics/PhysicsMaterial_1>
+                                    uniform int mjc:condim = 1
+                                    uniform double[] mjc:solimp = [0.9, 0.99, 0.003, 0.5, 2]
+                                    uniform double[] mjc:solref = [0.015, 1]
+                                    color3f[] primvars:displayColor = [(0.5, 0.5, 0.5)] (
+                                        interpolation = "constant"
+                                    )
+                                    int[] primvars:displayColor:indices = None
+                                    float[] primvars:displayOpacity = [1] (
+                                        interpolation = "constant"
+                                    )
+                                    int[] primvars:displayOpacity:indices = None
+                                    double radius = 0.027
+                                    quatf xformOp:orient = (0.70710677, -0.06704015, 0.7039216, 0)
+                                    float3 xformOp:scale = (1, 1, 1)
+                                    double3 xformOp:translate = (0.035, 0.01, 0)
+                                    uniform token[] xformOpOrder = ["xformOp:translate", "xformOp:orient", "xformOp:scale"]
+                                }
+
+                                def Cube "right_ankle" (
+                                    apiSchemas = ["MjcSiteAPI"]
+                                )
+                                {
+                                    float3[] extent = [(-1, -1, -1), (1, 1, 1)]
+                                    uniform int mjc:group = 3
+                                    color3f[] primvars:displayColor = [(1, 0, 0)] (
+                                        interpolation = "constant"
+                                    )
+                                    int[] primvars:displayColor:indices = None
+                                    float[] primvars:displayOpacity = [1] (
+                                        interpolation = "constant"
+                                    )
+                                    int[] primvars:displayOpacity:indices = None
+                                    uniform token purpose = "guide"
+                                    double size = 2
+                                    quatf xformOp:orient = (1, 0, 0, 0)
+                                    float3 xformOp:scale = (0.01, 0.01, 0.02)
+                                    double3 xformOp:translate = (0, 0, 0)
+                                    uniform token[] xformOpOrder = ["xformOp:translate", "xformOp:orient", "xformOp:scale"]
+                                }
+
+                                def Capsule "right_right_foot_1" (
+                                    apiSchemas = ["MjcSiteAPI"]
+                                    displayName = "right_right_foot"
+                                )
+                                {
+                                    uniform token axis = "Z"
+                                    float3[] extent = [(-0.03, -0.03, -0.14), (0.03, 0.03, 0.14)]
+                                    double height = 0.22
+                                    uniform int mjc:group = 3
+                                    color3f[] primvars:displayColor = [(0, 0, 1)] (
+                                        interpolation = "constant"
+                                    )
+                                    int[] primvars:displayColor:indices = None
+                                    float[] primvars:displayOpacity = [0.3] (
+                                        interpolation = "constant"
+                                    )
+                                    int[] primvars:displayOpacity:indices = None
+                                    uniform token purpose = "guide"
+                                    double radius = 0.03
+                                    quatf xformOp:orient = (0.70710677, 0.06704015, 0.7039216, 0)
+                                    float3 xformOp:scale = (1, 1, 1)
+                                    double3 xformOp:translate = (0.035, -0.03, 0)
+                                    uniform token[] xformOpOrder = ["xformOp:translate", "xformOp:orient", "xformOp:scale"]
+                                }
+
+                                def Capsule "left_right_foot_1" (
+                                    apiSchemas = ["MjcSiteAPI"]
+                                    displayName = "left_right_foot"
+                                )
+                                {
+                                    uniform token axis = "Z"
+                                    float3[] extent = [(-0.03, -0.03, -0.14), (0.03, 0.03, 0.14)]
+                                    double height = 0.22
+                                    uniform int mjc:group = 3
+                                    color3f[] primvars:displayColor = [(0, 0, 1)] (
+                                        interpolation = "constant"
+                                    )
+                                    int[] primvars:displayColor:indices = None
+                                    float[] primvars:displayOpacity = [0.3] (
+                                        interpolation = "constant"
+                                    )
+                                    int[] primvars:displayOpacity:indices = None
+                                    uniform token purpose = "guide"
+                                    double radius = 0.03
+                                    quatf xformOp:orient = (0.70710677, -0.06704015, 0.7039216, 0)
+                                    float3 xformOp:scale = (1, 1, 1)
+                                    double3 xformOp:translate = (0.035, 0.01, 0)
+                                    uniform token[] xformOpOrder = ["xformOp:translate", "xformOp:orient", "xformOp:scale"]
+                                }
+
+                                def PhysicsRevoluteJoint "right_ankle_y" (
+                                    apiSchemas = ["MjcJointAPI"]
+                                )
+                                {
+                                    uniform double mjc:armature = 0.006
+                                    uniform double mjc:damping = 1
+                                    uniform double[] mjc:solimplimit = [0, 0.99, 0.01, 0.5, 2]
+                                    uniform double mjc:stiffness = 2
+                                    uniform token physics:axis = "Y"
+                                    rel physics:body0 = </humanoid/Geometry/torso/lower_waist/pelvis/right_thigh/right_shin>
+                                    rel physics:body1 = </humanoid/Geometry/torso/lower_waist/pelvis/right_thigh/right_shin/right_foot>
+                                    point3f physics:localPos0 = (0, 0, -0.31)
+                                    point3f physics:localPos1 = (0, 0, 0.08)
+                                    quatf physics:localRot0 = (1, 0, 0, 0)
+                                    quatf physics:localRot1 = (1, 0, 0, 0)
+                                    float physics:lowerLimit = -50
+                                    float physics:upperLimit = 50
+                                }
+
+                                def PhysicsRevoluteJoint "right_ankle_x" (
+                                    apiSchemas = ["MjcJointAPI"]
+                                )
+                                {
+                                    uniform double mjc:armature = 0.006
+                                    uniform double mjc:damping = 1
+                                    uniform double[] mjc:solimplimit = [0, 0.99, 0.01, 0.5, 2]
+                                    uniform double mjc:stiffness = 2
+                                    uniform token physics:axis = "X"
+                                    rel physics:body0 = </humanoid/Geometry/torso/lower_waist/pelvis/right_thigh/right_shin>
+                                    rel physics:body1 = </humanoid/Geometry/torso/lower_waist/pelvis/right_thigh/right_shin/right_foot>
+                                    point3f physics:localPos0 = (0, 0, -0.31)
+                                    point3f physics:localPos1 = (0, 0, 0.08)
+                                    quatf physics:localRot0 = (0.97324896, 0, -0.22975293, 0)
+                                    quatf physics:localRot1 = (0.97324896, 0, -0.22975293, 0)
+                                    float physics:lowerLimit = -50
+                                    float physics:upperLimit = 50
+                                }
+                            }
+
+                            def PhysicsRevoluteJoint "right_knee_1" (
+                                apiSchemas = ["MjcJointAPI"]
+                                displayName = "right_knee"
+                            )
+                            {
+                                uniform double mjc:armature = 0.007
+                                uniform double mjc:damping = 0.1
+                                uniform double[] mjc:solimplimit = [0, 0.99, 0.01, 0.5, 2]
+                                uniform double mjc:stiffness = 5
+                                uniform token physics:axis = "Y"
+                                rel physics:body0 = </humanoid/Geometry/torso/lower_waist/pelvis/right_thigh>
+                                rel physics:body1 = </humanoid/Geometry/torso/lower_waist/pelvis/right_thigh/right_shin>
+                                point3f physics:localPos0 = (0, 0.01, -0.383)
+                                point3f physics:localPos1 = (0, 0, 0.02)
+                                quatf physics:localRot0 = (0, -1, 0, 0)
+                                quatf physics:localRot1 = (0, -1, 0, 0)
+                                float physics:lowerLimit = -160
+                                float physics:upperLimit = 2
+                            }
+                        }
+
+                        def PhysicsRevoluteJoint "right_hip_x" (
+                            apiSchemas = ["MjcJointAPI"]
+                        )
+                        {
+                            uniform double mjc:armature = 0.01
+                            uniform double mjc:damping = 5
+                            uniform double[] mjc:solimplimit = [0, 0.99, 0.01, 0.5, 2]
+                            uniform double mjc:stiffness = 10
+                            uniform token physics:axis = "X"
+                            rel physics:body0 = </humanoid/Geometry/torso/lower_waist/pelvis>
+                            rel physics:body1 = </humanoid/Geometry/torso/lower_waist/pelvis/right_thigh>
+                            point3f physics:localPos0 = (-1.7347235e-18, -0.1, -0.04)
+                            point3f physics:localPos1 = (0, 0, 0)
+                            quatf physics:localRot0 = (1, 0, 0, 0)
+                            quatf physics:localRot1 = (1, 0, 0, 0)
+                            float physics:lowerLimit = -25
+                            float physics:upperLimit = 5
+                        }
+
+                        def PhysicsRevoluteJoint "right_hip_z" (
+                            apiSchemas = ["MjcJointAPI"]
+                        )
+                        {
+                            uniform double mjc:armature = 0.01
+                            uniform double mjc:damping = 5
+                            uniform double[] mjc:solimplimit = [0, 0.99, 0.01, 0.5, 2]
+                            uniform double mjc:stiffness = 10
+                            uniform token physics:axis = "Z"
+                            rel physics:body0 = </humanoid/Geometry/torso/lower_waist/pelvis>
+                            rel physics:body1 = </humanoid/Geometry/torso/lower_waist/pelvis/right_thigh>
+                            point3f physics:localPos0 = (-1.7347235e-18, -0.1, -0.04)
+                            point3f physics:localPos1 = (0, 0, 0)
+                            quatf physics:localRot0 = (1, 0, 0, 0)
+                            quatf physics:localRot1 = (1, 0, 0, 0)
+                            float physics:lowerLimit = -60
+                            float physics:upperLimit = 35
+                        }
+
+                        def PhysicsRevoluteJoint "right_hip_y" (
+                            apiSchemas = ["MjcJointAPI"]
+                        )
+                        {
+                            uniform double mjc:armature = 0.01
+                            uniform double mjc:damping = 5
+                            uniform double[] mjc:solimplimit = [0, 0.99, 0.01, 0.5, 2]
+                            uniform double mjc:stiffness = 20
+                            uniform token physics:axis = "Y"
+                            rel physics:body0 = </humanoid/Geometry/torso/lower_waist/pelvis>
+                            rel physics:body1 = </humanoid/Geometry/torso/lower_waist/pelvis/right_thigh>
+                            point3f physics:localPos0 = (-1.7347235e-18, -0.1, -0.04)
+                            point3f physics:localPos1 = (0, 0, 0)
+                            quatf physics:localRot0 = (1, 0, 0, 0)
+                            quatf physics:localRot1 = (1, 0, 0, 0)
+                            float physics:lowerLimit = -80
+                            float physics:upperLimit = 20
+                        }
+                    }
+
+                    def Xform "left_thigh" (
+                        apiSchemas = ["PhysicsRigidBodyAPI"]
+                    )
+                    {
+                        quatf xformOp:orient = (1, 0, 0, 0)
+                        float3 xformOp:scale = (1, 1, 1)
+                        double3 xformOp:translate = (0, 0.1, -0.04)
+                        uniform token[] xformOpOrder = ["xformOp:translate", "xformOp:orient", "xformOp:scale"]
+
+                        def Capsule "left_thigh" (
+                            apiSchemas = ["PhysicsCollisionAPI", "MjcCollisionAPI", "MaterialBindingAPI"]
+                        )
+                        {
+                            uniform token axis = "Z"
+                            float3[] extent = [(-0.06, -0.06, -0.23007351), (0.06, 0.06, 0.23007351)]
+                            double height = 0.340147027033899
+                            rel material:binding:physics = </humanoid/Physics/PhysicsMaterial_1>
+                            uniform int mjc:condim = 1
+                            uniform double[] mjc:solimp = [0.9, 0.99, 0.003, 0.5, 2]
+                            uniform double[] mjc:solref = [0.015, 1]
+                            color3f[] primvars:displayColor = [(0.5, 0.5, 0.5)] (
+                                interpolation = "constant"
+                            )
+                            int[] primvars:displayColor:indices = None
+                            float[] primvars:displayOpacity = [1] (
+                                interpolation = "constant"
+                            )
+                            int[] primvars:displayOpacity:indices = None
+                            double radius = 0.06
+                            quatf xformOp:orient = (0.014701115, 0.99989194, 0, 0)
+                            float3 xformOp:scale = (1, 1, 1)
+                            double3 xformOp:translate = (0, -0.005, -0.17)
+                            uniform token[] xformOpOrder = ["xformOp:translate", "xformOp:orient", "xformOp:scale"]
+                        }
+
+                        def Cube "left_hip" (
+                            apiSchemas = ["MjcSiteAPI"]
+                        )
+                        {
+                            float3[] extent = [(-1, -1, -1), (1, 1, 1)]
+                            uniform int mjc:group = 3
+                            color3f[] primvars:displayColor = [(1, 0, 0)] (
+                                interpolation = "constant"
+                            )
+                            int[] primvars:displayColor:indices = None
+                            float[] primvars:displayOpacity = [1] (
+                                interpolation = "constant"
+                            )
+                            int[] primvars:displayOpacity:indices = None
+                            uniform token purpose = "guide"
+                            double size = 2
+                            quatf xformOp:orient = (1, 0, 0, 0)
+                            float3 xformOp:scale = (0.01, 0.01, 0.02)
+                            double3 xformOp:translate = (0, 0, 0)
+                            uniform token[] xformOpOrder = ["xformOp:translate", "xformOp:orient", "xformOp:scale"]
+                        }
+
+                        def Capsule "left_thigh_1" (
+                            apiSchemas = ["MjcSiteAPI"]
+                            displayName = "left_thigh"
+                        )
+                        {
+                            uniform token axis = "Z"
+                            float3[] extent = [(-0.061, -0.061, -0.231), (0.061, 0.061, 0.231)]
+                            double height = 0.34
+                            uniform int mjc:group = 3
+                            color3f[] primvars:displayColor = [(0, 0, 1)] (
+                                interpolation = "constant"
+                            )
+                            int[] primvars:displayColor:indices = None
+                            float[] primvars:displayOpacity = [0.3] (
+                                interpolation = "constant"
+                            )
+                            int[] primvars:displayOpacity:indices = None
+                            uniform token purpose = "guide"
+                            double radius = 0.061
+                            quatf xformOp:orient = (0.99989194, -0.014700842, 0, 0)
+                            float3 xformOp:scale = (1, 1, 1)
+                            double3 xformOp:translate = (0, -0.005, -0.17)
+                            uniform token[] xformOpOrder = ["xformOp:translate", "xformOp:orient", "xformOp:scale"]
+                        }
+
+                        def Xform "left_shin" (
+                            apiSchemas = ["PhysicsRigidBodyAPI"]
+                        )
+                        {
+                            quatf xformOp:orient = (1, 0, 0, 0)
+                            float3 xformOp:scale = (1, 1, 1)
+                            double3 xformOp:translate = (0, -0.01, -0.403)
+                            uniform token[] xformOpOrder = ["xformOp:translate", "xformOp:orient", "xformOp:scale"]
+
+                            def Capsule "left_shin" (
+                                apiSchemas = ["PhysicsCollisionAPI", "MjcCollisionAPI", "MaterialBindingAPI"]
+                            )
+                            {
+                                uniform token axis = "Z"
+                                float3[] extent = [(-0.049, -0.049, -0.199), (0.049, 0.049, 0.199)]
+                                double height = 0.3
+                                rel material:binding:physics = </humanoid/Physics/PhysicsMaterial_1>
+                                uniform int mjc:condim = 1
+                                uniform double[] mjc:solimp = [0.9, 0.99, 0.003, 0.5, 2]
+                                uniform double[] mjc:solref = [0.015, 1]
+                                color3f[] primvars:displayColor = [(0.5, 0.5, 0.5)] (
+                                    interpolation = "constant"
+                                )
+                                int[] primvars:displayColor:indices = None
+                                float[] primvars:displayOpacity = [1] (
+                                    interpolation = "constant"
+                                )
+                                int[] primvars:displayOpacity:indices = None
+                                double radius = 0.049
+                                quatf xformOp:orient = (6.123234e-17, 1, 0, 0)
+                                float3 xformOp:scale = (1, 1, 1)
+                                double3 xformOp:translate = (0, 0, -0.15)
+                                uniform token[] xformOpOrder = ["xformOp:translate", "xformOp:orient", "xformOp:scale"]
+                            }
+
+                            def Cube "left_knee" (
+                                apiSchemas = ["MjcSiteAPI"]
+                            )
+                            {
+                                float3[] extent = [(-1, -1, -1), (1, 1, 1)]
+                                uniform int mjc:group = 3
+                                color3f[] primvars:displayColor = [(1, 0, 0)] (
+                                    interpolation = "constant"
+                                )
+                                int[] primvars:displayColor:indices = None
+                                float[] primvars:displayOpacity = [1] (
+                                    interpolation = "constant"
+                                )
+                                int[] primvars:displayOpacity:indices = None
+                                uniform token purpose = "guide"
+                                double size = 2
+                                quatf xformOp:orient = (1, 0, 0, 0)
+                                float3 xformOp:scale = (0.01, 0.01, 0.02)
+                                double3 xformOp:translate = (0, 0, 0.02)
+                                uniform token[] xformOpOrder = ["xformOp:translate", "xformOp:orient", "xformOp:scale"]
+                            }
+
+                            def Capsule "left_shin_1" (
+                                apiSchemas = ["MjcSiteAPI"]
+                                displayName = "left_shin"
+                            )
+                            {
+                                uniform token axis = "Z"
+                                float3[] extent = [(-0.05, -0.05, -0.2), (0.05, 0.05, 0.2)]
+                                double height = 0.3
+                                uniform int mjc:group = 3
+                                color3f[] primvars:displayColor = [(0, 0, 1)] (
+                                    interpolation = "constant"
+                                )
+                                int[] primvars:displayColor:indices = None
+                                float[] primvars:displayOpacity = [0.3] (
+                                    interpolation = "constant"
+                                )
+                                int[] primvars:displayOpacity:indices = None
+                                uniform token purpose = "guide"
+                                double radius = 0.05
+                                quatf xformOp:orient = (1, 0, 0, 0)
+                                float3 xformOp:scale = (1, 1, 1)
+                                double3 xformOp:translate = (0, 0, -0.15)
+                                uniform token[] xformOpOrder = ["xformOp:translate", "xformOp:orient", "xformOp:scale"]
+                            }
+
+                            def Xform "left_foot" (
+                                apiSchemas = ["PhysicsRigidBodyAPI"]
+                            )
+                            {
+                                quatf xformOp:orient = (1, 0, 0, 0)
+                                float3 xformOp:scale = (1, 1, 1)
+                                double3 xformOp:translate = (0, 0, -0.39)
+                                uniform token[] xformOpOrder = ["xformOp:translate", "xformOp:orient", "xformOp:scale"]
+
+                                def Capsule "left_left_foot" (
+                                    apiSchemas = ["PhysicsCollisionAPI", "MjcCollisionAPI", "MaterialBindingAPI"]
+                                )
+                                {
+                                    uniform token axis = "Z"
+                                    float3[] extent = [(-0.027, -0.027, -0.13247512), (0.027, 0.027, 0.13247512)]
+                                    double height = 0.2109502310972899
+                                    rel material:binding:physics = </humanoid/Physics/PhysicsMaterial_1>
+                                    uniform int mjc:condim = 1
+                                    uniform double[] mjc:solimp = [0.9, 0.99, 0.003, 0.5, 2]
+                                    uniform double[] mjc:solref = [0.015, 1]
+                                    color3f[] primvars:displayColor = [(0.5, 0.5, 0.5)] (
+                                        interpolation = "constant"
+                                    )
+                                    int[] primvars:displayColor:indices = None
+                                    float[] primvars:displayOpacity = [1] (
+                                        interpolation = "constant"
+                                    )
+                                    int[] primvars:displayOpacity:indices = None
+                                    double radius = 0.027
+                                    quatf xformOp:orient = (0.70710677, -0.06704015, 0.7039216, 0)
+                                    float3 xformOp:scale = (1, 1, 1)
+                                    double3 xformOp:translate = (0.035, 0.03, 0)
+                                    uniform token[] xformOpOrder = ["xformOp:translate", "xformOp:orient", "xformOp:scale"]
+                                }
+
+                                def Capsule "right_left_foot" (
+                                    apiSchemas = ["PhysicsCollisionAPI", "MjcCollisionAPI", "MaterialBindingAPI"]
+                                )
+                                {
+                                    uniform token axis = "Z"
+                                    float3[] extent = [(-0.027, -0.027, -0.13247512), (0.027, 0.027, 0.13247512)]
+                                    double height = 0.2109502310972899
+                                    rel material:binding:physics = </humanoid/Physics/PhysicsMaterial_1>
+                                    uniform int mjc:condim = 1
+                                    uniform double[] mjc:solimp = [0.9, 0.99, 0.003, 0.5, 2]
+                                    uniform double[] mjc:solref = [0.015, 1]
+                                    color3f[] primvars:displayColor = [(0.5, 0.5, 0.5)] (
+                                        interpolation = "constant"
+                                    )
+                                    int[] primvars:displayColor:indices = None
+                                    float[] primvars:displayOpacity = [1] (
+                                        interpolation = "constant"
+                                    )
+                                    int[] primvars:displayOpacity:indices = None
+                                    double radius = 0.027
+                                    quatf xformOp:orient = (0.70710677, 0.06704015, 0.7039216, 0)
+                                    float3 xformOp:scale = (1, 1, 1)
+                                    double3 xformOp:translate = (0.035, -0.01, 0)
+                                    uniform token[] xformOpOrder = ["xformOp:translate", "xformOp:orient", "xformOp:scale"]
+                                }
+
+                                def Cube "left_ankle" (
+                                    apiSchemas = ["MjcSiteAPI"]
+                                )
+                                {
+                                    float3[] extent = [(-1, -1, -1), (1, 1, 1)]
+                                    uniform int mjc:group = 3
+                                    color3f[] primvars:displayColor = [(1, 0, 0)] (
+                                        interpolation = "constant"
+                                    )
+                                    int[] primvars:displayColor:indices = None
+                                    float[] primvars:displayOpacity = [1] (
+                                        interpolation = "constant"
+                                    )
+                                    int[] primvars:displayOpacity:indices = None
+                                    uniform token purpose = "guide"
+                                    double size = 2
+                                    quatf xformOp:orient = (1, 0, 0, 0)
+                                    float3 xformOp:scale = (0.01, 0.01, 0.02)
+                                    double3 xformOp:translate = (0, 0, 0)
+                                    uniform token[] xformOpOrder = ["xformOp:translate", "xformOp:orient", "xformOp:scale"]
+                                }
+
+                                def Capsule "right_left_foot_1" (
+                                    apiSchemas = ["MjcSiteAPI"]
+                                    displayName = "right_left_foot"
+                                )
+                                {
+                                    uniform token axis = "Z"
+                                    float3[] extent = [(-0.03, -0.03, -0.14), (0.03, 0.03, 0.14)]
+                                    double height = 0.22
+                                    uniform int mjc:group = 3
+                                    color3f[] primvars:displayColor = [(0, 0, 1)] (
+                                        interpolation = "constant"
+                                    )
+                                    int[] primvars:displayColor:indices = None
+                                    float[] primvars:displayOpacity = [0.3] (
+                                        interpolation = "constant"
+                                    )
+                                    int[] primvars:displayOpacity:indices = None
+                                    uniform token purpose = "guide"
+                                    double radius = 0.03
+                                    quatf xformOp:orient = (0.70710677, 0.06704015, 0.7039216, 0)
+                                    float3 xformOp:scale = (1, 1, 1)
+                                    double3 xformOp:translate = (0.035, -0.01, 0)
+                                    uniform token[] xformOpOrder = ["xformOp:translate", "xformOp:orient", "xformOp:scale"]
+                                }
+
+                                def Capsule "left_left_foot_1" (
+                                    apiSchemas = ["MjcSiteAPI"]
+                                    displayName = "left_left_foot"
+                                )
+                                {
+                                    uniform token axis = "Z"
+                                    float3[] extent = [(-0.03, -0.03, -0.14), (0.03, 0.03, 0.14)]
+                                    double height = 0.22
+                                    uniform int mjc:group = 3
+                                    color3f[] primvars:displayColor = [(0, 0, 1)] (
+                                        interpolation = "constant"
+                                    )
+                                    int[] primvars:displayColor:indices = None
+                                    float[] primvars:displayOpacity = [0.3] (
+                                        interpolation = "constant"
+                                    )
+                                    int[] primvars:displayOpacity:indices = None
+                                    uniform token purpose = "guide"
+                                    double radius = 0.03
+                                    quatf xformOp:orient = (0.70710677, -0.06704015, 0.7039216, 0)
+                                    float3 xformOp:scale = (1, 1, 1)
+                                    double3 xformOp:translate = (0.035, 0.03, 0)
+                                    uniform token[] xformOpOrder = ["xformOp:translate", "xformOp:orient", "xformOp:scale"]
+                                }
+
+                                def PhysicsRevoluteJoint "left_ankle_y" (
+                                    apiSchemas = ["MjcJointAPI"]
+                                )
+                                {
+                                    uniform double mjc:armature = 0.006
+                                    uniform double mjc:damping = 1
+                                    uniform double[] mjc:solimplimit = [0, 0.99, 0.01, 0.5, 2]
+                                    uniform double mjc:stiffness = 2
+                                    uniform token physics:axis = "Y"
+                                    rel physics:body0 = </humanoid/Geometry/torso/lower_waist/pelvis/left_thigh/left_shin>
+                                    rel physics:body1 = </humanoid/Geometry/torso/lower_waist/pelvis/left_thigh/left_shin/left_foot>
+                                    point3f physics:localPos0 = (0, 0, -0.31)
+                                    point3f physics:localPos1 = (0, 0, 0.08)
+                                    quatf physics:localRot0 = (1, 0, 0, 0)
+                                    quatf physics:localRot1 = (1, 0, 0, 0)
+                                    float physics:lowerLimit = -50
+                                    float physics:upperLimit = 50
+                                }
+
+                                def PhysicsRevoluteJoint "left_ankle_x" (
+                                    apiSchemas = ["MjcJointAPI"]
+                                )
+                                {
+                                    uniform double mjc:armature = 0.006
+                                    uniform double mjc:damping = 1
+                                    uniform double[] mjc:solimplimit = [0, 0.99, 0.01, 0.5, 2]
+                                    uniform double mjc:stiffness = 2
+                                    uniform token physics:axis = "X"
+                                    rel physics:body0 = </humanoid/Geometry/torso/lower_waist/pelvis/left_thigh/left_shin>
+                                    rel physics:body1 = </humanoid/Geometry/torso/lower_waist/pelvis/left_thigh/left_shin/left_foot>
+                                    point3f physics:localPos0 = (0, 0, -0.31)
+                                    point3f physics:localPos1 = (0, 0, 0.08)
+                                    quatf physics:localRot0 = (0.97324896, 0, -0.22975293, 0)
+                                    quatf physics:localRot1 = (0.97324896, 0, -0.22975293, 0)
+                                    float physics:lowerLimit = -50
+                                    float physics:upperLimit = 50
+                                }
+                            }
+
+                            def PhysicsRevoluteJoint "left_knee_1" (
+                                apiSchemas = ["MjcJointAPI"]
+                                displayName = "left_knee"
+                            )
+                            {
+                                uniform double mjc:armature = 0.007
+                                uniform double mjc:damping = 0.1
+                                uniform double[] mjc:solimplimit = [0, 0.99, 0.01, 0.5, 2]
+                                uniform double mjc:stiffness = 5
+                                uniform token physics:axis = "Y"
+                                rel physics:body0 = </humanoid/Geometry/torso/lower_waist/pelvis/left_thigh>
+                                rel physics:body1 = </humanoid/Geometry/torso/lower_waist/pelvis/left_thigh/left_shin>
+                                point3f physics:localPos0 = (0, -0.01, -0.383)
+                                point3f physics:localPos1 = (0, 0, 0.02)
+                                quatf physics:localRot0 = (0, -1, 0, 0)
+                                quatf physics:localRot1 = (0, -1, 0, 0)
+                                float physics:lowerLimit = -160
+                                float physics:upperLimit = 2
+                            }
+                        }
+
+                        def PhysicsRevoluteJoint "left_hip_x" (
+                            apiSchemas = ["MjcJointAPI"]
+                        )
+                        {
+                            uniform double mjc:armature = 0.01
+                            uniform double mjc:damping = 5
+                            uniform double[] mjc:solimplimit = [0, 0.99, 0.01, 0.5, 2]
+                            uniform double mjc:stiffness = 10
+                            uniform token physics:axis = "X"
+                            rel physics:body0 = </humanoid/Geometry/torso/lower_waist/pelvis>
+                            rel physics:body1 = </humanoid/Geometry/torso/lower_waist/pelvis/left_thigh>
+                            point3f physics:localPos0 = (-1.7347235e-18, 0.1, -0.04)
+                            point3f physics:localPos1 = (0, 0, 0)
+                            quatf physics:localRot0 = (0, 0, -1, 0)
+                            quatf physics:localRot1 = (0, 0, -1, 0)
+                            float physics:lowerLimit = -25
+                            float physics:upperLimit = 5
+                        }
+
+                        def PhysicsRevoluteJoint "left_hip_z" (
+                            apiSchemas = ["MjcJointAPI"]
+                        )
+                        {
+                            uniform double mjc:armature = 0.01
+                            uniform double mjc:damping = 5
+                            uniform double[] mjc:solimplimit = [0, 0.99, 0.01, 0.5, 2]
+                            uniform double mjc:stiffness = 10
+                            uniform token physics:axis = "Z"
+                            rel physics:body0 = </humanoid/Geometry/torso/lower_waist/pelvis>
+                            rel physics:body1 = </humanoid/Geometry/torso/lower_waist/pelvis/left_thigh>
+                            point3f physics:localPos0 = (-1.7347235e-18, 0.1, -0.04)
+                            point3f physics:localPos1 = (0, 0, 0)
+                            quatf physics:localRot0 = (0, -1, 0, 0)
+                            quatf physics:localRot1 = (0, -1, 0, 0)
+                            float physics:lowerLimit = -60
+                            float physics:upperLimit = 35
+                        }
+
+                        def PhysicsRevoluteJoint "left_hip_y" (
+                            apiSchemas = ["MjcJointAPI"]
+                        )
+                        {
+                            uniform double mjc:armature = 0.01
+                            uniform double mjc:damping = 5
+                            uniform double[] mjc:solimplimit = [0, 0.99, 0.01, 0.5, 2]
+                            uniform double mjc:stiffness = 20
+                            uniform token physics:axis = "Y"
+                            rel physics:body0 = </humanoid/Geometry/torso/lower_waist/pelvis>
+                            rel physics:body1 = </humanoid/Geometry/torso/lower_waist/pelvis/left_thigh>
+                            point3f physics:localPos0 = (-1.7347235e-18, 0.1, -0.04)
+                            point3f physics:localPos1 = (0, 0, 0)
+                            quatf physics:localRot0 = (1, 0, 0, 0)
+                            quatf physics:localRot1 = (1, 0, 0, 0)
+                            float physics:lowerLimit = -80
+                            float physics:upperLimit = 20
+                        }
+                    }
+
+                    def PhysicsRevoluteJoint "abdomen_x" (
+                        apiSchemas = ["MjcJointAPI"]
+                    )
+                    {
+                        uniform double mjc:armature = 0.01
+                        uniform double mjc:damping = 5
+                        uniform double[] mjc:solimplimit = [0, 0.99, 0.01, 0.5, 2]
+                        uniform double mjc:stiffness = 10
+                        uniform token physics:axis = "X"
+                        rel physics:body0 = </humanoid/Geometry/torso/lower_waist>
+                        rel physics:body1 = </humanoid/Geometry/torso/lower_waist/pelvis>
+                        point3f physics:localPos0 = (-0.00040264602, 0, -0.06500081)
+                        point3f physics:localPos1 = (0, 0, 0.1)
+                        quatf physics:localRot0 = (0.999998, 0, -0.0020132342, 0)
+                        quatf physics:localRot1 = (1, 0, 0, 0)
+                        float physics:lowerLimit = -35
+                        float physics:upperLimit = 35
+                    }
+                }
+
+                def PhysicsRevoluteJoint "abdomen_z" (
+                    apiSchemas = ["MjcJointAPI"]
+                )
+                {
+                    uniform double mjc:armature = 0.02
+                    uniform double mjc:damping = 5
+                    uniform double[] mjc:solimplimit = [0, 0.99, 0.01, 0.5, 2]
+                    uniform double mjc:stiffness = 20
+                    uniform token physics:axis = "Z"
+                    rel physics:body0 = </humanoid/Geometry/torso>
+                    rel physics:body1 = </humanoid/Geometry/torso/lower_waist>
+                    point3f physics:localPos0 = (-0.01026172, 0, -0.19500053)
+                    point3f physics:localPos1 = (0, 0, 0.065)
+                    quatf physics:localRot0 = (0.999998, 0, -0.0020132342, 0)
+                    quatf physics:localRot1 = (1, 0, 0, 0)
+                    float physics:lowerLimit = -45
+                    float physics:upperLimit = 45
+                }
+
+                def PhysicsRevoluteJoint "abdomen_y" (
+                    apiSchemas = ["MjcJointAPI"]
+                )
+                {
+                    uniform double mjc:armature = 0.01
+                    uniform double mjc:damping = 5
+                    uniform double[] mjc:solimplimit = [0, 0.99, 0.01, 0.5, 2]
+                    uniform double mjc:stiffness = 20
+                    uniform token physics:axis = "Y"
+                    rel physics:body0 = </humanoid/Geometry/torso>
+                    rel physics:body1 = </humanoid/Geometry/torso/lower_waist>
+                    point3f physics:localPos0 = (-0.01026172, 0, -0.19500053)
+                    point3f physics:localPos1 = (0, 0, 0.065)
+                    quatf physics:localRot0 = (0.999998, 0, -0.0020132342, 0)
+                    quatf physics:localRot1 = (1, 0, 0, 0)
+                    float physics:lowerLimit = -75
+                    float physics:upperLimit = 30
+                }
+            }
+
+            def Xform "right_upper_arm" (
+                apiSchemas = ["PhysicsRigidBodyAPI"]
+            )
+            {
+                quatf xformOp:orient = (1, 0, 0, 0)
+                float3 xformOp:scale = (1, 1, 1)
+                double3 xformOp:translate = (0, -0.17, 0.06)
+                uniform token[] xformOpOrder = ["xformOp:translate", "xformOp:orient", "xformOp:scale"]
+
+                def Capsule "right_upper_arm" (
+                    apiSchemas = ["PhysicsCollisionAPI", "MjcCollisionAPI", "MaterialBindingAPI"]
+                )
+                {
+                    uniform token axis = "Z"
+                    float3[] extent = [(-0.04, -0.04, -0.17856407), (0.04, 0.04, 0.17856407)]
+                    double height = 0.27712812921102037
+                    rel material:binding:physics = </humanoid/Physics/PhysicsMaterial_1>
+                    uniform int mjc:condim = 1
+                    uniform double[] mjc:solimp = [0.9, 0.99, 0.003, 0.5, 2]
+                    uniform double[] mjc:solref = [0.015, 1]
+                    color3f[] primvars:displayColor = [(0.5, 0.5, 0.5)] (
+                        interpolation = "constant"
+                    )
+                    int[] primvars:displayColor:indices = None
+                    float[] primvars:displayOpacity = [1] (
+                        interpolation = "constant"
+                    )
+                    int[] primvars:displayOpacity:indices = None
+                    double radius = 0.04
+                    quatf xformOp:orient = (0.45970088, 0.627963, 0.627963, -4.419938e-17)
+                    float3 xformOp:scale = (1, 1, 1)
+                    double3 xformOp:translate = (0.08, -0.08, -0.08)
+                    uniform token[] xformOpOrder = ["xformOp:translate", "xformOp:orient", "xformOp:scale"]
+                }
+
+                def Capsule "right_upper_arm_1" (
+                    apiSchemas = ["MjcSiteAPI"]
+                    displayName = "right_upper_arm"
+                )
+                {
+                    uniform token axis = "Z"
+                    float3[] extent = [(-0.041, -0.041, -0.181), (0.041, 0.041, 0.181)]
+                    double height = 0.28
+                    uniform int mjc:group = 3
+                    color3f[] primvars:displayColor = [(0, 0, 1)] (
+                        interpolation = "constant"
+                    )
+                    int[] primvars:displayColor:indices = None
+                    float[] primvars:displayOpacity = [0.3] (
+                        interpolation = "constant"
+                    )
+                    int[] primvars:displayOpacity:indices = None
+                    uniform token purpose = "guide"
+                    double radius = 0.041
+                    quatf xformOp:orient = (0.45970088, 0.627963, 0.627963, -4.419938e-17)
+                    float3 xformOp:scale = (1, 1, 1)
+                    double3 xformOp:translate = (0.08, -0.08, -0.08)
+                    uniform token[] xformOpOrder = ["xformOp:translate", "xformOp:orient", "xformOp:scale"]
+                }
+
+                def Xform "right_lower_arm" (
+                    apiSchemas = ["PhysicsRigidBodyAPI"]
+                )
+                {
+                    quatf xformOp:orient = (1, 0, 0, 0)
+                    float3 xformOp:scale = (1, 1, 1)
+                    double3 xformOp:translate = (0.18, -0.18, -0.18)
+                    uniform token[] xformOpOrder = ["xformOp:translate", "xformOp:orient", "xformOp:scale"]
+
+                    def Capsule "right_lower_arm" (
+                        apiSchemas = ["PhysicsCollisionAPI", "MjcCollisionAPI", "MaterialBindingAPI"]
+                    )
+                    {
+                        uniform token axis = "Z"
+                        float3[] extent = [(-0.031, -0.031, -0.16956407), (0.031, 0.031, 0.16956407)]
+                        double height = 0.27712812921102037
+                        rel material:binding:physics = </humanoid/Physics/PhysicsMaterial_1>
+                        uniform int mjc:condim = 1
+                        uniform double[] mjc:solimp = [0.9, 0.99, 0.003, 0.5, 2]
+                        uniform double[] mjc:solref = [0.015, 1]
+                        color3f[] primvars:displayColor = [(0.5, 0.5, 0.5)] (
+                            interpolation = "constant"
+                        )
+                        int[] primvars:displayColor:indices = None
+                        float[] primvars:displayOpacity = [1] (
+                            interpolation = "constant"
+                        )
+                        int[] primvars:displayOpacity:indices = None
+                        double radius = 0.031
+                        quatf xformOp:orient = (0.88807386, -0.32505754, 0.32505754, -3.125368e-17)
+                        float3 xformOp:scale = (1, 1, 1)
+                        double3 xformOp:translate = (0.09000000000000001, 0.09000000000000001, 0.09000000000000001)
+                        uniform token[] xformOpOrder = ["xformOp:translate", "xformOp:orient", "xformOp:scale"]
+                    }
+
+                    def Sphere "right_hand" (
+                        apiSchemas = ["PhysicsCollisionAPI", "MjcCollisionAPI", "MaterialBindingAPI"]
+                    )
+                    {
+                        float3[] extent = [(-0.04, -0.04, -0.04), (0.04, 0.04, 0.04)]
+                        rel material:binding:physics = </humanoid/Physics/PhysicsMaterial_1>
+                        uniform int mjc:condim = 1
+                        uniform double[] mjc:solimp = [0.9, 0.99, 0.003, 0.5, 2]
+                        uniform double[] mjc:solref = [0.015, 1]
+                        color3f[] primvars:displayColor = [(0.5, 0.5, 0.5)] (
+                            interpolation = "constant"
+                        )
+                        int[] primvars:displayColor:indices = None
+                        float[] primvars:displayOpacity = [1] (
+                            interpolation = "constant"
+                        )
+                        int[] primvars:displayOpacity:indices = None
+                        double radius = 0.04
+                        quatf xformOp:orient = (1, 0, 0, 0)
+                        float3 xformOp:scale = (1, 1, 1)
+                        double3 xformOp:translate = (0.18, 0.18, 0.18)
+                        uniform token[] xformOpOrder = ["xformOp:translate", "xformOp:orient", "xformOp:scale"]
+                    }
+
+                    def Capsule "right_lower_arm_1" (
+                        apiSchemas = ["MjcSiteAPI"]
+                        displayName = "right_lower_arm"
+                    )
+                    {
+                        uniform token axis = "Z"
+                        float3[] extent = [(-0.032, -0.032, -0.172), (0.032, 0.032, 0.172)]
+                        double height = 0.28
+                        uniform int mjc:group = 3
+                        color3f[] primvars:displayColor = [(0, 0, 1)] (
+                            interpolation = "constant"
+                        )
+                        int[] primvars:displayColor:indices = None
+                        float[] primvars:displayOpacity = [0.3] (
+                            interpolation = "constant"
+                        )
+                        int[] primvars:displayOpacity:indices = None
+                        uniform token purpose = "guide"
+                        double radius = 0.032
+                        quatf xformOp:orient = (0.88807386, -0.32505754, 0.32505754, -3.125368e-17)
+                        float3 xformOp:scale = (1, 1, 1)
+                        double3 xformOp:translate = (0.09, 0.09, 0.09)
+                        uniform token[] xformOpOrder = ["xformOp:translate", "xformOp:orient", "xformOp:scale"]
+                    }
+
+                    def PhysicsRevoluteJoint "right_elbow" (
+                        apiSchemas = ["MjcJointAPI"]
+                    )
+                    {
+                        uniform double mjc:armature = 0.006
+                        uniform double mjc:damping = 1
+                        uniform double[] mjc:solimplimit = [0, 0.99, 0.01, 0.5, 2]
+                        uniform double mjc:stiffness = 2
+                        uniform token physics:axis = "X"
+                        rel physics:body0 = </humanoid/Geometry/torso/right_upper_arm>
+                        rel physics:body1 = </humanoid/Geometry/torso/right_upper_arm/right_lower_arm>
+                        point3f physics:localPos0 = (0.18, -0.18, -0.18)
+                        point3f physics:localPos1 = (0, 0, 0)
+                        quatf physics:localRot0 = (0.70710677, 0, -0.50000006, -0.50000006)
+                        quatf physics:localRot1 = (0.70710677, 0, -0.50000006, -0.50000006)
+                        float physics:lowerLimit = -90
+                        float physics:upperLimit = 50
+                    }
+                }
+
+                def PhysicsRevoluteJoint "right_shoulder1" (
+                    apiSchemas = ["MjcJointAPI"]
+                )
+                {
+                    uniform double mjc:armature = 0.01
+                    uniform double mjc:damping = 5
+                    uniform double[] mjc:solimplimit = [0, 0.99, 0.01, 0.5, 2]
+                    uniform double mjc:stiffness = 10
+                    uniform token physics:axis = "X"
+                    rel physics:body0 = </humanoid/Geometry/torso>
+                    rel physics:body1 = </humanoid/Geometry/torso/right_upper_arm>
+                    point3f physics:localPos0 = (0, -0.17, 0.06)
+                    point3f physics:localPos1 = (0, 0, 0)
+                    quatf physics:localRot0 = (0.95302063, 0, -0.2141865, 0.2141865)
+                    quatf physics:localRot1 = (0.95302063, 0, -0.2141865, 0.2141865)
+                    float physics:lowerLimit = -60
+                    float physics:upperLimit = 60
+                }
+
+                def PhysicsRevoluteJoint "right_shoulder2" (
+                    apiSchemas = ["MjcJointAPI"]
+                )
+                {
+                    uniform double mjc:armature = 0.01
+                    uniform double mjc:damping = 5
+                    uniform double[] mjc:solimplimit = [0, 0.99, 0.01, 0.5, 2]
+                    uniform double mjc:stiffness = 10
+                    uniform token physics:axis = "X"
+                    rel physics:body0 = </humanoid/Geometry/torso>
+                    rel physics:body1 = </humanoid/Geometry/torso/right_upper_arm>
+                    point3f physics:localPos0 = (0, -0.17, 0.06)
+                    point3f physics:localPos1 = (0, 0, 0)
+                    quatf physics:localRot0 = (0.70710677, 0, -0.50000006, -0.50000006)
+                    quatf physics:localRot1 = (0.70710677, 0, -0.50000006, -0.50000006)
+                    float physics:lowerLimit = -60
+                    float physics:upperLimit = 60
+                }
+            }
+
+            def Xform "left_upper_arm" (
+                apiSchemas = ["PhysicsRigidBodyAPI"]
+            )
+            {
+                quatf xformOp:orient = (1, 0, 0, 0)
+                float3 xformOp:scale = (1, 1, 1)
+                double3 xformOp:translate = (0, 0.17, 0.06)
+                uniform token[] xformOpOrder = ["xformOp:translate", "xformOp:orient", "xformOp:scale"]
+
+                def Capsule "left_upper_arm" (
+                    apiSchemas = ["PhysicsCollisionAPI", "MjcCollisionAPI", "MaterialBindingAPI"]
+                )
+                {
+                    uniform token axis = "Z"
+                    float3[] extent = [(-0.04, -0.04, -0.17856407), (0.04, 0.04, 0.17856407)]
+                    double height = 0.27712812921102037
+                    rel material:binding:physics = </humanoid/Physics/PhysicsMaterial_1>
+                    uniform int mjc:condim = 1
+                    uniform double[] mjc:solimp = [0.9, 0.99, 0.003, 0.5, 2]
+                    uniform double[] mjc:solref = [0.015, 1]
+                    color3f[] primvars:displayColor = [(0.5, 0.5, 0.5)] (
+                        interpolation = "constant"
+                    )
+                    int[] primvars:displayColor:indices = None
+                    float[] primvars:displayOpacity = [1] (
+                        interpolation = "constant"
+                    )
+                    int[] primvars:displayOpacity:indices = None
+                    double radius = 0.04
+                    quatf xformOp:orient = (0.45970088, -0.627963, 0.627963, 4.419938e-17)
+                    float3 xformOp:scale = (1, 1, 1)
+                    double3 xformOp:translate = (0.08, 0.08, -0.08)
+                    uniform token[] xformOpOrder = ["xformOp:translate", "xformOp:orient", "xformOp:scale"]
+                }
+
+                def Capsule "left_upper_arm_1" (
+                    apiSchemas = ["MjcSiteAPI"]
+                    displayName = "left_upper_arm"
+                )
+                {
+                    uniform token axis = "Z"
+                    float3[] extent = [(-0.041, -0.041, -0.181), (0.041, 0.041, 0.181)]
+                    double height = 0.28
+                    uniform int mjc:group = 3
+                    color3f[] primvars:displayColor = [(0, 0, 1)] (
+                        interpolation = "constant"
+                    )
+                    int[] primvars:displayColor:indices = None
+                    float[] primvars:displayOpacity = [0.3] (
+                        interpolation = "constant"
+                    )
+                    int[] primvars:displayOpacity:indices = None
+                    uniform token purpose = "guide"
+                    double radius = 0.041
+                    quatf xformOp:orient = (0.45970088, -0.627963, 0.627963, 4.419938e-17)
+                    float3 xformOp:scale = (1, 1, 1)
+                    double3 xformOp:translate = (0.08, 0.08, -0.08)
+                    uniform token[] xformOpOrder = ["xformOp:translate", "xformOp:orient", "xformOp:scale"]
+                }
+
+                def Xform "left_lower_arm" (
+                    apiSchemas = ["PhysicsRigidBodyAPI"]
+                )
+                {
+                    quatf xformOp:orient = (1, 0, 0, 0)
+                    float3 xformOp:scale = (1, 1, 1)
+                    double3 xformOp:translate = (0.18, 0.18, -0.18)
+                    uniform token[] xformOpOrder = ["xformOp:translate", "xformOp:orient", "xformOp:scale"]
+
+                    def Capsule "left_lower_arm" (
+                        apiSchemas = ["PhysicsCollisionAPI", "MjcCollisionAPI", "MaterialBindingAPI"]
+                    )
+                    {
+                        uniform token axis = "Z"
+                        float3[] extent = [(-0.031, -0.031, -0.16956407), (0.031, 0.031, 0.16956407)]
+                        double height = 0.27712812921102037
+                        rel material:binding:physics = </humanoid/Physics/PhysicsMaterial_1>
+                        uniform int mjc:condim = 1
+                        uniform double[] mjc:solimp = [0.9, 0.99, 0.003, 0.5, 2]
+                        uniform double[] mjc:solref = [0.015, 1]
+                        color3f[] primvars:displayColor = [(0.5, 0.5, 0.5)] (
+                            interpolation = "constant"
+                        )
+                        int[] primvars:displayColor:indices = None
+                        float[] primvars:displayOpacity = [1] (
+                            interpolation = "constant"
+                        )
+                        int[] primvars:displayOpacity:indices = None
+                        double radius = 0.031
+                        quatf xformOp:orient = (0.88807386, 0.32505754, 0.32505754, -1.562684e-17)
+                        float3 xformOp:scale = (1, 1, 1)
+                        double3 xformOp:translate = (0.09000000000000001, -0.09000000000000001, 0.09000000000000001)
+                        uniform token[] xformOpOrder = ["xformOp:translate", "xformOp:orient", "xformOp:scale"]
+                    }
+
+                    def Sphere "left_hand" (
+                        apiSchemas = ["PhysicsCollisionAPI", "MjcCollisionAPI", "MaterialBindingAPI"]
+                    )
+                    {
+                        float3[] extent = [(-0.04, -0.04, -0.04), (0.04, 0.04, 0.04)]
+                        rel material:binding:physics = </humanoid/Physics/PhysicsMaterial_1>
+                        uniform int mjc:condim = 1
+                        uniform double[] mjc:solimp = [0.9, 0.99, 0.003, 0.5, 2]
+                        uniform double[] mjc:solref = [0.015, 1]
+                        color3f[] primvars:displayColor = [(0.5, 0.5, 0.5)] (
+                            interpolation = "constant"
+                        )
+                        int[] primvars:displayColor:indices = None
+                        float[] primvars:displayOpacity = [1] (
+                            interpolation = "constant"
+                        )
+                        int[] primvars:displayOpacity:indices = None
+                        double radius = 0.04
+                        quatf xformOp:orient = (1, 0, 0, 0)
+                        float3 xformOp:scale = (1, 1, 1)
+                        double3 xformOp:translate = (0.18, -0.18, 0.18)
+                        uniform token[] xformOpOrder = ["xformOp:translate", "xformOp:orient", "xformOp:scale"]
+                    }
+
+                    def Capsule "left_lower_arm_1" (
+                        apiSchemas = ["MjcSiteAPI"]
+                        displayName = "left_lower_arm"
+                    )
+                    {
+                        uniform token axis = "Z"
+                        float3[] extent = [(-0.032, -0.032, -0.172), (0.032, 0.032, 0.172)]
+                        double height = 0.28
+                        uniform int mjc:group = 3
+                        color3f[] primvars:displayColor = [(0, 0, 1)] (
+                            interpolation = "constant"
+                        )
+                        int[] primvars:displayColor:indices = None
+                        float[] primvars:displayOpacity = [0.3] (
+                            interpolation = "constant"
+                        )
+                        int[] primvars:displayOpacity:indices = None
+                        uniform token purpose = "guide"
+                        double radius = 0.032
+                        quatf xformOp:orient = (0.88807386, 0.32505754, 0.32505754, -1.562684e-17)
+                        float3 xformOp:scale = (1, 1, 1)
+                        double3 xformOp:translate = (0.09, -0.09, 0.09)
+                        uniform token[] xformOpOrder = ["xformOp:translate", "xformOp:orient", "xformOp:scale"]
+                    }
+
+                    def PhysicsRevoluteJoint "left_elbow" (
+                        apiSchemas = ["MjcJointAPI"]
+                    )
+                    {
+                        uniform double mjc:armature = 0.006
+                        uniform double mjc:damping = 1
+                        uniform double[] mjc:solimplimit = [0, 0.99, 0.01, 0.5, 2]
+                        uniform double mjc:stiffness = 2
+                        uniform token physics:axis = "X"
+                        rel physics:body0 = </humanoid/Geometry/torso/left_upper_arm>
+                        rel physics:body1 = </humanoid/Geometry/torso/left_upper_arm/left_lower_arm>
+                        point3f physics:localPos0 = (0.18, 0.18, -0.18)
+                        point3f physics:localPos1 = (0, 0, 0)
+                        quatf physics:localRot0 = (0.70710677, 0, 0.50000006, -0.50000006)
+                        quatf physics:localRot1 = (0.70710677, 0, 0.50000006, -0.50000006)
+                        float physics:lowerLimit = -90
+                        float physics:upperLimit = 50
+                    }
+                }
+
+                def PhysicsRevoluteJoint "left_shoulder1" (
+                    apiSchemas = ["MjcJointAPI"]
+                )
+                {
+                    uniform double mjc:armature = 0.01
+                    uniform double mjc:damping = 5
+                    uniform double[] mjc:solimplimit = [0, 0.99, 0.01, 0.5, 2]
+                    uniform double mjc:stiffness = 10
+                    uniform token physics:axis = "X"
+                    rel physics:body0 = </humanoid/Geometry/torso>
+                    rel physics:body1 = </humanoid/Geometry/torso/left_upper_arm>
+                    point3f physics:localPos0 = (0, 0.17, 0.06)
+                    point3f physics:localPos1 = (0, 0, 0)
+                    quatf physics:localRot0 = (0.30290547, 0, 0.6738873, 0.6738873)
+                    quatf physics:localRot1 = (0.30290547, 0, 0.6738873, 0.6738873)
+                    float physics:lowerLimit = -60
+                    float physics:upperLimit = 60
+                }
+
+                def PhysicsRevoluteJoint "left_shoulder2" (
+                    apiSchemas = ["MjcJointAPI"]
+                )
+                {
+                    uniform double mjc:armature = 0.01
+                    uniform double mjc:damping = 5
+                    uniform double[] mjc:solimplimit = [0, 0.99, 0.01, 0.5, 2]
+                    uniform double mjc:stiffness = 10
+                    uniform token physics:axis = "X"
+                    rel physics:body0 = </humanoid/Geometry/torso>
+                    rel physics:body1 = </humanoid/Geometry/torso/left_upper_arm>
+                    point3f physics:localPos0 = (0, 0.17, 0.06)
+                    point3f physics:localPos1 = (0, 0, 0)
+                    quatf physics:localRot0 = (0.70710677, 0, 0.50000006, -0.50000006)
+                    quatf physics:localRot1 = (0.70710677, 0, 0.50000006, -0.50000006)
+                    float physics:lowerLimit = -60
+                    float physics:upperLimit = 60
+                }
+            }
+        }
+    }
+
+    def Scope "Physics"
+    {
+        def Material "PhysicsMaterial" (
+            apiSchemas = ["PhysicsMaterialAPI", "MjcMaterialAPI"]
+        )
+        {
+            float physics:dynamicFriction = 1
+        }
+
+        def Material "PhysicsMaterial_1" (
+            apiSchemas = ["PhysicsMaterialAPI", "MjcMaterialAPI"]
+        )
+        {
+            uniform double mjc:rollingfriction = 0.05
+            uniform double mjc:torsionalfriction = 0.05
+            float physics:dynamicFriction = 1
+        }
+
+        def MjcActuator "abdomen_y"
+        {
+            uniform token mjc:ctrlLimited = "true"
+            uniform double mjc:ctrlRange:max = 1
+            uniform double mjc:ctrlRange:min = -1
+            uniform double[] mjc:gear = [67.5, 0, 0, 0, 0, 0]
+            rel mjc:target = </humanoid/Geometry/torso/lower_waist/abdomen_y>
+        }
+
+        def MjcActuator "abdomen_z"
+        {
+            uniform token mjc:ctrlLimited = "true"
+            uniform double mjc:ctrlRange:max = 1
+            uniform double mjc:ctrlRange:min = -1
+            uniform double[] mjc:gear = [67.5, 0, 0, 0, 0, 0]
+            rel mjc:target = </humanoid/Geometry/torso/lower_waist/abdomen_z>
+        }
+
+        def MjcActuator "abdomen_x"
+        {
+            uniform token mjc:ctrlLimited = "true"
+            uniform double mjc:ctrlRange:max = 1
+            uniform double mjc:ctrlRange:min = -1
+            uniform double[] mjc:gear = [67.5, 0, 0, 0, 0, 0]
+            rel mjc:target = </humanoid/Geometry/torso/lower_waist/pelvis/abdomen_x>
+        }
+
+        def MjcActuator "right_hip_x"
+        {
+            uniform token mjc:ctrlLimited = "true"
+            uniform double mjc:ctrlRange:max = 1
+            uniform double mjc:ctrlRange:min = -1
+            uniform double[] mjc:gear = [45, 0, 0, 0, 0, 0]
+            rel mjc:target = </humanoid/Geometry/torso/lower_waist/pelvis/right_thigh/right_hip_x>
+        }
+
+        def MjcActuator "right_hip_z"
+        {
+            uniform token mjc:ctrlLimited = "true"
+            uniform double mjc:ctrlRange:max = 1
+            uniform double mjc:ctrlRange:min = -1
+            uniform double[] mjc:gear = [45, 0, 0, 0, 0, 0]
+            rel mjc:target = </humanoid/Geometry/torso/lower_waist/pelvis/right_thigh/right_hip_z>
+        }
+
+        def MjcActuator "right_hip_y"
+        {
+            uniform token mjc:ctrlLimited = "true"
+            uniform double mjc:ctrlRange:max = 1
+            uniform double mjc:ctrlRange:min = -1
+            uniform double[] mjc:gear = [135, 0, 0, 0, 0, 0]
+            rel mjc:target = </humanoid/Geometry/torso/lower_waist/pelvis/right_thigh/right_hip_y>
+        }
+
+        def MjcActuator "right_knee"
+        {
+            uniform token mjc:ctrlLimited = "true"
+            uniform double mjc:ctrlRange:max = 1
+            uniform double mjc:ctrlRange:min = -1
+            uniform double[] mjc:gear = [90, 0, 0, 0, 0, 0]
+            rel mjc:target = </humanoid/Geometry/torso/lower_waist/pelvis/right_thigh/right_shin/right_knee_1>
+        }
+
+        def MjcActuator "right_ankle_x"
+        {
+            uniform token mjc:ctrlLimited = "true"
+            uniform double mjc:ctrlRange:max = 1
+            uniform double mjc:ctrlRange:min = -1
+            uniform double[] mjc:gear = [22.5, 0, 0, 0, 0, 0]
+            rel mjc:target = </humanoid/Geometry/torso/lower_waist/pelvis/right_thigh/right_shin/right_foot/right_ankle_x>
+        }
+
+        def MjcActuator "right_ankle_y"
+        {
+            uniform token mjc:ctrlLimited = "true"
+            uniform double mjc:ctrlRange:max = 1
+            uniform double mjc:ctrlRange:min = -1
+            uniform double[] mjc:gear = [22.5, 0, 0, 0, 0, 0]
+            rel mjc:target = </humanoid/Geometry/torso/lower_waist/pelvis/right_thigh/right_shin/right_foot/right_ankle_y>
+        }
+
+        def MjcActuator "left_hip_x"
+        {
+            uniform token mjc:ctrlLimited = "true"
+            uniform double mjc:ctrlRange:max = 1
+            uniform double mjc:ctrlRange:min = -1
+            uniform double[] mjc:gear = [45, 0, 0, 0, 0, 0]
+            rel mjc:target = </humanoid/Geometry/torso/lower_waist/pelvis/left_thigh/left_hip_x>
+        }
+
+        def MjcActuator "left_hip_z"
+        {
+            uniform token mjc:ctrlLimited = "true"
+            uniform double mjc:ctrlRange:max = 1
+            uniform double mjc:ctrlRange:min = -1
+            uniform double[] mjc:gear = [45, 0, 0, 0, 0, 0]
+            rel mjc:target = </humanoid/Geometry/torso/lower_waist/pelvis/left_thigh/left_hip_z>
+        }
+
+        def MjcActuator "left_hip_y"
+        {
+            uniform token mjc:ctrlLimited = "true"
+            uniform double mjc:ctrlRange:max = 1
+            uniform double mjc:ctrlRange:min = -1
+            uniform double[] mjc:gear = [135, 0, 0, 0, 0, 0]
+            rel mjc:target = </humanoid/Geometry/torso/lower_waist/pelvis/left_thigh/left_hip_y>
+        }
+
+        def MjcActuator "left_knee"
+        {
+            uniform token mjc:ctrlLimited = "true"
+            uniform double mjc:ctrlRange:max = 1
+            uniform double mjc:ctrlRange:min = -1
+            uniform double[] mjc:gear = [90, 0, 0, 0, 0, 0]
+            rel mjc:target = </humanoid/Geometry/torso/lower_waist/pelvis/left_thigh/left_shin/left_knee_1>
+        }
+
+        def MjcActuator "left_ankle_x"
+        {
+            uniform token mjc:ctrlLimited = "true"
+            uniform double mjc:ctrlRange:max = 1
+            uniform double mjc:ctrlRange:min = -1
+            uniform double[] mjc:gear = [22.5, 0, 0, 0, 0, 0]
+            rel mjc:target = </humanoid/Geometry/torso/lower_waist/pelvis/left_thigh/left_shin/left_foot/left_ankle_x>
+        }
+
+        def MjcActuator "left_ankle_y"
+        {
+            uniform token mjc:ctrlLimited = "true"
+            uniform double mjc:ctrlRange:max = 1
+            uniform double mjc:ctrlRange:min = -1
+            uniform double[] mjc:gear = [22.5, 0, 0, 0, 0, 0]
+            rel mjc:target = </humanoid/Geometry/torso/lower_waist/pelvis/left_thigh/left_shin/left_foot/left_ankle_y>
+        }
+
+        def MjcActuator "right_shoulder1"
+        {
+            uniform token mjc:ctrlLimited = "true"
+            uniform double mjc:ctrlRange:max = 1
+            uniform double mjc:ctrlRange:min = -1
+            uniform double[] mjc:gear = [67.5, 0, 0, 0, 0, 0]
+            rel mjc:target = </humanoid/Geometry/torso/right_upper_arm/right_shoulder1>
+        }
+
+        def MjcActuator "right_shoulder2"
+        {
+            uniform token mjc:ctrlLimited = "true"
+            uniform double mjc:ctrlRange:max = 1
+            uniform double mjc:ctrlRange:min = -1
+            uniform double[] mjc:gear = [67.5, 0, 0, 0, 0, 0]
+            rel mjc:target = </humanoid/Geometry/torso/right_upper_arm/right_shoulder2>
+        }
+
+        def MjcActuator "right_elbow"
+        {
+            uniform token mjc:ctrlLimited = "true"
+            uniform double mjc:ctrlRange:max = 1
+            uniform double mjc:ctrlRange:min = -1
+            uniform double[] mjc:gear = [45, 0, 0, 0, 0, 0]
+            rel mjc:target = </humanoid/Geometry/torso/right_upper_arm/right_lower_arm/right_elbow>
+        }
+
+        def MjcActuator "left_shoulder1"
+        {
+            uniform token mjc:ctrlLimited = "true"
+            uniform double mjc:ctrlRange:max = 1
+            uniform double mjc:ctrlRange:min = -1
+            uniform double[] mjc:gear = [67.5, 0, 0, 0, 0, 0]
+            rel mjc:target = </humanoid/Geometry/torso/left_upper_arm/left_shoulder1>
+        }
+
+        def MjcActuator "left_shoulder2"
+        {
+            uniform token mjc:ctrlLimited = "true"
+            uniform double mjc:ctrlRange:max = 1
+            uniform double mjc:ctrlRange:min = -1
+            uniform double[] mjc:gear = [67.5, 0, 0, 0, 0, 0]
+            rel mjc:target = </humanoid/Geometry/torso/left_upper_arm/left_shoulder2>
+        }
+
+        def MjcActuator "left_elbow"
+        {
+            uniform token mjc:ctrlLimited = "true"
+            uniform double mjc:ctrlRange:max = 1
+            uniform double mjc:ctrlRange:min = -1
+            uniform double[] mjc:gear = [45, 0, 0, 0, 0, 0]
+            rel mjc:target = </humanoid/Geometry/torso/left_upper_arm/left_lower_arm/left_elbow>
+        }
+    }
+}
+
+def PhysicsScene "PhysicsScene" (
+    apiSchemas = ["MjcSceneAPI", "PhysxSceneAPI"]
+)
+{
+    uniform double mjc:option:timestep = 0.00555
+    vector3f physics:gravityDirection = (0, 0, -1)
+    float physics:gravityMagnitude = 9.81
+}
+
+def "Render" (
+    hide_in_stage_window = true
+    no_delete = true
+)
+{
+    def "OmniverseKit"
+    {
+        def "HydraTextures" (
+            hide_in_stage_window = true
+            no_delete = true
+        )
+        {
+            def RenderProduct "omni_kit_widget_viewport_ViewportTexture_0" (
+                apiSchemas = ["OmniRtxSettingsCommonAdvancedAPI_1", "OmniRtxSettingsRtAdvancedAPI_1", "OmniRtxSettingsPtAdvancedAPI_1", "OmniRtxPostColorGradingAPI_1", "OmniRtxPostChromaticAberrationAPI_1", "OmniRtxPostBloomPhysicalAPI_1", "OmniRtxPostMatteObjectAPI_1", "OmniRtxPostCompositingAPI_1", "OmniRtxPostDofAPI_1", "OmniRtxPostMotionBlurAPI_1", "OmniRtxPostTvNoiseAPI_1", "OmniRtxPostTonemapIrayReinhardAPI_1", "OmniRtxPostDebugSettingsAPI_1", "OmniRtxDebugSettingsAPI_1"]
+                hide_in_stage_window = true
+                no_delete = true
+            )
+            {
+                rel camera = </OmniverseKit_Persp>
+                token omni:rtx:background:source:texture:textureMode = "repeatMirrored"
+                token omni:rtx:background:source:type = "domeLight"
+                bool omni:rtx:dlss:frameGeneration = 0
+                string omni:rtx:material:db:rtSensorNameToIdMap = "DefaultMaterial:0;AsphaltStandardMaterial:1;AsphaltWeatheredMaterial:2;VegetationGrassMaterial:3;WaterStandardMaterial:4;GlassStandardMaterial:5;FiberGlassMaterial:6;MetalAlloyMaterial:7;MetalAluminumMaterial:8;MetalAluminumOxidizedMaterial:9;PlasticStandardMaterial:10;RetroMarkingsMaterial:11;RetroSignMaterial:12;RubberStandardMaterial:13;SoilClayMaterial:14;ConcreteRoughMaterial:15;ConcreteSmoothMaterial:16;OakTreeBarkMaterial:17;FabricStandardMaterial:18;PlexiGlassStandardMaterial:19;MetalSilverMaterial:20"
+                bool omni:rtx:material:db:syncLoads = 1
+                bool omni:rtx:post:registeredCompositing:invertColorCorrection = 1
+                bool omni:rtx:post:registeredCompositing:invertToneMap = 1
+                bool omni:rtx:pt:lightcache:cached:dontResolveConflicts = 1
+                int omni:rtx:pt:maxSamplesPerLaunch = 2073600
+                int omni:rtx:pt:mgpu:maxPixelsPerRegionExponent = 12
+                color3f omni:rtx:rt:ambientLight:color = (0.1, 0.1, 0.1)
+                bool omni:rtx:rt:demoire = 0
+                bool omni:rtx:rt:lightcache:spatialCache:dontResolveConflicts = 1
+                bool omni:rtx:scene:hydra:materialSyncLoads = 1
+                bool omni:rtx:scene:hydra:mdlMaterialWarmup = 1
+                uint omni:rtx:viewTile:limit = 4294967295
+                rel orderedVars = </Render/Vars/LdrColor>
+                custom bool overrideClipRange = 0
+                uniform int2 resolution = (1920, 1080)
+            }
+        }
+    }
+
+    def RenderSettings "OmniverseGlobalRenderSettings" (
+        apiSchemas = ["OmniRtxSettingsGlobalRtAdvancedAPI_1", "OmniRtxSettingsGlobalPtAdvancedAPI_1"]
+        no_delete = true
+    )
+    {
+        rel products = </Render/OmniverseKit/HydraTextures/omni_kit_widget_viewport_ViewportTexture_0>
+    }
+
+    def "Vars"
+    {
+        def RenderVar "LdrColor" (
+            hide_in_stage_window = true
+            no_delete = true
+        )
+        {
+            uniform string sourceName = "LdrColor"
+        }
+    }
+}
+
diff --git a/newton/tests/test_broad_phase.py b/newton/tests/test_broad_phase.py
index 89a4a1d264..a851191d62 100644
--- a/newton/tests/test_broad_phase.py
+++ b/newton/tests/test_broad_phase.py
@@ -371,8 +371,6 @@ def test_nxn_broadphase_multiple_worlds(self):
             candidate_pair_count,
         )
 
-        wp.synchronize()
-
         # Get results
         pairs_wp = candidate_pair.numpy()
         num_candidate_pair_result = candidate_pair_count.numpy()[0]
@@ -579,8 +577,6 @@ def test_nxn_broadphase_with_shape_flags(self):
             candidate_pair_count,
         )
 
-        wp.synchronize()
-
         # Get results
         pairs_wp = candidate_pair.numpy()
         num_candidate_pair_result = candidate_pair_count.numpy()[0]
@@ -1171,8 +1167,6 @@ def _test_sap_broadphase_with_shape_flags_impl(self, sort_type):
             candidate_pair_count,
         )
 
-        wp.synchronize()
-
         # Get results
         pairs_wp = candidate_pair.numpy()
         num_candidate_pair_result = candidate_pair_count.numpy()[0]
@@ -1555,8 +1549,6 @@ def test_nxn_edge_cases(self):
             candidate_pair_count,
         )
 
-        wp.synchronize()
-
         # Get results
         pairs_wp = candidate_pair.numpy()
         num_candidate_pair_result = candidate_pair_count.numpy()[0]
@@ -1964,8 +1956,6 @@ def _test_sap_edge_cases_impl(self, sort_type):
             candidate_pair_count,
         )
 
-        wp.synchronize()
-
         # Get results
         pairs_wp = candidate_pair.numpy()
         num_candidate_pair_result = candidate_pair_count.numpy()[0]
diff --git a/newton/tests/test_collision_pipeline.py b/newton/tests/test_collision_pipeline.py
index 9dc0b94e3f..d1bc1a6ba4 100644
--- a/newton/tests/test_collision_pipeline.py
+++ b/newton/tests/test_collision_pipeline.py
@@ -717,6 +717,71 @@ def test_rigid_contact_normal_sphere_sphere(test, device, broad_phase: str):
     )
 
 
+def test_box_box_quaternion_perturbation(test, device, broad_phase: str):
+    """Verify box-box contacts are correct under tiny quaternion perturbation.
+
+    Two identical cubes are placed face-to-face with a non-trivial base
+    rotation (30 deg around X) and a tiny quaternion perturbation (~1e-14)
+    in the second box only. Without the support-map deadband fix this
+    produces 1 invalid contact instead of 4 face-corner contacts, with an
+    out-of-bounds body-frame point and a wrong world-frame normal.
+
+    Regression test for issue #2024 / #2430.
+    """
+    with wp.ScopedDevice(device):
+        half = 0.495
+        q_clean = wp.quat(0.2588233343021173, 0.0, 0.0, 0.9659246769912934)
+        q_noisy = wp.quat(0.2588233343021173, -2.27e-14, 9.25e-15, 0.9659246769912934)
+
+        y, z = 6.680443286895752, 4.4285125732421875
+
+        builder = newton.ModelBuilder()
+        b0 = builder.add_body(xform=wp.transform(p=wp.vec3(half, y, z), q=q_clean))
+        builder.add_shape_box(body=b0, hx=half, hy=half, hz=half)
+
+        b1 = builder.add_body(xform=wp.transform(p=wp.vec3(-half, y, z), q=q_noisy))
+        builder.add_shape_box(body=b1, hx=half, hy=half, hz=half)
+
+        model = builder.finalize(device=device)
+        state = model.state()
+
+        pipeline = newton.CollisionPipeline(model, broad_phase=broad_phase)
+        contacts = pipeline.contacts()
+        pipeline.collide(state, contacts)
+
+        cc = int(contacts.rigid_contact_count.numpy()[0])
+        points0 = contacts.rigid_contact_point0.numpy()[:cc]
+        normals = contacts.rigid_contact_normal.numpy()[:cc]
+
+        test.assertEqual(cc, 4, f"Expected 4 face-corner contacts, got {cc}")
+
+        for i in range(cc):
+            pt = points0[i]
+            n = normals[i]
+            for j in range(3):
+                test.assertLessEqual(
+                    abs(pt[j]),
+                    half * 1.01,
+                    f"Contact {i} body-frame point[{j}] = {pt[j]:.4f} outside half-extent {half}",
+                )
+            test.assertAlmostEqual(
+                abs(n[0]),
+                1.0,
+                places=2,
+                msg=f"Contact {i} normal = [{n[0]:.4f}, {n[1]:.4f}, {n[2]:.4f}], expected [+-1, 0, 0]",
+            )
+
+
+for bp_name in ("explicit", "nxn", "sap"):
+    add_function_test(
+        TestRigidContactNormal,
+        f"test_box_box_quaternion_perturbation_{bp_name}",
+        test_box_box_quaternion_perturbation,
+        devices=devices,
+        broad_phase=bp_name,
+    )
+
+
 # ============================================================================
 # Particle-Shape (Soft) Contact Tests
 # ============================================================================
@@ -1031,5 +1096,259 @@ def test_particle_shape_contacts(test, device, shape_type: GeoType):
     )
 
 
+# ============================================================================
+# Full-scene deterministic contact pipeline test
+# ============================================================================
+
+
+class TestDeterministicPipeline(unittest.TestCase):
+    """Test that deterministic=True yields bit-identical contacts across collide calls."""
+
+    pass
+
+
+def _build_deterministic_scene(device):
+    """Build the mixed-shape scene from example_basic_shapes6_determinism."""
+    from newton._src.geometry import create_mesh_terrain  # noqa: PLC0415
+
+    builder = newton.ModelBuilder()
+
+    # Procedural mesh terrain ground
+    terrain_vertices, terrain_indices = create_mesh_terrain(
+        grid_size=(6, 6),
+        block_size=(5.0, 5.0),
+        terrain_types=["pyramid_stairs"],
+        terrain_params={
+            "pyramid_stairs": {"step_width": 0.4, "step_height": 0.05, "platform_width": 0.8},
+        },
+        seed=42,
+    )
+    terrain_mesh = newton.Mesh(terrain_vertices, terrain_indices)
+    terrain_mesh.build_sdf(max_resolution=512)
+    builder.add_shape_mesh(body=-1, mesh=terrain_mesh, xform=wp.transform(p=wp.vec3(-15.0, -15.0, -0.5)))
+
+    # Icosahedron mesh
+    phi = (1.0 + np.sqrt(5.0)) / 2.0
+    ico_radius = 0.35
+    ico_base_vertices = np.array(
+        [
+            [-1, phi, 0],
+            [1, phi, 0],
+            [-1, -phi, 0],
+            [1, -phi, 0],
+            [0, -1, phi],
+            [0, 1, phi],
+            [0, -1, -phi],
+            [0, 1, -phi],
+            [phi, 0, -1],
+            [phi, 0, 1],
+            [-phi, 0, -1],
+            [-phi, 0, 1],
+        ],
+        dtype=np.float32,
+    )
+    for i in range(len(ico_base_vertices)):
+        ico_base_vertices[i] = ico_base_vertices[i] / np.linalg.norm(ico_base_vertices[i]) * ico_radius
+    ico_face_indices = [
+        [0, 11, 5],
+        [0, 5, 1],
+        [0, 1, 7],
+        [0, 7, 10],
+        [0, 10, 11],
+        [1, 5, 9],
+        [5, 11, 4],
+        [11, 10, 2],
+        [10, 7, 6],
+        [7, 1, 8],
+        [3, 9, 4],
+        [3, 4, 2],
+        [3, 2, 6],
+        [3, 6, 8],
+        [3, 8, 9],
+        [4, 9, 5],
+        [2, 4, 11],
+        [6, 2, 10],
+        [8, 6, 7],
+        [9, 8, 1],
+    ]
+    ico_vertices, ico_normals, ico_indices = [], [], []
+    for face_idx, face in enumerate(ico_face_indices):
+        v0, v1, v2 = ico_base_vertices[face[0]], ico_base_vertices[face[1]], ico_base_vertices[face[2]]
+        normal = np.cross(v1 - v0, v2 - v0)
+        normal = normal / np.linalg.norm(normal)
+        ico_vertices.extend([v0, v1, v2])
+        ico_normals.extend([normal, normal, normal])
+        base = face_idx * 3
+        ico_indices.extend([base, base + 1, base + 2])
+    ico_mesh = newton.Mesh(
+        np.array(ico_vertices, dtype=np.float32),
+        np.array(ico_indices, dtype=np.int32),
+        normals=np.array(ico_normals, dtype=np.float32),
+    )
+
+    # Cube mesh with SDF
+    hs = 0.3
+    cube_verts = np.array(
+        [
+            [-hs, -hs, -hs],
+            [hs, -hs, -hs],
+            [hs, hs, -hs],
+            [-hs, hs, -hs],
+            [-hs, -hs, hs],
+            [hs, -hs, hs],
+            [hs, hs, hs],
+            [-hs, hs, hs],
+        ],
+        dtype=np.float32,
+    )
+    cube_tris = np.array(
+        [0, 3, 2, 0, 2, 1, 4, 5, 6, 4, 6, 7, 0, 1, 5, 0, 5, 4, 2, 3, 7, 2, 7, 6, 0, 4, 7, 0, 7, 3, 1, 2, 6, 1, 6, 5],
+        dtype=np.int32,
+    )
+    cube_mesh = newton.Mesh(cube_verts, cube_tris)
+    cube_mesh.build_sdf(max_resolution=64)
+
+    # 4x4x4 grid of mixed shapes
+    shape_types = ["sphere", "box", "capsule", "mesh_cube", "cylinder", "cone", "icosahedron"]
+    grid_offset = wp.vec3(-5.0, -5.0, 0.5)
+    rng = np.random.default_rng(42)
+    shape_index = 0
+    for ix in range(4):
+        for iy in range(4):
+            for iz in range(4):
+                pos = wp.vec3(
+                    float(grid_offset[0]) + ix * 1.5 + (rng.random() - 0.5) * 0.4,
+                    float(grid_offset[1]) + iy * 1.5 + (rng.random() - 0.5) * 0.4,
+                    float(grid_offset[2]) + iz * 1.5 + (rng.random() - 0.5) * 0.4,
+                )
+                shape_type = shape_types[shape_index % len(shape_types)]
+                shape_index += 1
+                body = builder.add_body(xform=wp.transform(p=pos, q=wp.quat_identity()))
+                if shape_type == "sphere":
+                    builder.add_shape_sphere(body, radius=0.3)
+                elif shape_type == "box":
+                    builder.add_shape_box(body, hx=0.3, hy=0.3, hz=0.3)
+                elif shape_type == "capsule":
+                    builder.add_shape_capsule(body, radius=0.2, half_height=0.4)
+                elif shape_type == "cylinder":
+                    builder.add_shape_cylinder(body, radius=0.25, half_height=0.35)
+                elif shape_type == "cone":
+                    builder.add_shape_cone(body, radius=0.3, half_height=0.4)
+                elif shape_type == "mesh_cube":
+                    builder.add_shape_mesh(body, mesh=cube_mesh)
+                elif shape_type == "icosahedron":
+                    builder.add_shape_convex_hull(body, mesh=ico_mesh)
+                joint = builder.add_joint_free(body)
+                builder.add_articulation([joint])
+
+    model = builder.finalize(device=device)
+    return model
+
+
+def test_deterministic_pipeline_500_steps(test, device):
+    """Run 500 steps of the mixed-shape scene and assert bit-identical contacts on every collide."""
+    with wp.ScopedDevice(device):
+        model = _build_deterministic_scene(device)
+
+        pipeline_a = newton.CollisionPipeline(
+            model,
+            broad_phase="nxn",
+            deterministic=True,
+            reduce_contacts=True,
+            rigid_contact_max=50000,
+        )
+        pipeline_b = newton.CollisionPipeline(
+            model,
+            broad_phase="nxn",
+            deterministic=True,
+            reduce_contacts=True,
+            rigid_contact_max=50000,
+        )
+        contacts_a = pipeline_a.contacts()
+        contacts_b = pipeline_b.contacts()
+
+        solver = newton.solvers.SolverXPBD(model, iterations=2, rigid_contact_relaxation=0.8)
+        state_0 = model.state()
+        state_1 = model.state()
+        control = model.control()
+        newton.eval_fk(model, model.joint_q, model.joint_qd, state_0)
+
+        fps = 100
+        sim_substeps = 10
+        sim_dt = 1.0 / fps / sim_substeps
+
+        checked_arrays = [
+            "rigid_contact_shape0",
+            "rigid_contact_shape1",
+            "rigid_contact_point0",
+            "rigid_contact_point1",
+            "rigid_contact_normal",
+            "rigid_contact_offset0",
+            "rigid_contact_offset1",
+            "rigid_contact_margin0",
+            "rigid_contact_margin1",
+        ]
+
+        total_checks = 0
+        for _frame in range(500):
+            for _sub in range(sim_substeps):
+                state_0.clear_forces()
+                pipeline_a.collide(state_0, contacts_a)
+                pipeline_b.collide(state_0, contacts_b)
+
+                count_a = int(contacts_a.rigid_contact_count.numpy()[0])
+                count_b = int(contacts_b.rigid_contact_count.numpy()[0])
+                test.assertEqual(
+                    count_a,
+                    count_b,
+                    f"Contact count mismatch at frame {_frame} substep {_sub}: {count_a} vs {count_b}",
+                )
+                if count_a > 0:
+                    # Also compare sort keys to distinguish ordering vs value issues
+                    keys_a = pipeline_a._sort_key_array.numpy()[:count_a]
+                    keys_b = pipeline_b._sort_key_array.numpy()[:count_a]
+                    keys_match = np.array_equal(keys_a, keys_b)
+
+                    for name in checked_arrays:
+                        a = getattr(contacts_a, name).numpy()[:count_a]
+                        b = getattr(contacts_b, name).numpy()[:count_a]
+                        if not np.array_equal(a, b):
+                            diff_mask = a != b
+                            diff_indices = np.argwhere(diff_mask)
+                            msg = (
+                                f"Determinism failure in {name} at frame {_frame} substep {_sub} "
+                                f"({int(np.count_nonzero(diff_mask))} elements differ, {count_a} contacts)\n"
+                                f"  sort_keys_match={keys_match}\n"
+                            )
+                            for raw_idx in diff_indices[:5]:
+                                tidx = tuple(raw_idx)
+                                msg += f"  [{tidx}]: a={a[tidx]!r}  b={b[tidx]!r}  diff={float(a[tidx]) - float(b[tidx]):.18e}\n"
+                            if not keys_match:
+                                key_diff = np.argwhere(keys_a != keys_b)
+                                msg += f"  sort_key diffs at indices: {key_diff[:10].flatten().tolist()}\n"
+                                for ki in key_diff[:5].flatten():
+                                    msg += f"    key[{ki}]: a=0x{keys_a[ki]:016x}  b=0x{keys_b[ki]:016x}\n"
+                            # Show shape pairs for differing contacts
+                            s0_a = contacts_a.rigid_contact_shape0.numpy()[:count_a]
+                            s1_a = contacts_a.rigid_contact_shape1.numpy()[:count_a]
+                            for idx in diff_indices[:5]:
+                                ci = idx[0] if len(idx) > 1 else int(idx)
+                                msg += f"  contact[{ci}]: shapes=({s0_a[ci]}, {s1_a[ci]}), key_a=0x{keys_a[ci]:016x}\n"
+                            test.assertTrue(False, msg)
+                total_checks += 1
+
+                solver.step(state_0, state_1, control, contacts_a, sim_dt)
+                state_0, state_1 = state_1, state_0
+
+
+add_function_test(
+    TestDeterministicPipeline,
+    "test_deterministic_pipeline_500_steps",
+    test_deterministic_pipeline_500_steps,
+    devices=get_cuda_test_devices(),
+    check_output=False,
+)
+
+
 if __name__ == "__main__":
     unittest.main(verbosity=2, failfast=False)
diff --git a/newton/tests/test_contact_reduction_global.py b/newton/tests/test_contact_reduction_global.py
index 63fbfd294d..068589d594 100644
--- a/newton/tests/test_contact_reduction_global.py
+++ b/newton/tests/test_contact_reduction_global.py
@@ -8,10 +8,15 @@
 import numpy as np
 import warp as wp
 
-from newton._src.geometry.contact_data import ContactData
+from newton._src.geometry.contact_data import ContactData, make_contact_sort_key
+from newton._src.geometry.contact_reduction import float_flip
 from newton._src.geometry.contact_reduction_global import (
+    SCORE_SHIFT,
     GlobalContactReducer,
     GlobalContactReducerData,
+    _make_contact_value_det,
+    _make_preprune_probe_det,
+    _unpack_contact_id_det,
     create_export_reduced_contacts_kernel,
     decode_oct,
     encode_oct,
@@ -108,6 +113,7 @@ def store_contact_kernel(
             position=wp.vec3(1.0, 2.0, 3.0),
             normal=wp.vec3(0.0, 1.0, 0.0),
             depth=-0.01,
+            fingerprint=0,
             reducer_data=reducer_data,
             beta=0.001,
             shape_transform=xform,
@@ -169,6 +175,7 @@ def store_multiple_contacts_kernel(
             position=wp.vec3(x, 0.0, 0.0),
             normal=wp.vec3(0.0, 1.0, 0.0),
             depth=-0.01,
+            fingerprint=0,
             reducer_data=reducer_data,
             beta=0.001,
             shape_transform=xform,
@@ -228,6 +235,7 @@ def store_different_pairs_kernel(
             position=wp.vec3(0.0, 0.0, 0.0),
             normal=wp.vec3(0.0, 1.0, 0.0),
             depth=-0.01,
+            fingerprint=0,
             reducer_data=reducer_data,
             beta=0.001,
             shape_transform=xform,
@@ -284,6 +292,7 @@ def store_one_contact_kernel(
             position=wp.vec3(0.0, 0.0, 0.0),
             normal=wp.vec3(0.0, 1.0, 0.0),
             depth=-0.01,
+            fingerprint=0,
             reducer_data=reducer_data,
             beta=0.001,
             shape_transform=xform,
@@ -358,6 +367,7 @@ def stress_kernel(
             position=wp.vec3(x, y, 0.0),
             normal=wp.vec3(nx / n_len, ny / n_len, nz / n_len),
             depth=-0.01,
+            fingerprint=0,
             reducer_data=reducer_data,
             beta=0.001,
             shape_transform=xform,
@@ -414,6 +424,7 @@ def store_contact_kernel(
             position=wp.vec3(1.0, 2.0, 3.0),
             normal=wp.vec3(0.0, 1.0, 0.0),
             depth=-0.01,
+            fingerprint=0,
             reducer_data=reducer_data,
             beta=0.001,
             shape_transform=xform,
@@ -503,6 +514,7 @@ def store_contacts_kernel(
             position=wp.vec3(float(tid), 0.0, 0.0),
             normal=wp.vec3(0.0, 1.0, 0.0),
             depth=-0.01,
+            fingerprint=0,
             reducer_data=reducer_data,
             beta=0.001,
             shape_transform=xform,
@@ -568,12 +580,14 @@ def store_contacts_kernel(
             reducer.position_depth,
             reducer.normal,
             reducer.shape_pairs,
+            reducer.contact_fingerprints,
             reducer.exported_flags,
             shape_types,
             shape_data,
             shape_gap,
             writer_data,
             total_threads,
+            0,  # deterministic=0 (fast packing)
         ],
         device=device,
     )
@@ -671,6 +685,7 @@ def store_centered_contacts_kernel(reducer_data: GlobalContactReducerData):
             position=position,
             normal=normal,
             depth=depth,
+            fingerprint=0,
             centered_position=centered_position,
             X_ws_voxel_shape=X_ws_shape,
             aabb_lower_voxel=aabb_lower,
@@ -708,6 +723,7 @@ def store_different_pairs_centered_kernel(reducer_data: GlobalContactReducerData
             position=wp.vec3(0.0, 0.0, 0.0),
             normal=wp.vec3(0.0, 1.0, 0.0),
             depth=-0.01,
+            fingerprint=0,
             centered_position=wp.vec3(0.0, 0.0, 0.0),
             X_ws_voxel_shape=X_ws_shape,
             aabb_lower_voxel=aabb_lower,
@@ -742,6 +758,7 @@ def store_varying_depth_kernel(reducer_data: GlobalContactReducerData):
             position=wp.vec3(0.0, 0.0, 0.0),
             normal=wp.vec3(0.0, 1.0, 0.0),
             depth=depth,
+            fingerprint=0,
             centered_position=wp.vec3(0.0, 0.0, 0.0),
             X_ws_voxel_shape=X_ws_shape,
             aabb_lower_voxel=aabb_lower,
@@ -796,6 +813,7 @@ def store_extreme_contacts_kernel(reducer_data: GlobalContactReducerData):
             position=positions,
             normal=wp.vec3(0.0, 1.0, 0.0),
             depth=-0.5,
+            fingerprint=0,
             centered_position=positions,
             X_ws_voxel_shape=X_ws,
             aabb_lower_voxel=wp.vec3(-15.0, -5.0, -15.0),
@@ -805,7 +823,6 @@ def store_extreme_contacts_kernel(reducer_data: GlobalContactReducerData):
         )
 
     wp.launch(store_extreme_contacts_kernel, dim=4, inputs=[reducer_data], device=device)
-    wp.synchronize()
     count_after_extremes = get_contact_count(reducer)
     test.assertEqual(count_after_extremes, 4)
 
@@ -821,6 +838,7 @@ def store_one_dominated_contact_kernel(
             position=wp.vec3(x_offset, 0.0, 0.0),
             normal=wp.vec3(0.0, 1.0, 0.0),
             depth=-0.001,
+            fingerprint=0,
             centered_position=wp.vec3(x_offset, 0.0, 0.0),
             X_ws_voxel_shape=X_ws,
             aabb_lower_voxel=wp.vec3(-15.0, -5.0, -15.0),
@@ -854,6 +872,439 @@ def store_one_dominated_contact_kernel(
     )
 
 
+# =============================================================================
+# Float-flip precision tests
+# =============================================================================
+
+
+@wp.func_native("""
+uint32_t mask = ((u >> 31) - 1) | 0x80000000;
+uint32_t i = u ^ mask;
+return reinterpret_cast<float&>(i);
+""")
+def ifloat_flip(u: wp.uint32) -> float: ...
+
+
+@wp.kernel(enable_backward=False)
+def float_flip_roundtrip_kernel(
+    values_in: wp.array[float],
+    values_out: wp.array[float],
+    truncated_out: wp.array[wp.uint32],
+    score_shift: int,
+):
+    """Apply float_flip, clear low bits, then ifloat_flip to measure precision loss."""
+    tid = wp.tid()
+    f = values_in[tid]
+    flipped = float_flip(f)
+    truncated = (flipped >> wp.uint32(score_shift)) << wp.uint32(score_shift)
+    reconstructed = ifloat_flip(truncated)
+    values_out[tid] = reconstructed
+    truncated_out[tid] = truncated
+
+
+class TestFloatFlipPrecision(unittest.TestCase):
+    """Test float_flip / ifloat_flip roundtrip precision with the SCORE_SHIFT used in contact reduction."""
+
+    pass
+
+
+def test_float_flip_roundtrip_precision(test, device):
+    """Validate that ifloat_flip((float_flip(f) >> SCORE_SHIFT) << SCORE_SHIFT) preserves
+    order and maintains relative precision ~2^-(23-SCORE_SHIFT)."""
+    score_shift = SCORE_SHIFT
+    mantissa_bits_kept = 23 - score_shift
+    max_relative_error = 2.0 ** (-mantissa_bits_kept)  # ~1.22e-4
+
+    # --- Build test values spanning actual score ranges ---
+    # Depth scores: -depth in [0.0001, 0.1]
+    depth_scores = np.linspace(0.0001, 0.1, 200, dtype=np.float32)
+    # Spatial scores: dot(pos_2d, dir_2d) in [-10, +10]
+    spatial_scores = np.linspace(-10.0, 10.0, 600, dtype=np.float32)
+    # Dense sweep around 1.0 to probe distinguishability
+    dense_sweep = np.linspace(0.999, 1.001, 100, dtype=np.float32)
+    # Edge cases
+    edge_cases = np.array(
+        [0.0, -0.0, 1e-6, -1e-6, 1e-4, -1e-4, 1.0, -1.0, 100.0, -100.0],
+        dtype=np.float32,
+    )
+
+    all_values = np.concatenate([depth_scores, spatial_scores, dense_sweep, edge_cases])
+    n = len(all_values)
+
+    values_in = wp.array(all_values, dtype=float, device=device)
+    values_out = wp.zeros(n, dtype=float, device=device)
+    truncated_out = wp.zeros(n, dtype=wp.uint32, device=device)
+
+    wp.launch(
+        float_flip_roundtrip_kernel,
+        dim=n,
+        inputs=[values_in, values_out, truncated_out, score_shift],
+        device=device,
+    )
+
+    orig = all_values
+    recon = values_out.numpy()
+    trunc = truncated_out.numpy()
+
+    # --- 1. Roundtrip for +0.0 (positive zero roundtrips exactly;
+    #     -0.0 maps to a tiny negative via float_flip, which is fine) ---
+    pos_zero_mask = (orig == 0.0) & ~np.signbit(orig)
+    if np.any(pos_zero_mask):
+        test.assertTrue(
+            np.all(recon[pos_zero_mask] == 0.0),
+            "Positive zero must roundtrip exactly",
+        )
+
+    # --- 2. Relative error bound ---
+    nonzero_mask = np.abs(orig) > 1e-30
+    rel_err = np.abs(recon[nonzero_mask] - orig[nonzero_mask]) / np.abs(orig[nonzero_mask])
+    worst_rel = float(np.max(rel_err))
+    test.assertLessEqual(
+        worst_rel,
+        max_relative_error,
+        f"Worst relative error {worst_rel:.6e} exceeds 2^-{mantissa_bits_kept} = {max_relative_error:.6e}",
+    )
+
+    # --- 3. Order preservation (monotonicity) ---
+    sorted_idx = np.argsort(orig)
+    sorted_orig = orig[sorted_idx]
+    sorted_trunc = trunc[sorted_idx]
+    violations = 0
+    for i in range(len(sorted_orig) - 1):
+        if sorted_orig[i] < sorted_orig[i + 1] and sorted_trunc[i] > sorted_trunc[i + 1]:
+            violations += 1
+    test.assertEqual(violations, 0, f"Order violations: {violations}")
+
+    # --- 4. Distinguishability at the precision floor ---
+    # Two values separated by more than 2^-(mantissa_bits_kept) relative
+    # to their magnitude must produce different truncated values.
+    base = np.float32(1.0)
+    eps_distinguishable = np.float32(2.0 ** (-mantissa_bits_kept + 1))  # 2x the LSB
+    pair = np.array([base, base + eps_distinguishable], dtype=np.float32)
+    pair_in = wp.array(pair, dtype=float, device=device)
+    pair_out = wp.zeros(2, dtype=float, device=device)
+    pair_trunc = wp.zeros(2, dtype=wp.uint32, device=device)
+    wp.launch(
+        float_flip_roundtrip_kernel,
+        dim=2,
+        inputs=[pair_in, pair_out, pair_trunc, score_shift],
+        device=device,
+    )
+    t = pair_trunc.numpy()
+    test.assertNotEqual(
+        int(t[0]),
+        int(t[1]),
+        f"Values {pair[0]} and {pair[1]} (eps={eps_distinguishable:.6e}) must produce different truncated values",
+    )
+
+    # --- 5. Sign correctness: all negatives map below all positives ---
+    neg_mask = orig < 0
+    pos_mask = orig > 0
+    if np.any(neg_mask) and np.any(pos_mask):
+        max_neg_trunc = int(np.max(trunc[neg_mask]))
+        min_pos_trunc = int(np.min(trunc[pos_mask]))
+        test.assertLess(
+            max_neg_trunc,
+            min_pos_trunc,
+            "All negative truncated values must be less than all positive truncated values",
+        )
+
+
+def test_float_flip_exact_inverse(test, device):
+    """Verify ifloat_flip(float_flip(f)) == f exactly (no truncation)."""
+    values = np.array(
+        [0.0, -0.0, 1.0, -1.0, 0.5, -0.5, 3.14159, -2.71828, 1e-6, -1e-6, 1e6, -1e6, 42.0],
+        dtype=np.float32,
+    )
+    n = len(values)
+    values_in = wp.array(values, dtype=float, device=device)
+    values_out = wp.zeros(n, dtype=float, device=device)
+    truncated_out = wp.zeros(n, dtype=wp.uint32, device=device)
+
+    # Use score_shift=0 for exact roundtrip (no bits cleared)
+    wp.launch(
+        float_flip_roundtrip_kernel,
+        dim=n,
+        inputs=[values_in, values_out, truncated_out, 0],
+        device=device,
+    )
+
+    orig = values
+    recon = values_out.numpy()
+    for i in range(n):
+        test.assertEqual(
+            orig[i],
+            recon[i],
+            f"Exact roundtrip failed for {orig[i]}: got {recon[i]}",
+        )
+
+
+# =============================================================================
+# make_contact_sort_key tests
+# =============================================================================
+
+
+class TestMakeContactSortKey(unittest.TestCase):
+    """Test make_contact_sort_key bit layout and ordering."""
+
+    pass
+
+
+@wp.kernel(enable_backward=False)
+def _sort_key_kernel(
+    shape_a: wp.array[int],
+    shape_b: wp.array[int],
+    sub_key: wp.array[int],
+    keys_out: wp.array[wp.int64],
+):
+    tid = wp.tid()
+    keys_out[tid] = make_contact_sort_key(shape_a[tid], shape_b[tid], sub_key[tid])
+
+
+def test_sort_key_bit_layout(test, device):
+    """Verify that make_contact_sort_key produces correct lexicographic ordering."""
+    # Pairs ordered lexicographically: (shape_a, shape_b, sub_key)
+    # Each successive entry should produce a strictly larger key.
+    sa = wp.array([0, 0, 0, 1, 1], dtype=int, device=device)
+    sb = wp.array([0, 0, 1, 0, 0], dtype=int, device=device)
+    sk = wp.array([0, 1, 0, 0, 1], dtype=int, device=device)
+    keys = wp.zeros(5, dtype=wp.int64, device=device)
+    wp.launch(_sort_key_kernel, dim=5, inputs=[sa, sb, sk, keys], device=device)
+
+    keys_np = keys.numpy()
+    for i in range(len(keys_np) - 1):
+        test.assertLess(
+            keys_np[i],
+            keys_np[i + 1],
+            f"Key[{i}]={keys_np[i]} should be < Key[{i + 1}]={keys_np[i + 1]}",
+        )
+
+
+def test_sort_key_overflow_masking(test, device):
+    """Verify that values exceeding bit widths are masked (not corrupting other fields)."""
+    # shape_a with 21 bits set (exceeds 20-bit field) — high bit should be masked
+    large_a = (1 << 21) | 5  # bit 20 set + low bits
+    sa = wp.array([large_a, 5], dtype=int, device=device)
+    sb = wp.array([0, 0], dtype=int, device=device)
+    sk = wp.array([0, 0], dtype=int, device=device)
+    keys = wp.zeros(2, dtype=wp.int64, device=device)
+    wp.launch(_sort_key_kernel, dim=2, inputs=[sa, sb, sk, keys], device=device)
+
+    keys_np = keys.numpy()
+    # After masking to 20 bits, large_a & 0xFFFFF == 5, so both keys should be equal
+    test.assertEqual(keys_np[0], keys_np[1], "Overflow bits should be masked away")
+
+
+# =============================================================================
+# Deterministic packing function tests
+# =============================================================================
+
+
+class TestDeterministicPacking(unittest.TestCase):
+    """Test deterministic contact value packing and unpacking."""
+
+    pass
+
+
+@wp.kernel(enable_backward=False)
+def _det_pack_unpack_kernel(
+    scores: wp.array[float],
+    fingerprints: wp.array[int],
+    contact_ids: wp.array[int],
+    packed_out: wp.array[wp.uint64],
+    unpacked_ids_out: wp.array[int],
+):
+    tid = wp.tid()
+    packed = _make_contact_value_det(scores[tid], fingerprints[tid], contact_ids[tid])
+    packed_out[tid] = packed
+    unpacked_ids_out[tid] = _unpack_contact_id_det(packed)
+
+
+def test_det_pack_unpack_roundtrip(test, device):
+    """Verify contact_id survives pack/unpack roundtrip in deterministic mode."""
+    n = 5
+    scores = wp.array([0.1, 0.5, -0.01, 1.0, 0.0], dtype=float, device=device)
+    fps = wp.array([0, 100, 999999, 42, 0], dtype=int, device=device)
+    ids = wp.array([0, 1, 1048575, 500, 12345], dtype=int, device=device)
+    packed = wp.zeros(n, dtype=wp.uint64, device=device)
+    unpacked = wp.zeros(n, dtype=int, device=device)
+
+    wp.launch(_det_pack_unpack_kernel, dim=n, inputs=[scores, fps, ids, packed, unpacked], device=device)
+
+    ids_np = ids.numpy()
+    unpacked_np = unpacked.numpy()
+    for i in range(n):
+        expected = ids_np[i] & ((1 << 20) - 1)
+        test.assertEqual(
+            unpacked_np[i],
+            expected,
+            f"Roundtrip failed for contact_id={ids_np[i]}: got {unpacked_np[i]}, expected {expected}",
+        )
+
+
+def test_det_packing_score_dominates(test, device):
+    """Verify that higher score always produces a larger packed value."""
+    n = 2
+    # Same fingerprint and contact_id, different scores
+    scores = wp.array([0.1, 0.5], dtype=float, device=device)
+    fps = wp.array([42, 42], dtype=int, device=device)
+    ids = wp.array([10, 10], dtype=int, device=device)
+    packed = wp.zeros(n, dtype=wp.uint64, device=device)
+    unpacked = wp.zeros(n, dtype=int, device=device)
+
+    wp.launch(_det_pack_unpack_kernel, dim=n, inputs=[scores, fps, ids, packed, unpacked], device=device)
+
+    packed_np = packed.numpy()
+    test.assertLess(packed_np[0], packed_np[1], "Higher score should produce larger packed value")
+
+
+def test_det_packing_fingerprint_breaks_tie(test, device):
+    """Verify that fingerprint breaks ties when scores are equal."""
+    n = 2
+    # Same score and contact_id, different fingerprints
+    scores = wp.array([0.5, 0.5], dtype=float, device=device)
+    fps = wp.array([10, 20], dtype=int, device=device)
+    ids = wp.array([5, 5], dtype=int, device=device)
+    packed = wp.zeros(n, dtype=wp.uint64, device=device)
+    unpacked = wp.zeros(n, dtype=int, device=device)
+
+    wp.launch(_det_pack_unpack_kernel, dim=n, inputs=[scores, fps, ids, packed, unpacked], device=device)
+
+    packed_np = packed.numpy()
+    test.assertNotEqual(packed_np[0], packed_np[1], "Different fingerprints should produce different packed values")
+    test.assertLess(packed_np[0], packed_np[1], "Higher fingerprint should produce larger packed value")
+
+
+@wp.kernel(enable_backward=False)
+def _det_preprune_probe_kernel(
+    scores: wp.array[float],
+    fingerprints: wp.array[int],
+    probes_out: wp.array[wp.uint64],
+):
+    tid = wp.tid()
+    probes_out[tid] = _make_preprune_probe_det(scores[tid], fingerprints[tid])
+
+
+def test_det_preprune_probe_is_ceiling(test, device):
+    """Verify that the preprune probe is >= any packed value with the same score and fingerprint."""
+    n = 1
+    score = wp.array([0.5], dtype=float, device=device)
+    fp = wp.array([42], dtype=int, device=device)
+    probe = wp.zeros(n, dtype=wp.uint64, device=device)
+    wp.launch(_det_preprune_probe_kernel, dim=n, inputs=[score, fp, probe], device=device)
+
+    # Pack with same score/fp but various contact_ids
+    ids_to_test = [0, 1, 100, 500000, (1 << 20) - 1]
+    for cid in ids_to_test:
+        ids_arr = wp.array([cid], dtype=int, device=device)
+        packed = wp.zeros(1, dtype=wp.uint64, device=device)
+        unpacked = wp.zeros(1, dtype=int, device=device)
+        wp.launch(_det_pack_unpack_kernel, dim=1, inputs=[score, fp, ids_arr, packed, unpacked], device=device)
+
+        probe_val = int(probe.numpy()[0])
+        packed_val = int(packed.numpy()[0])
+        test.assertGreaterEqual(
+            probe_val,
+            packed_val,
+            f"Preprune probe should be >= packed value for contact_id={cid}",
+        )
+
+
+# =============================================================================
+# End-to-end deterministic test
+# =============================================================================
+
+
+class TestDeterministicEndToEnd(unittest.TestCase):
+    """End-to-end test that deterministic mode produces identical contacts across runs."""
+
+    pass
+
+
+def test_deterministic_identical_across_runs(test, device):
+    """Create a deterministic reducer, collide the same scene N times, assert identical winners.
+
+    Compares winning contacts by their geometric content (position, depth,
+    fingerprint) rather than buffer contact IDs, since IDs are assigned by
+    atomic_add and vary between runs.
+    """
+    if str(device) == "cpu":
+        return  # Deterministic mode is primarily for GPU
+
+    num_runs = 5
+    all_contact_sets = []
+
+    for _ in range(num_runs):
+        reducer = GlobalContactReducer(capacity=500, device=device, deterministic=True)
+        reducer_data = reducer.get_data_struct()
+
+        @wp.kernel(enable_backward=False)
+        def store_contacts_det_kernel(reducer_data: GlobalContactReducerData):
+            tid = wp.tid()
+            x = float(tid % 10) - 5.0
+            z = float(tid // 10) - 5.0
+            depth = -0.001 * float((tid * 7 + 3) % 20 + 1)
+            fingerprint = tid * 3 + 1
+
+            X_ws = wp.transform(wp.vec3(0.0, 0.0, 0.0), wp.quat_identity())
+            export_and_reduce_contact_centered(
+                shape_a=0,
+                shape_b=1,
+                position=wp.vec3(x, 0.0, z),
+                normal=wp.vec3(0.0, 1.0, 0.0),
+                depth=depth,
+                fingerprint=fingerprint,
+                centered_position=wp.vec3(x, 0.0, z),
+                X_ws_voxel_shape=X_ws,
+                aabb_lower_voxel=wp.vec3(-10.0, -5.0, -10.0),
+                aabb_upper_voxel=wp.vec3(10.0, 5.0, 10.0),
+                voxel_res=wp.vec3i(4, 4, 4),
+                reducer_data=reducer_data,
+            )
+
+        wp.launch(store_contacts_det_kernel, dim=100, inputs=[reducer_data], device=device)
+
+        # Extract winning contacts by geometric content (not by contact ID)
+        values = reducer.ht_values.numpy()
+        capacity = reducer.hashtable.capacity
+        active_slots_np = reducer.hashtable.active_slots.numpy()
+        count = active_slots_np[capacity]
+        pd_np = reducer.position_depth.numpy()
+        fp_np = reducer.contact_fingerprints.numpy()
+
+        seen_ids = set()
+        contact_set = set()
+        for i in range(count):
+            entry_idx = active_slots_np[i]
+            for slot in range(reducer.values_per_key):
+                val = values[slot * capacity + entry_idx]
+                if val != 0:
+                    contact_id = int(val & ((1 << 20) - 1))
+                    if contact_id not in seen_ids:
+                        seen_ids.add(contact_id)
+                        pd = pd_np[contact_id]
+                        fp = int(fp_np[contact_id])
+                        # Round to avoid floating-point noise from storage
+                        key = (
+                            round(float(pd[0]), 5),
+                            round(float(pd[1]), 5),
+                            round(float(pd[2]), 5),
+                            round(float(pd[3]), 5),
+                            fp,
+                        )
+                        contact_set.add(key)
+
+        all_contact_sets.append(contact_set)
+
+    # All runs should produce identical geometric contact sets
+    for run_idx in range(1, num_runs):
+        test.assertEqual(
+            all_contact_sets[0],
+            all_contact_sets[run_idx],
+            f"Run 0 and run {run_idx} produced different winning contacts",
+        )
+
+
 # =============================================================================
 # Test registration
 # =============================================================================
@@ -906,6 +1357,52 @@ def store_one_dominated_contact_kernel(
     test_oct_encode_decode_roundtrip,
     devices=devices,
 )
+add_function_test(
+    TestFloatFlipPrecision,
+    "test_float_flip_roundtrip_precision",
+    test_float_flip_roundtrip_precision,
+    devices=devices,
+)
+add_function_test(
+    TestFloatFlipPrecision,
+    "test_float_flip_exact_inverse",
+    test_float_flip_exact_inverse,
+    devices=devices,
+)
+
+# make_contact_sort_key tests
+add_function_test(TestMakeContactSortKey, "test_sort_key_bit_layout", test_sort_key_bit_layout, devices=devices)
+add_function_test(
+    TestMakeContactSortKey, "test_sort_key_overflow_masking", test_sort_key_overflow_masking, devices=devices
+)
+
+# Deterministic packing tests
+add_function_test(
+    TestDeterministicPacking, "test_det_pack_unpack_roundtrip", test_det_pack_unpack_roundtrip, devices=devices
+)
+add_function_test(
+    TestDeterministicPacking, "test_det_packing_score_dominates", test_det_packing_score_dominates, devices=devices
+)
+add_function_test(
+    TestDeterministicPacking,
+    "test_det_packing_fingerprint_breaks_tie",
+    test_det_packing_fingerprint_breaks_tie,
+    devices=devices,
+)
+add_function_test(
+    TestDeterministicPacking,
+    "test_det_preprune_probe_is_ceiling",
+    test_det_preprune_probe_is_ceiling,
+    devices=devices,
+)
+
+# End-to-end deterministic test
+add_function_test(
+    TestDeterministicEndToEnd,
+    "test_deterministic_identical_across_runs",
+    test_deterministic_identical_across_runs,
+    devices=devices,
+)
 
 
 if __name__ == "__main__":
diff --git a/newton/tests/test_hashtable.py b/newton/tests/test_hashtable.py
index 86d0e4b149..cc815904c6 100644
--- a/newton/tests/test_hashtable.py
+++ b/newton/tests/test_hashtable.py
@@ -76,7 +76,6 @@ def insert_test_kernel(
         inputs=[ht.keys, values, ht.active_slots],
         device=device,
     )
-    wp.synchronize()
 
     # Find the entry
     keys_np = ht.keys.numpy()
@@ -116,7 +115,6 @@ def atomic_max_test_kernel(
         inputs=[ht.keys, values, ht.active_slots],
         device=device,
     )
-    wp.synchronize()
 
     # Find the entry
     keys_np = ht.keys.numpy()
@@ -154,7 +152,6 @@ def multi_key_kernel(
         inputs=[ht.keys, values, ht.active_slots],
         device=device,
     )
-    wp.synchronize()
 
     # Check that we have 100 entries
     keys_np = ht.keys.numpy()
@@ -189,7 +186,6 @@ def insert_kernel(
         inputs=[ht.keys, values, ht.active_slots],
         device=device,
     )
-    wp.synchronize()
 
     # Verify data exists
     keys_np = ht.keys.numpy()
@@ -230,7 +226,6 @@ def insert_kernel(
         inputs=[ht.keys, values, ht.active_slots],
         device=device,
     )
-    wp.synchronize()
 
     # Verify data exists
     active_count = ht.active_slots.numpy()[ht.capacity]
@@ -278,7 +273,6 @@ def collision_kernel(
         inputs=[ht.keys, values, ht.active_slots],
         device=device,
     )
-    wp.synchronize()
 
     # Should have exactly 10 unique keys
     keys_np = ht.keys.numpy()
@@ -318,7 +312,6 @@ def insert_descending_kernel(
         inputs=[ht.keys, values, ht.active_slots],
         device=device,
     )
-    wp.synchronize()
 
     # Find the entry
     keys_np = ht.keys.numpy()
diff --git a/newton/tests/test_hydroelastic.py b/newton/tests/test_hydroelastic.py
index ff28f3d57f..ae6a89898c 100644
--- a/newton/tests/test_hydroelastic.py
+++ b/newton/tests/test_hydroelastic.py
@@ -834,7 +834,6 @@ def test_entry_k_eff_matches_shape_harmonic_mean(test, device):
     newton.eval_fk(model, model.joint_q, model.joint_qd, state_0)
     contacts = pipeline.contacts()
     pipeline.collide(state_0, contacts)
-    wp.synchronize()
 
     hydro = pipeline.hydroelastic_sdf
     reducer = hydro.contact_reduction.reducer
diff --git a/newton/tests/test_import_usd.py b/newton/tests/test_import_usd.py
index 354b718100..3bb81176c1 100644
--- a/newton/tests/test_import_usd.py
+++ b/newton/tests/test_import_usd.py
@@ -7733,6 +7733,103 @@ def test_get_tetmesh_no_material(self):
         self.assertIsNone(tm.k_lambda)
         self.assertIsNone(tm.density)
 
+    @unittest.skipUnless(USD_AVAILABLE, "Requires usd-core")
+    def test_add_usd_imports_tetmesh(self):
+        """Test that add_usd imports TetMesh prims as soft meshes."""
+        asset_path = os.path.join(os.path.dirname(__file__), "assets", "tetmesh_with_material.usda")
+
+        builder = newton.ModelBuilder()
+        builder.add_usd(asset_path)
+
+        self.assertEqual(len(builder.particle_q), 4)
+        self.assertEqual(len(builder.tet_indices), 1)
+        self.assertEqual(len(builder.tri_indices), 4)
+        self.assertAlmostEqual(builder.tet_materials[0][0], 300000.0 / (2.0 * 1.3), places=0)
+        self.assertAlmostEqual(builder.tet_materials[0][1], 300000.0 * 0.3 / (1.3 * 0.4), places=0)
+        self.assertAlmostEqual(sum(builder.particle_mass), 40.0 / 6.0, places=5)
+
+    @unittest.skipUnless(USD_AVAILABLE, "Requires usd-core")
+    def test_add_usd_imports_instanced_tetmesh_once_per_instance(self):
+        """Test that instance proxies import one TetMesh per instance."""
+        from pxr import Sdf, Usd, UsdGeom
+
+        stage = Usd.Stage.CreateInMemory()
+        UsdGeom.SetStageUpAxis(stage, UsdGeom.Tokens.z)
+
+        world = UsdGeom.Xform.Define(stage, "/World")
+        stage.SetDefaultPrim(world.GetPrim())
+
+        UsdGeom.Xform.Define(stage, "/Prototypes/TetProto")
+        tetmesh = stage.DefinePrim("/Prototypes/TetProto/SoftBody", "TetMesh")
+        tetmesh.CreateAttribute("points", Sdf.ValueTypeNames.Point3fArray).Set(
+            [(0, 0, 0), (1, 0, 0), (0, 1, 0), (0, 0, 1)]
+        )
+        tetmesh.CreateAttribute("tetVertexIndices", Sdf.ValueTypeNames.Int4Array).Set([(0, 1, 2, 3)])
+
+        for i in range(2):
+            instance = UsdGeom.Xform.Define(stage, f"/World/Instance{i}")
+            instance_prim = instance.GetPrim()
+            instance_prim.GetReferences().AddInternalReference("/Prototypes/TetProto")
+            instance_prim.SetInstanceable(True)
+
+        builder = newton.ModelBuilder()
+        builder.add_usd(stage)
+
+        self.assertEqual(len(builder.particle_q), 8)
+        self.assertEqual(len(builder.tet_indices), 2)
+        self.assertEqual(len(builder.tri_indices), 8)
+
+    @unittest.skipUnless(USD_AVAILABLE, "Requires usd-core")
+    def test_add_usd_imports_tetmesh_with_transforms(self):
+        """Test that add_usd applies TetMesh rotation and non-uniform scale transforms."""
+        from pxr import Usd
+
+        stage = Usd.Stage.CreateInMemory()
+        stage.GetRootLayer().ImportFromString(
+            """#usda 1.0
+(
+    defaultPrim = "World"
+    upAxis = "Z"
+)
+
+def Xform "World"
+{
+    double3 xformOp:translate = (1, 2, 3)
+    float xformOp:rotateZ = 90
+    float3 xformOp:scale = (2, 3, 4)
+    uniform token[] xformOpOrder = ["xformOp:translate", "xformOp:rotateZ", "xformOp:scale"]
+
+    def Xform "Offset"
+    {
+        double3 xformOp:translate = (0.5, -1, 2)
+        uniform token[] xformOpOrder = ["xformOp:translate"]
+
+        def TetMesh "SoftBody" ()
+        {
+            point3f[] points = [(0, 0, 0), (1, 0, 0), (0, 1, 0), (0, 0, 1)]
+            int4[] tetVertexIndices = [(0, 1, 2, 3)]
+        }
+    }
+}
+"""
+        )
+
+        import_quat = wp.quat_from_axis_angle(wp.vec3(0.0, 0.0, 1.0), np.pi)
+        builder = newton.ModelBuilder()
+        builder.add_usd(stage, xform=wp.transform((4.0, 5.0, 6.0), import_quat))
+
+        positions = np.array(builder.particle_q, dtype=np.float32)
+        expected = np.array(
+            [
+                [0.0, 2.0, 17.0],
+                [0.0, 0.0, 17.0],
+                [3.0, 2.0, 17.0],
+                [0.0, 2.0, 21.0],
+            ],
+            dtype=np.float32,
+        )
+        np.testing.assert_allclose(positions, expected, atol=1e-6)
+
     def test_tetmesh_save_load_npz(self):
         """Test TetMesh round-trip save/load via .npz."""
 
@@ -7971,6 +8068,61 @@ def test_tetmesh_custom_attributes_to_model(self):
         self.assertEqual(len(region_arr), model.tet_count)
         np.testing.assert_array_equal(region_arr, region_id)
 
+    @unittest.skipUnless(USD_AVAILABLE, "Requires usd-core")
+    def test_add_usd_does_not_mutate_loaded_tetmesh_custom_attributes(self):
+        """Test that add_usd filters TetMesh custom attributes without mutating the loaded mesh."""
+        from pxr import Usd
+
+        stage = Usd.Stage.CreateInMemory()
+        stage.GetRootLayer().ImportFromString(
+            """#usda 1.0
+(
+    defaultPrim = "World"
+)
+
+def Xform "World"
+{
+    def TetMesh "SoftBody" ()
+    {
+        point3f[] points = [(0, 0, 0), (1, 0, 0), (0, 1, 0), (0, 0, 1)]
+        int4[] tetVertexIndices = [(0, 1, 2, 3)]
+    }
+}
+"""
+        )
+
+        source_tetmesh = newton.TetMesh(
+            vertices=np.array([[0, 0, 0], [1, 0, 0], [0, 1, 0], [0, 0, 1]], dtype=np.float32),
+            tet_indices=np.array([0, 1, 2, 3], dtype=np.int32),
+            custom_attributes={
+                "temperature": (
+                    np.array([100.0, 200.0, 300.0, 400.0], dtype=np.float32),
+                    newton.Model.AttributeFrequency.PARTICLE,
+                ),
+                "regionId": (
+                    np.array([7], dtype=np.int32),
+                    newton.Model.AttributeFrequency.TETRAHEDRON,
+                ),
+            },
+        )
+
+        builder = newton.ModelBuilder()
+        builder.add_custom_attribute(
+            newton.ModelBuilder.CustomAttribute(
+                name="temperature",
+                dtype=wp.float32,
+                frequency=newton.Model.AttributeFrequency.PARTICLE,
+            )
+        )
+
+        with mock.patch("newton._src.utils.import_usd.usd.get_tetmesh", return_value=source_tetmesh):
+            builder.add_usd(stage)
+
+        self.assertEqual(set(source_tetmesh.custom_attributes), {"temperature", "regionId"})
+        model = builder.finalize()
+        self.assertTrue(hasattr(model, "temperature"))
+        self.assertFalse(hasattr(model, "regionId"))
+
     def test_mesh_create_from_file_obj(self):
         """Test Mesh.create_from_file with an OBJ file."""
 
diff --git a/newton/tests/test_import_usd_multi_dof.py b/newton/tests/test_import_usd_multi_dof.py
new file mode 100644
index 0000000000..76ad90579e
--- /dev/null
+++ b/newton/tests/test_import_usd_multi_dof.py
@@ -0,0 +1,67 @@
+# SPDX-FileCopyrightText: Copyright (c) 2026 The Newton Developers
+# SPDX-License-Identifier: Apache-2.0
+
+import os
+import unittest
+
+import newton
+from newton.tests.unittest_utils import USD_AVAILABLE
+
+
+class TestImportUsdMultiDofJoints(unittest.TestCase):
+    """Tests for USD import of multi-DOF joints (multiple single-DOF joints between same bodies)."""
+
+    @unittest.skipUnless(USD_AVAILABLE, "Requires usd-core")
+    def test_humanoid_mjc_multi_dof(self):
+        """Import a MuJoCo-converted humanoid with multi-joint body pairs.
+
+        The humanoid_mjc.usda file has 21 revolute joints across 13 bodies,
+        where several body pairs share multiple joints (e.g. 3 hip joints).
+        These must be merged into D6 joints without triggering cycle errors.
+        """
+        builder = newton.ModelBuilder()
+        asset_path = os.path.join(os.path.dirname(__file__), "assets", "humanoid_mjc.usda")
+
+        builder.add_usd(asset_path)
+
+        # 13 bodies (torso + 12 child bodies)
+        self.assertEqual(builder.body_count, 13)
+        # 13 joints: 1 free root + 7 merged D6 + 5 standalone revolute
+        self.assertEqual(builder.joint_count, 13)
+        # 27 DOFs: 6 free root + 21 individual DOFs from the 21 revolute joints
+        self.assertEqual(builder.joint_dof_count, 27)
+
+    @unittest.skipUnless(USD_AVAILABLE, "Requires usd-core")
+    def test_humanoid_mjc_path_joint_map(self):
+        """All original joint prim paths should be in the path_joint_map."""
+        builder = newton.ModelBuilder()
+        asset_path = os.path.join(os.path.dirname(__file__), "assets", "humanoid_mjc.usda")
+
+        result = builder.add_usd(asset_path)
+
+        path_joint_map = result["path_joint_map"]
+        # All 21 original revolute joint paths should be mapped
+        self.assertEqual(len(path_joint_map), 21)
+
+        # Merged joints should point to the same joint index
+        # e.g. right_hip_x, right_hip_z, right_hip_y all map to the same D6
+        hip_paths = [p for p in path_joint_map if "right_hip" in p]
+        self.assertEqual(len(hip_paths), 3)
+        hip_indices = {path_joint_map[p] for p in hip_paths}
+        self.assertEqual(len(hip_indices), 1, "All right hip joints should map to the same D6 joint index")
+
+    @unittest.skipUnless(USD_AVAILABLE, "Requires usd-core")
+    def test_humanoid_mjc_finalize(self):
+        """The imported humanoid should finalize and simulate without errors."""
+        builder = newton.ModelBuilder()
+        asset_path = os.path.join(os.path.dirname(__file__), "assets", "humanoid_mjc.usda")
+        builder.add_usd(asset_path)
+
+        model = builder.finalize()
+        self.assertIsNotNone(model)
+        self.assertEqual(model.body_count, 13)
+        self.assertEqual(model.joint_count, 13)
+
+
+if __name__ == "__main__":
+    unittest.main()
diff --git a/newton/tests/test_menagerie_mujoco.py b/newton/tests/test_menagerie_mujoco.py
index eaab53ad21..d852b1ca32 100644
--- a/newton/tests/test_menagerie_mujoco.py
+++ b/newton/tests/test_menagerie_mujoco.py
@@ -1168,8 +1168,6 @@ def backfill_model_from_native(
         if native_arr.shape == newton_arr.shape:
             newton_arr.assign(native_arr)
 
-    wp.synchronize()
-
 
 def compare_mjw_models(
     newton_mjw: Any,
diff --git a/newton/tests/test_menagerie_usd_mujoco.py b/newton/tests/test_menagerie_usd_mujoco.py
index c5a7b0f4e3..aa7710c2af 100644
--- a/newton/tests/test_menagerie_usd_mujoco.py
+++ b/newton/tests/test_menagerie_usd_mujoco.py
@@ -1279,8 +1279,9 @@ class TestMenagerieUSD_H1(TestMenagerieUSD):
     usd_asset_folder = "unitree_h1"
     usd_scene_file = "usd_structured/h1.usda"
 
-    num_worlds = 2
-    num_steps = 0  # USD dynamics not yet tested with step-response
+    num_steps = 20
+    fk_enabled = True
+    backfill_model = True
 
 
 @unittest.skipUnless(USD_AVAILABLE, "Requires usd-core")
@@ -1294,6 +1295,7 @@ class TestMenagerieUSD_G1WithHands(TestMenagerieUSD):
 
     num_worlds = 2
     num_steps = 0  # USD dynamics not yet tested with step-response
+    fk_enabled = False  # xpos diff 0.109 — USD import issue (#2420)
 
 
 @unittest.skipUnless(USD_AVAILABLE, "Requires usd-core")
@@ -1307,6 +1309,7 @@ class TestMenagerieUSD_ShadowHand(TestMenagerieUSD):
 
     num_worlds = 2
     num_steps = 0  # USD dynamics not yet tested with step-response
+    fk_enabled = False  # xpos diff 0.146 — USD import issue (#2420)
 
 
 @unittest.skipUnless(USD_AVAILABLE, "Requires usd-core")
@@ -1335,6 +1338,7 @@ class TestMenagerieUSD_ApptronikApollo(TestMenagerieUSD):
 
     num_worlds = 2
     num_steps = 0  # USD dynamics not yet tested with step-response
+    fk_enabled = False  # xpos diff 1.56 — USD import issue (#2420)
     njmax = 398
 
     # Apollo's USD has no collision geoms, so geom/collision counts differ.
@@ -1356,6 +1360,7 @@ class TestMenagerieUSD_BoosterT1(TestMenagerieUSD):
 
     num_worlds = 2
     num_steps = 0  # USD dynamics not yet tested with step-response
+    fk_enabled = False  # xpos diff 0.509 — USD import issue (#2420)
 
 
 @unittest.skipUnless(USD_AVAILABLE, "Requires usd-core")
@@ -1369,6 +1374,7 @@ class TestMenagerieUSD_WonikAllegro(TestMenagerieUSD):
 
     num_worlds = 2
     num_steps = 0  # USD dynamics not yet tested with step-response
+    fk_enabled = False  # xpos diff 0.106 — USD import issue (#2420)
 
     def _compare_inertia(self, newton_mjw: Any, native_mjw: Any) -> None:
         # TODO: USD asset has different mass/inertia values than the original MJCF.
@@ -1389,8 +1395,9 @@ class TestMenagerieUSD_UR5e(TestMenagerieUSD):
     usd_asset_folder = "universal_robots_ur5e"
     usd_scene_file = "usd_structured/ur5e.usda"
 
-    num_worlds = 2
-    num_steps = 0  # USD dynamics not yet tested with step-response
+    num_steps = 20
+    fk_enabled = True
+    backfill_model = True
 
 
 # =============================================================================
diff --git a/newton/tests/test_mujoco_solver.py b/newton/tests/test_mujoco_solver.py
index 18ae2d2f92..4a2c3433e6 100644
--- a/newton/tests/test_mujoco_solver.py
+++ b/newton/tests/test_mujoco_solver.py
@@ -3971,6 +3971,94 @@ def test_efc_address_init(self):
         self.assertEqual(n_stale, 0, f"{n_stale}/{inactive.sum()} inactive contacts have stale efc_address")
 
 
+class TestFrictionPriority(unittest.TestCase):
+    """Verify that contact friction respects geom priority.
+
+    When two geoms have different priorities, the higher-priority geom's
+    friction should be used directly (not the element-wise max).
+    """
+
+    def _build_model(self, priority_a, friction_a, priority_b, friction_b):
+        builder = newton.ModelBuilder()
+        SolverMuJoCo.register_custom_attributes(builder)
+
+        cfg_a = newton.ModelBuilder.ShapeConfig(ke=1e4, kd=1000.0, mu=friction_a)
+        cfg_b = newton.ModelBuilder.ShapeConfig(ke=1e4, kd=1000.0, mu=friction_b)
+
+        body_a = builder.add_body(xform=wp.transform(wp.vec3(0.0, 0.0, 0.3), wp.quat_identity()))
+        builder.add_shape_box(
+            body=body_a,
+            hx=0.2,
+            hy=0.2,
+            hz=0.1,
+            cfg=cfg_a,
+            custom_attributes={"mujoco:geom_priority": priority_a},
+        )
+
+        body_b = builder.add_body(xform=wp.transform(wp.vec3(0.0, 0.0, 0.1), wp.quat_identity()))
+        builder.add_shape_box(
+            body=body_b,
+            hx=0.5,
+            hy=0.5,
+            hz=0.1,
+            cfg=cfg_b,
+            custom_attributes={"mujoco:geom_priority": priority_b},
+        )
+
+        model = builder.finalize()
+        return model
+
+    def _get_contact_friction(self, model):
+        try:
+            solver = SolverMuJoCo(model, use_mujoco_contacts=False, njmax=200, nconmax=200)
+        except ImportError as e:
+            self.skipTest(f"MuJoCo or deps not installed: {e}")
+
+        contacts = model.contacts()
+        state_in = model.state()
+        state_out = model.state()
+        control = model.control()
+        newton.eval_fk(model, model.joint_q, model.joint_qd, state_in)
+        model.collide(state_in, contacts)
+        solver.step(state_in, state_out, control, contacts, 0.002)
+
+        nacon = solver.mjw_data.nacon.numpy()[0]
+        self.assertGreater(nacon, 0, "No contacts generated")
+        return solver.mjw_data.contact.friction.numpy()[:nacon]
+
+    def _assert_slide_friction(self, friction, expected, label):
+        for i in range(len(friction)):
+            self.assertAlmostEqual(
+                float(friction[i, 0]),
+                expected,
+                places=5,
+                msg=f"{label}: contact {i} slide friction should be {expected}, got {friction[i, 0]}",
+            )
+
+    def test_higher_priority_friction_used(self):
+        """Contact friction should come from the higher-priority geom, regardless of operand order."""
+        hi_mu = 0.3
+        lo_mu = 0.9
+
+        model_a = self._build_model(priority_a=5, friction_a=hi_mu, priority_b=0, friction_b=lo_mu)
+        self._assert_slide_friction(self._get_contact_friction(model_a), hi_mu, "high-priority on body A")
+
+        model_b = self._build_model(priority_a=0, friction_a=lo_mu, priority_b=5, friction_b=hi_mu)
+        self._assert_slide_friction(self._get_contact_friction(model_b), hi_mu, "high-priority on body B")
+
+    def test_equal_priority_uses_max(self):
+        """When priorities are equal, contact friction should be the element-wise max, regardless of operand order."""
+        mu_lo = 0.2
+        mu_hi = 0.8
+        expected = mu_hi
+
+        model_a = self._build_model(priority_a=0, friction_a=mu_hi, priority_b=0, friction_b=mu_lo)
+        self._assert_slide_friction(self._get_contact_friction(model_a), expected, "larger mu on body A")
+
+        model_b = self._build_model(priority_a=0, friction_a=mu_lo, priority_b=0, friction_b=mu_hi)
+        self._assert_slide_friction(self._get_contact_friction(model_b), expected, "larger mu on body B")
+
+
 class TestImmovableContactFiltering(unittest.TestCase):
     """Verify that contacts between two immovable bodies are filtered out.
 
@@ -6377,6 +6465,26 @@ def test_iterations_constructor_override(self):
         self.assertEqual(solver.mj_model.opt.iterations, 5, "Constructor value should override custom attribute")
         self.assertEqual(solver.mj_model.opt.ls_iterations, 3, "Constructor value should override custom attribute")
 
+    def test_enable_multiccd_default_off(self):
+        """Verify that mjENBL_MULTICCD is not set by default."""
+        model = self._create_multiworld_model(world_count=1)
+        solver = SolverMuJoCo(model)
+        mujoco = SolverMuJoCo._mujoco
+        self.assertFalse(
+            solver.mj_model.opt.enableflags & mujoco.mjtEnableBit.mjENBL_MULTICCD,
+            "mjENBL_MULTICCD should not be set when enable_multiccd is not specified",
+        )
+
+    def test_enable_multiccd_passed_to_mujoco(self):
+        """Verify that enable_multiccd sets mjENBL_MULTICCD on the MuJoCo model."""
+        model = self._create_multiworld_model(world_count=1)
+        solver = SolverMuJoCo(model, enable_multiccd=True)
+        mujoco = SolverMuJoCo._mujoco
+        self.assertTrue(
+            solver.mj_model.opt.enableflags & mujoco.mjtEnableBit.mjENBL_MULTICCD,
+            "mjENBL_MULTICCD should be set on mj_model.opt.enableflags",
+        )
+
 
 class TestMuJoCoArticulationConversion(unittest.TestCase):
     def test_loop_joints_only(self):
diff --git a/newton/tests/test_narrow_phase.py b/newton/tests/test_narrow_phase.py
index 48ba158b03..1c7cf3e194 100644
--- a/newton/tests/test_narrow_phase.py
+++ b/newton/tests/test_narrow_phase.py
@@ -330,8 +330,6 @@ def _run_narrow_phase(self, geom_list, pairs):
             contact_tangent=contact_tangent,
         )
 
-        wp.synchronize()
-
         count = contact_count.numpy()[0]
         return (
             count,
diff --git a/newton/tests/test_raycast.py b/newton/tests/test_raycast.py
index 35ebd263c3..df07a3e6be 100644
--- a/newton/tests/test_raycast.py
+++ b/newton/tests/test_raycast.py
@@ -13,8 +13,10 @@
     ray_intersect_capsule,
     ray_intersect_cone,
     ray_intersect_cylinder,
+    ray_intersect_ellipsoid,
     ray_intersect_geom,
     ray_intersect_mesh,
+    ray_intersect_plane,
     ray_intersect_sphere,
 )
 from newton.tests.unittest_utils import add_function_test, get_test_devices
@@ -88,6 +90,30 @@ def kernel_test_cone(
     out_t[tid] = ray_intersect_cone(geom_to_world, ray_origin, ray_direction, r, h)
 
 
+@wp.kernel
+def kernel_test_ellipsoid(
+    out_t: wp.array[float],
+    geom_to_world: wp.transform,
+    ray_origin: wp.vec3,
+    ray_direction: wp.vec3,
+    semi_axes: wp.vec3,
+):
+    tid = wp.tid()
+    out_t[tid] = ray_intersect_ellipsoid(geom_to_world, ray_origin, ray_direction, semi_axes)
+
+
+@wp.kernel
+def kernel_test_plane(
+    out_t: wp.array[float],
+    geom_to_world: wp.transform,
+    ray_origin: wp.vec3,
+    ray_direction: wp.vec3,
+    size: wp.vec3,
+):
+    tid = wp.tid()
+    out_t[tid] = ray_intersect_plane(geom_to_world, ray_origin, ray_direction, size)
+
+
 @wp.kernel
 def kernel_test_geom(
     out_t: wp.array[float],
@@ -121,21 +147,21 @@ def test_ray_intersect_sphere(test: TestRaycast, device: str):
     geom_to_world = wp.transform_identity()
     r = 1.0
 
-    # Case 1: Ray hits sphere
-    ray_origin = wp.vec3(-2.0, 0.0, 0.0)
-    ray_direction = wp.vec3(1.0, 0.0, 0.0)
-    wp.launch(kernel_test_sphere, dim=1, inputs=[out_t, geom_to_world, ray_origin, ray_direction, r], device=device)
-    test.assertAlmostEqual(out_t.numpy()[0], 1.0, delta=1e-5)
+    with test.subTest("hit"):
+        ray_origin = wp.vec3(-2.0, 0.0, 0.0)
+        ray_direction = wp.vec3(1.0, 0.0, 0.0)
+        wp.launch(kernel_test_sphere, dim=1, inputs=[out_t, geom_to_world, ray_origin, ray_direction, r], device=device)
+        test.assertAlmostEqual(out_t.numpy()[0], 1.0, delta=1e-5)
 
-    # Case 2: Ray misses sphere
-    ray_origin = wp.vec3(-2.0, 2.0, 0.0)
-    wp.launch(kernel_test_sphere, dim=1, inputs=[out_t, geom_to_world, ray_origin, ray_direction, r], device=device)
-    test.assertAlmostEqual(out_t.numpy()[0], -1.0, delta=1e-5)
+    with test.subTest("miss"):
+        ray_origin = wp.vec3(-2.0, 2.0, 0.0)
+        wp.launch(kernel_test_sphere, dim=1, inputs=[out_t, geom_to_world, ray_origin, ray_direction, r], device=device)
+        test.assertAlmostEqual(out_t.numpy()[0], -1.0, delta=1e-5)
 
-    # Case 3: Ray starts inside
-    ray_origin = wp.vec3(0.0, 0.0, 0.0)
-    wp.launch(kernel_test_sphere, dim=1, inputs=[out_t, geom_to_world, ray_origin, ray_direction, r], device=device)
-    test.assertAlmostEqual(out_t.numpy()[0], 1.0, delta=1e-5)
+    with test.subTest("inside"):
+        ray_origin = wp.vec3(0.0, 0.0, 0.0)
+        wp.launch(kernel_test_sphere, dim=1, inputs=[out_t, geom_to_world, ray_origin, ray_direction, r], device=device)
+        test.assertAlmostEqual(out_t.numpy()[0], 1.0, delta=1e-5)
 
 
 def test_ray_intersect_box(test: TestRaycast, device: str):
@@ -143,30 +169,29 @@ def test_ray_intersect_box(test: TestRaycast, device: str):
     geom_to_world = wp.transform_identity()
     size = wp.vec3(1.0, 1.0, 1.0)
 
-    # Case 1: Ray hits box
-    ray_origin = wp.vec3(-2.0, 0.0, 0.0)
-    ray_direction = wp.vec3(1.0, 0.0, 0.0)
-    wp.launch(kernel_test_box, dim=1, inputs=[out_t, geom_to_world, ray_origin, ray_direction, size], device=device)
-    test.assertAlmostEqual(out_t.numpy()[0], 1.0, delta=1e-5)
-
-    # Case 2: Ray misses box
-    ray_origin = wp.vec3(-2.0, 2.0, 0.0)
-    wp.launch(kernel_test_box, dim=1, inputs=[out_t, geom_to_world, ray_origin, ray_direction, size], device=device)
-    test.assertAlmostEqual(out_t.numpy()[0], -1.0, delta=1e-5)
-
-    # Case 3: Ray starts inside
-    ray_origin = wp.vec3(0.0, 0.0, 0.0)
-    wp.launch(kernel_test_box, dim=1, inputs=[out_t, geom_to_world, ray_origin, ray_direction, size], device=device)
-    test.assertAlmostEqual(out_t.numpy()[0], 1.0, delta=1e-5)
-
-    # Case 4: Rotated box
-    # Rotate 45 degrees around Z axis
-    rot = wp.quat_from_axis_angle(wp.vec3(0.0, 0.0, 1.0), 0.785398)  # pi/4
-    geom_to_world = wp.transform(wp.vec3(0.0, 0.0, 0.0), rot)
-    ray_origin = wp.vec3(-2.0, 0.0, 0.0)
-    ray_direction = wp.vec3(1.0, 0.0, 0.0)
-    wp.launch(kernel_test_box, dim=1, inputs=[out_t, geom_to_world, ray_origin, ray_direction, size], device=device)
-    test.assertAlmostEqual(out_t.numpy()[0], 2.0 - 1.41421, delta=1e-5)
+    with test.subTest("hit"):
+        ray_origin = wp.vec3(-2.0, 0.0, 0.0)
+        ray_direction = wp.vec3(1.0, 0.0, 0.0)
+        wp.launch(kernel_test_box, dim=1, inputs=[out_t, geom_to_world, ray_origin, ray_direction, size], device=device)
+        test.assertAlmostEqual(out_t.numpy()[0], 1.0, delta=1e-5)
+
+    with test.subTest("miss"):
+        ray_origin = wp.vec3(-2.0, 2.0, 0.0)
+        wp.launch(kernel_test_box, dim=1, inputs=[out_t, geom_to_world, ray_origin, ray_direction, size], device=device)
+        test.assertAlmostEqual(out_t.numpy()[0], -1.0, delta=1e-5)
+
+    with test.subTest("inside"):
+        ray_origin = wp.vec3(0.0, 0.0, 0.0)
+        wp.launch(kernel_test_box, dim=1, inputs=[out_t, geom_to_world, ray_origin, ray_direction, size], device=device)
+        test.assertAlmostEqual(out_t.numpy()[0], 1.0, delta=1e-5)
+
+    with test.subTest("rotated"):
+        rot = wp.quat_from_axis_angle(wp.vec3(0.0, 0.0, 1.0), 0.785398)  # pi/4
+        geom_to_world = wp.transform(wp.vec3(0.0, 0.0, 0.0), rot)
+        ray_origin = wp.vec3(-2.0, 0.0, 0.0)
+        ray_direction = wp.vec3(1.0, 0.0, 0.0)
+        wp.launch(kernel_test_box, dim=1, inputs=[out_t, geom_to_world, ray_origin, ray_direction, size], device=device)
+        test.assertAlmostEqual(out_t.numpy()[0], 2.0 - 1.41421, delta=1e-5)
 
 
 def test_ray_intersect_capsule(test: TestRaycast, device: str):
@@ -175,23 +200,29 @@ def test_ray_intersect_capsule(test: TestRaycast, device: str):
     r = 0.5
     h = 1.0
 
-    # Case 1: Hit cylinder part
-    ray_origin = wp.vec3(-2.0, 0.0, 0.0)
-    ray_direction = wp.vec3(1.0, 0.0, 0.0)
-    wp.launch(kernel_test_capsule, dim=1, inputs=[out_t, geom_to_world, ray_origin, ray_direction, r, h], device=device)
-    test.assertAlmostEqual(out_t.numpy()[0], 1.5, delta=1e-5)
-
-    # Case 2: Hit top cap
-    ray_origin = wp.vec3(0.0, 0.0, -2.0)
-    ray_direction = wp.vec3(0.0, 0.0, 1.0)
-    wp.launch(kernel_test_capsule, dim=1, inputs=[out_t, geom_to_world, ray_origin, ray_direction, r, h], device=device)
-    test.assertAlmostEqual(out_t.numpy()[0], 2.0 - 1.0 - 0.5, delta=1e-5)
-
-    # Case 3: Miss
-    ray_origin = wp.vec3(-2.0, 2.0, 0.0)
-    ray_direction = wp.vec3(1.0, 0.0, 0.0)
-    wp.launch(kernel_test_capsule, dim=1, inputs=[out_t, geom_to_world, ray_origin, ray_direction, r, h], device=device)
-    test.assertAlmostEqual(out_t.numpy()[0], -1.0, delta=1e-5)
+    with test.subTest("hit_cylinder"):
+        ray_origin = wp.vec3(-2.0, 0.0, 0.0)
+        ray_direction = wp.vec3(1.0, 0.0, 0.0)
+        wp.launch(
+            kernel_test_capsule, dim=1, inputs=[out_t, geom_to_world, ray_origin, ray_direction, r, h], device=device
+        )
+        test.assertAlmostEqual(out_t.numpy()[0], 1.5, delta=1e-5)
+
+    with test.subTest("hit_cap"):
+        ray_origin = wp.vec3(0.0, 0.0, -2.0)
+        ray_direction = wp.vec3(0.0, 0.0, 1.0)
+        wp.launch(
+            kernel_test_capsule, dim=1, inputs=[out_t, geom_to_world, ray_origin, ray_direction, r, h], device=device
+        )
+        test.assertAlmostEqual(out_t.numpy()[0], 2.0 - 1.0 - 0.5, delta=1e-5)
+
+    with test.subTest("miss"):
+        ray_origin = wp.vec3(-2.0, 2.0, 0.0)
+        ray_direction = wp.vec3(1.0, 0.0, 0.0)
+        wp.launch(
+            kernel_test_capsule, dim=1, inputs=[out_t, geom_to_world, ray_origin, ray_direction, r, h], device=device
+        )
+        test.assertAlmostEqual(out_t.numpy()[0], -1.0, delta=1e-5)
 
 
 def test_ray_intersect_cylinder(test: TestRaycast, device: str):
@@ -200,29 +231,29 @@ def test_ray_intersect_cylinder(test: TestRaycast, device: str):
     r = 0.5
     h = 1.0
 
-    # Case 1: Hit cylinder body
-    ray_origin = wp.vec3(-2.0, 0.0, 0.0)
-    ray_direction = wp.vec3(1.0, 0.0, 0.0)
-    wp.launch(
-        kernel_test_cylinder, dim=1, inputs=[out_t, geom_to_world, ray_origin, ray_direction, r, h], device=device
-    )
-    test.assertAlmostEqual(out_t.numpy()[0], 1.5, delta=1e-5)
-
-    # Case 2: Hit top cap
-    ray_origin = wp.vec3(0.0, 0.0, -2.0)
-    ray_direction = wp.vec3(0.0, 0.0, 1.0)
-    wp.launch(
-        kernel_test_cylinder, dim=1, inputs=[out_t, geom_to_world, ray_origin, ray_direction, r, h], device=device
-    )
-    test.assertAlmostEqual(out_t.numpy()[0], 1.0, delta=1e-5)
-
-    # Case 3: Miss
-    ray_origin = wp.vec3(-2.0, 2.0, 0.0)
-    ray_direction = wp.vec3(1.0, 0.0, 0.0)
-    wp.launch(
-        kernel_test_cylinder, dim=1, inputs=[out_t, geom_to_world, ray_origin, ray_direction, r, h], device=device
-    )
-    test.assertAlmostEqual(out_t.numpy()[0], -1.0, delta=1e-5)
+    with test.subTest("hit_body"):
+        ray_origin = wp.vec3(-2.0, 0.0, 0.0)
+        ray_direction = wp.vec3(1.0, 0.0, 0.0)
+        wp.launch(
+            kernel_test_cylinder, dim=1, inputs=[out_t, geom_to_world, ray_origin, ray_direction, r, h], device=device
+        )
+        test.assertAlmostEqual(out_t.numpy()[0], 1.5, delta=1e-5)
+
+    with test.subTest("hit_cap"):
+        ray_origin = wp.vec3(0.0, 0.0, -2.0)
+        ray_direction = wp.vec3(0.0, 0.0, 1.0)
+        wp.launch(
+            kernel_test_cylinder, dim=1, inputs=[out_t, geom_to_world, ray_origin, ray_direction, r, h], device=device
+        )
+        test.assertAlmostEqual(out_t.numpy()[0], 1.0, delta=1e-5)
+
+    with test.subTest("miss"):
+        ray_origin = wp.vec3(-2.0, 2.0, 0.0)
+        ray_direction = wp.vec3(1.0, 0.0, 0.0)
+        wp.launch(
+            kernel_test_cylinder, dim=1, inputs=[out_t, geom_to_world, ray_origin, ray_direction, r, h], device=device
+        )
+        test.assertAlmostEqual(out_t.numpy()[0], -1.0, delta=1e-5)
 
 
 def test_ray_intersect_cone(test: TestRaycast, device: str):
@@ -231,29 +262,173 @@ def test_ray_intersect_cone(test: TestRaycast, device: str):
     r = 1.0  # base radius
     h = 1.0  # half height (so total height is 2.0)
 
-    # Case 1: Hit cone body from the side
-    ray_origin = wp.vec3(-2.0, 0.0, 0.0)
-    ray_direction = wp.vec3(1.0, 0.0, 0.0)
-    wp.launch(kernel_test_cone, dim=1, inputs=[out_t, geom_to_world, ray_origin, ray_direction, r, h], device=device)
-    test.assertAlmostEqual(out_t.numpy()[0], 1.5, delta=1e-3)
-
-    # Case 2: Hit cone base from below
-    ray_origin = wp.vec3(0.0, 0.0, -2.0)
-    ray_direction = wp.vec3(0.0, 0.0, 1.0)
-    wp.launch(kernel_test_cone, dim=1, inputs=[out_t, geom_to_world, ray_origin, ray_direction, r, h], device=device)
-    test.assertAlmostEqual(out_t.numpy()[0], 1.0, delta=1e-3)  # hits base at z=-1
-
-    # Case 3: Miss cone completely
-    ray_origin = wp.vec3(-2.0, 2.0, 0.0)
-    ray_direction = wp.vec3(1.0, 0.0, 0.0)
-    wp.launch(kernel_test_cone, dim=1, inputs=[out_t, geom_to_world, ray_origin, ray_direction, r, h], device=device)
-    test.assertAlmostEqual(out_t.numpy()[0], -1.0, delta=1e-5)
-
-    # Case 4: Ray from above hitting the tip area
-    ray_origin = wp.vec3(0.0, 0.0, 2.0)
-    ray_direction = wp.vec3(0.0, 0.0, -1.0)
-    wp.launch(kernel_test_cone, dim=1, inputs=[out_t, geom_to_world, ray_origin, ray_direction, r, h], device=device)
-    test.assertAlmostEqual(out_t.numpy()[0], 1.0, delta=1e-3)  # hits tip at z=1
+    with test.subTest("hit_body"):
+        ray_origin = wp.vec3(-2.0, 0.0, 0.0)
+        ray_direction = wp.vec3(1.0, 0.0, 0.0)
+        wp.launch(
+            kernel_test_cone, dim=1, inputs=[out_t, geom_to_world, ray_origin, ray_direction, r, h], device=device
+        )
+        test.assertAlmostEqual(out_t.numpy()[0], 1.5, delta=1e-3)
+
+    with test.subTest("hit_base"):
+        ray_origin = wp.vec3(0.0, 0.0, -2.0)
+        ray_direction = wp.vec3(0.0, 0.0, 1.0)
+        wp.launch(
+            kernel_test_cone, dim=1, inputs=[out_t, geom_to_world, ray_origin, ray_direction, r, h], device=device
+        )
+        test.assertAlmostEqual(out_t.numpy()[0], 1.0, delta=1e-3)  # hits base at z=-1
+
+    with test.subTest("miss"):
+        ray_origin = wp.vec3(-2.0, 2.0, 0.0)
+        ray_direction = wp.vec3(1.0, 0.0, 0.0)
+        wp.launch(
+            kernel_test_cone, dim=1, inputs=[out_t, geom_to_world, ray_origin, ray_direction, r, h], device=device
+        )
+        test.assertAlmostEqual(out_t.numpy()[0], -1.0, delta=1e-5)
+
+    with test.subTest("hit_tip"):
+        ray_origin = wp.vec3(0.0, 0.0, 2.0)
+        ray_direction = wp.vec3(0.0, 0.0, -1.0)
+        wp.launch(
+            kernel_test_cone, dim=1, inputs=[out_t, geom_to_world, ray_origin, ray_direction, r, h], device=device
+        )
+        test.assertAlmostEqual(out_t.numpy()[0], 1.0, delta=1e-3)  # hits tip at z=1
+
+
+def test_ray_intersect_ellipsoid(test: TestRaycast, device: str):
+    out_t = wp.zeros(1, dtype=float, device=device)
+    geom_to_world = wp.transform_identity()
+    semi_axes = wp.vec3(1.0, 0.5, 0.5)  # non-uniform to exercise ellipsoid-specific logic
+
+    with test.subTest("hit"):
+        ray_origin = wp.vec3(-3.0, 0.0, 0.0)
+        ray_direction = wp.vec3(1.0, 0.0, 0.0)
+        wp.launch(
+            kernel_test_ellipsoid,
+            dim=1,
+            inputs=[out_t, geom_to_world, ray_origin, ray_direction, semi_axes],
+            device=device,
+        )
+        test.assertAlmostEqual(out_t.numpy()[0], 2.0, delta=1e-5)
+
+    with test.subTest("miss"):
+        ray_origin = wp.vec3(-3.0, 1.0, 0.0)
+        ray_direction = wp.vec3(1.0, 0.0, 0.0)
+        wp.launch(
+            kernel_test_ellipsoid,
+            dim=1,
+            inputs=[out_t, geom_to_world, ray_origin, ray_direction, semi_axes],
+            device=device,
+        )
+        test.assertAlmostEqual(out_t.numpy()[0], -1.0, delta=1e-5)
+
+    with test.subTest("inside"):
+        ray_origin = wp.vec3(0.0, 0.0, 0.0)
+        ray_direction = wp.vec3(1.0, 0.0, 0.0)
+        wp.launch(
+            kernel_test_ellipsoid,
+            dim=1,
+            inputs=[out_t, geom_to_world, ray_origin, ray_direction, semi_axes],
+            device=device,
+        )
+        test.assertAlmostEqual(out_t.numpy()[0], 1.0, delta=1e-5)
+
+
+def test_ray_intersect_plane(test: TestRaycast, device: str):
+    out_t = wp.zeros(1, dtype=float, device=device)
+    geom_to_world = wp.transform_identity()
+    size = wp.vec3(0.0, 0.0, 0.0)
+
+    with test.subTest("hit_from_above"):
+        ray_origin = wp.vec3(0.0, 0.0, 4.0)
+        ray_direction = wp.vec3(3.0, 0.0, -4.0)  # 3-4-5 triple
+        wp.launch(
+            kernel_test_plane, dim=1, inputs=[out_t, geom_to_world, ray_origin, ray_direction, size], device=device
+        )
+        test.assertAlmostEqual(out_t.numpy()[0], 1.0, delta=1e-5)
+
+    with test.subTest("parallel_miss"):
+        ray_origin = wp.vec3(0.0, 0.0, 2.0)
+        ray_direction = wp.vec3(1.0, 0.0, 0.0)
+        wp.launch(
+            kernel_test_plane, dim=1, inputs=[out_t, geom_to_world, ray_origin, ray_direction, size], device=device
+        )
+        test.assertAlmostEqual(out_t.numpy()[0], -1.0, delta=1e-5)
+
+    with test.subTest("backward_miss"):
+        ray_origin = wp.vec3(0.0, 0.0, 5.0)
+        ray_direction = wp.vec3(0.0, 0.0, 1.0)
+        wp.launch(
+            kernel_test_plane, dim=1, inputs=[out_t, geom_to_world, ray_origin, ray_direction, size], device=device
+        )
+        test.assertAlmostEqual(out_t.numpy()[0], -1.0, delta=1e-5)
+
+    with test.subTest("translated_plane"):
+        geom_to_world = wp.transform(wp.vec3(0.0, 0.0, 3.0), wp.quat_identity())
+        ray_origin = wp.vec3(0.0, 0.0, 7.0)
+        ray_direction = wp.vec3(3.0, 0.0, -4.0)  # 3-4-5 triple, local z-offset = 4
+        wp.launch(
+            kernel_test_plane, dim=1, inputs=[out_t, geom_to_world, ray_origin, ray_direction, size], device=device
+        )
+        test.assertAlmostEqual(out_t.numpy()[0], 1.0, delta=1e-5)
+
+    with test.subTest("finite_miss_half_extent"):
+        geom_to_world = wp.transform_identity()
+        size_finite = wp.vec3(4.0, 4.0, 0.0)  # full width 4, half-extent 2
+        ray_origin = wp.vec3(0.0, 0.0, 4.0)
+        ray_direction = wp.vec3(3.0, 0.0, -4.0)  # 3-4-5 triple, crosses plane at (3, 0, 0) -- |3| > 2
+        wp.launch(
+            kernel_test_plane,
+            dim=1,
+            inputs=[out_t, geom_to_world, ray_origin, ray_direction, size_finite],
+            device=device,
+        )
+        test.assertAlmostEqual(out_t.numpy()[0], -1.0, delta=1e-5)
+
+    with test.subTest("finite_miss_x"):
+        geom_to_world = wp.transform_identity()
+        size_finite = wp.vec3(2.0, 2.0, 0.0)  # full width 2, half-extent 1
+        ray_origin = wp.vec3(0.0, 0.0, 4.0)
+        ray_direction = wp.vec3(3.0, 0.0, -4.0)  # 3-4-5 triple, hits at (3, 0, 0) -- |3| > 1
+        wp.launch(
+            kernel_test_plane,
+            dim=1,
+            inputs=[out_t, geom_to_world, ray_origin, ray_direction, size_finite],
+            device=device,
+        )
+        test.assertAlmostEqual(out_t.numpy()[0], -1.0, delta=1e-5)
+
+    with test.subTest("finite_miss_y"):
+        geom_to_world = wp.transform_identity()
+        size_finite = wp.vec3(10.0, 2.0, 0.0)
+        ray_origin = wp.vec3(0.0, 0.0, 4.0)
+        ray_direction = wp.vec3(0.0, 3.0, -4.0)  # 3-4-5 triple, hits at (0, 3, 0) -- |3| > half 2 = 1
+        wp.launch(
+            kernel_test_plane,
+            dim=1,
+            inputs=[out_t, geom_to_world, ray_origin, ray_direction, size_finite],
+            device=device,
+        )
+        test.assertAlmostEqual(out_t.numpy()[0], -1.0, delta=1e-5)
+
+    with test.subTest("hit_from_below"):
+        geom_to_world = wp.transform_identity()
+        ray_origin = wp.vec3(0.0, 0.0, -4.0)
+        ray_direction = wp.vec3(0.0, 3.0, 4.0)  # 3-4-5 triple
+        wp.launch(
+            kernel_test_plane, dim=1, inputs=[out_t, geom_to_world, ray_origin, ray_direction, size], device=device
+        )
+        test.assertAlmostEqual(out_t.numpy()[0], 1.0, delta=1e-5)
+
+    with test.subTest("rotated_plane"):
+        q_rot = wp.quat_from_axis_angle(wp.vec3(1.0, 0.0, 0.0), 3.14159265 / 2.0)
+        geom_to_world = wp.transform(wp.vec3(0.0, 0.0, 0.0), q_rot)
+        ray_origin = wp.vec3(0.0, -5.0, 0.0)
+        ray_direction = wp.vec3(0.0, 1.0, 0.0)
+        wp.launch(
+            kernel_test_plane, dim=1, inputs=[out_t, geom_to_world, ray_origin, ray_direction, size], device=device
+        )
+        test.assertAlmostEqual(out_t.numpy()[0], 5.0, delta=1e-5)
 
 
 def test_geom_ray_intersect(test: TestRaycast, device: str):
@@ -263,55 +438,77 @@ def test_geom_ray_intersect(test: TestRaycast, device: str):
     ray_direction = wp.vec3(1.0, 0.0, 0.0)
     mesh_id = wp.uint64(0)  # No mesh for primitive shapes
 
-    # Sphere
-    size = wp.vec3(1.0, 0.0, 0.0)  # r
-    wp.launch(
-        kernel_test_geom,
-        dim=1,
-        inputs=[out_t, geom_to_world, size, GeoType.SPHERE, ray_origin, ray_direction, mesh_id],
-        device=device,
-    )
-    test.assertAlmostEqual(out_t.numpy()[0], 1.0, delta=1e-5)
-
-    # Box
-    size = wp.vec3(1.0, 1.0, 1.0)  # half-extents
-    wp.launch(
-        kernel_test_geom,
-        dim=1,
-        inputs=[out_t, geom_to_world, size, GeoType.BOX, ray_origin, ray_direction, mesh_id],
-        device=device,
-    )
-    test.assertAlmostEqual(out_t.numpy()[0], 1.0, delta=1e-5)
-
-    # Capsule
-    size = wp.vec3(0.5, 1.0, 0.0)  # r, h
-    wp.launch(
-        kernel_test_geom,
-        dim=1,
-        inputs=[out_t, geom_to_world, size, GeoType.CAPSULE, ray_origin, ray_direction, mesh_id],
-        device=device,
-    )
-    test.assertAlmostEqual(out_t.numpy()[0], 1.5, delta=1e-5)
-
-    # Cylinder
-    size = wp.vec3(0.5, 1.0, 0.0)  # r, h
-    wp.launch(
-        kernel_test_geom,
-        dim=1,
-        inputs=[out_t, geom_to_world, size, GeoType.CYLINDER, ray_origin, ray_direction, mesh_id],
-        device=device,
-    )
-    test.assertAlmostEqual(out_t.numpy()[0], 1.5, delta=1e-5)
-
-    # Cone
-    size = wp.vec3(1.0, 1.0, 0.0)  # r, h
-    wp.launch(
-        kernel_test_geom,
-        dim=1,
-        inputs=[out_t, geom_to_world, size, GeoType.CONE, ray_origin, ray_direction, mesh_id],
-        device=device,
-    )
-    test.assertAlmostEqual(out_t.numpy()[0], 1.5, delta=1e-3)
+    with test.subTest("plane"):
+        size = wp.vec3(0.0, 0.0, 0.0)
+        ray_origin_plane = wp.vec3(0.0, 0.0, 5.0)
+        ray_direction_plane = wp.vec3(0.0, 0.0, -1.0)
+        wp.launch(
+            kernel_test_geom,
+            dim=1,
+            inputs=[out_t, geom_to_world, size, GeoType.PLANE, ray_origin_plane, ray_direction_plane, mesh_id],
+            device=device,
+        )
+        test.assertAlmostEqual(out_t.numpy()[0], 5.0, delta=1e-5)
+
+    with test.subTest("sphere"):
+        size = wp.vec3(1.0, 0.0, 0.0)  # r
+        wp.launch(
+            kernel_test_geom,
+            dim=1,
+            inputs=[out_t, geom_to_world, size, GeoType.SPHERE, ray_origin, ray_direction, mesh_id],
+            device=device,
+        )
+        test.assertAlmostEqual(out_t.numpy()[0], 1.0, delta=1e-5)
+
+    with test.subTest("box"):
+        size = wp.vec3(1.0, 1.0, 1.0)  # half-extents
+        wp.launch(
+            kernel_test_geom,
+            dim=1,
+            inputs=[out_t, geom_to_world, size, GeoType.BOX, ray_origin, ray_direction, mesh_id],
+            device=device,
+        )
+        test.assertAlmostEqual(out_t.numpy()[0], 1.0, delta=1e-5)
+
+    with test.subTest("capsule"):
+        size = wp.vec3(0.5, 1.0, 0.0)  # r, h
+        wp.launch(
+            kernel_test_geom,
+            dim=1,
+            inputs=[out_t, geom_to_world, size, GeoType.CAPSULE, ray_origin, ray_direction, mesh_id],
+            device=device,
+        )
+        test.assertAlmostEqual(out_t.numpy()[0], 1.5, delta=1e-5)
+
+    with test.subTest("cylinder"):
+        size = wp.vec3(0.5, 1.0, 0.0)  # r, h
+        wp.launch(
+            kernel_test_geom,
+            dim=1,
+            inputs=[out_t, geom_to_world, size, GeoType.CYLINDER, ray_origin, ray_direction, mesh_id],
+            device=device,
+        )
+        test.assertAlmostEqual(out_t.numpy()[0], 1.5, delta=1e-5)
+
+    with test.subTest("cone"):
+        size = wp.vec3(1.0, 1.0, 0.0)  # r, h
+        wp.launch(
+            kernel_test_geom,
+            dim=1,
+            inputs=[out_t, geom_to_world, size, GeoType.CONE, ray_origin, ray_direction, mesh_id],
+            device=device,
+        )
+        test.assertAlmostEqual(out_t.numpy()[0], 1.5, delta=1e-3)
+
+    with test.subTest("ellipsoid"):
+        size = wp.vec3(1.0, 0.5, 0.5)  # semi-axes (rx, ry, rz)
+        wp.launch(
+            kernel_test_geom,
+            dim=1,
+            inputs=[out_t, geom_to_world, size, GeoType.ELLIPSOID, ray_origin, ray_direction, mesh_id],
+            device=device,
+        )
+        test.assertAlmostEqual(out_t.numpy()[0], 1.0, delta=1e-5)
 
 
 def test_ray_intersect_mesh(test: TestRaycast, device: str):
@@ -470,11 +667,13 @@ def test_convex_hull_ray_intersect_via_geom(test: TestRaycast, device: str):
 
 
 devices = get_test_devices()
+add_function_test(TestRaycast, "test_ray_intersect_plane", test_ray_intersect_plane, devices=devices)
 add_function_test(TestRaycast, "test_ray_intersect_sphere", test_ray_intersect_sphere, devices=devices)
 add_function_test(TestRaycast, "test_ray_intersect_box", test_ray_intersect_box, devices=devices)
 add_function_test(TestRaycast, "test_ray_intersect_capsule", test_ray_intersect_capsule, devices=devices)
 add_function_test(TestRaycast, "test_ray_intersect_cylinder", test_ray_intersect_cylinder, devices=devices)
 add_function_test(TestRaycast, "test_ray_intersect_cone", test_ray_intersect_cone, devices=devices)
+add_function_test(TestRaycast, "test_ray_intersect_ellipsoid", test_ray_intersect_ellipsoid, devices=devices)
 add_function_test(TestRaycast, "test_geom_ray_intersect", test_geom_ray_intersect, devices=devices)
 add_function_test(TestRaycast, "test_ray_intersect_mesh", test_ray_intersect_mesh, devices=devices)
 add_function_test(TestRaycast, "test_mesh_ray_intersect_via_geom", test_mesh_ray_intersect_via_geom, devices=devices)
diff --git a/newton/tests/test_remesh.py b/newton/tests/test_remesh.py
index 46a89999dc..0c51947b99 100644
--- a/newton/tests/test_remesh.py
+++ b/newton/tests/test_remesh.py
@@ -513,7 +513,6 @@ def accumulate_test_point(
                 grid.counts,
             ],
         )
-        wp.synchronize()
 
         self.assertEqual(grid.get_num_voxels(), 1)
 
@@ -606,7 +605,6 @@ def accumulate_points(
                 grid.counts,
             ],
         )
-        wp.synchronize()
 
         # All points should fall in the same voxel (voxel_size=1.0, all coords in [0,1))
         self.assertEqual(grid.get_num_voxels(), 1)
@@ -703,7 +701,6 @@ def accumulate_points(
                 grid.counts,
             ],
         )
-        wp.synchronize()
 
         # Should have 3 separate voxels
         self.assertEqual(grid.get_num_voxels(), 3)
@@ -746,7 +743,6 @@ def add_point(
                 grid.counts,
             ],
         )
-        wp.synchronize()
 
         self.assertEqual(grid.get_num_voxels(), 1)
 
@@ -832,7 +828,6 @@ def accumulate_points(
                 grid.counts,
             ],
         )
-        wp.synchronize()
 
         # Should have 3 separate voxels
         self.assertEqual(grid.get_num_voxels(), 3)
@@ -935,7 +930,6 @@ def accumulate_points(
                 grid.counts,
             ],
         )
-        wp.synchronize()
 
         # Points at 0.0 and 0.099 should be in one voxel, 0.1 in another
         # So we expect 2 voxels
diff --git a/newton/tests/test_sensor_raycast.py b/newton/tests/test_sensor_raycast.py
index 1a4b01ecb9..273124f7bc 100644
--- a/newton/tests/test_sensor_raycast.py
+++ b/newton/tests/test_sensor_raycast.py
@@ -393,6 +393,69 @@ def test_sensor_raycast_single_pixel_hit(test: unittest.TestCase, device):
     test.assertTrue(np.all(depth_image[no_hit_mask] < 0.0), "Non-target pixels should report no hit (-1).")
 
 
+def test_sensor_raycast_ground_plane(test: unittest.TestCase, device: str):
+    """Test that SensorRaycast detects the ground plane."""
+    builder = newton.ModelBuilder(up_axis=newton.Axis.Z)
+    builder.add_ground_plane()
+
+    with wp.ScopedDevice(device):
+        model = builder.finalize()
+
+    state = model.state()
+
+    # Camera at z=5 looking straight down -- should see ground at z=0
+    sensor = SensorRaycast(
+        model=model,
+        camera_position=(0.0, 0.0, 5.0),
+        camera_direction=(0.0, 0.0, -1.0),
+        camera_up=(0.0, 1.0, 0.0),
+        fov_radians=0.5,
+        width=8,
+        height=8,
+        max_distance=100.0,
+    )
+
+    sensor.update(state)
+    depth = sensor.get_depth_image_numpy()
+
+    # Every pixel should hit the infinite ground plane
+    test.assertTrue(np.all(depth > 0.0), "All pixels should hit the ground plane")
+    # Center pixel should be at distance 5.0
+    test.assertAlmostEqual(float(depth[4, 4]), 5.0, delta=0.1)
+
+
+def test_sensor_raycast_ellipsoid(test: unittest.TestCase, device: str):
+    """Test that SensorRaycast detects an ellipsoid shape."""
+    builder = newton.ModelBuilder(up_axis=newton.Axis.Z)
+    body = builder.add_body(xform=wp.transform(wp.vec3(0.0, 0.0, 5.0), wp.quat_identity()))
+    builder.add_shape_ellipsoid(body=body, rx=1.5, ry=1.0, rz=0.8)
+
+    with wp.ScopedDevice(device):
+        model = builder.finalize()
+
+    state = model.state()
+    newton.eval_fk(model, state.joint_q, state.joint_qd, state)
+
+    # Camera at origin looking +Z toward the ellipsoid
+    sensor = SensorRaycast(
+        model=model,
+        camera_position=(0.0, 0.0, 0.0),
+        camera_direction=(0.0, 0.0, 1.0),
+        camera_up=(0.0, 1.0, 0.0),
+        fov_radians=0.1,
+        width=1,
+        height=1,
+        max_distance=20.0,
+    )
+
+    sensor.update(state)
+    depth = sensor.get_depth_image_numpy()
+
+    test.assertEqual(depth.shape, (1, 1))
+    # Ray along +Z hits ellipsoid at z = 5.0 - rz = 4.2
+    test.assertAlmostEqual(float(depth[0, 0]), 4.2, delta=1e-3)
+
+
 class TestSensorRaycast(unittest.TestCase):
     pass
 
@@ -400,6 +463,12 @@ class TestSensorRaycast(unittest.TestCase):
 # Register test for all available devices
 devices = get_test_devices()
 add_function_test(TestSensorRaycast, "test_sensor_raycast_cubemap", test_sensor_raycast_cubemap, devices=devices)
+add_function_test(
+    TestSensorRaycast,
+    "test_sensor_raycast_ground_plane",
+    test_sensor_raycast_ground_plane,
+    devices=devices,
+)
 add_function_test(
     TestSensorRaycast,
     "test_sensor_raycast_particles_hit",
@@ -442,6 +511,12 @@ class TestSensorRaycast(unittest.TestCase):
     test_sensor_raycast_single_pixel_hit,
     devices=devices,
 )
+add_function_test(
+    TestSensorRaycast,
+    "test_sensor_raycast_ellipsoid",
+    test_sensor_raycast_ellipsoid,
+    devices=devices,
+)
 
 
 if __name__ == "__main__":
diff --git a/newton/tests/test_solver_xpbd.py b/newton/tests/test_solver_xpbd.py
index fc61732c0d..8e8a309789 100644
--- a/newton/tests/test_solver_xpbd.py
+++ b/newton/tests/test_solver_xpbd.py
@@ -466,6 +466,333 @@ def test_articulation_contact_drift(test, device):
     )
 
 
+def _test_xpbd_contact_force_sphere_on_plane(test, device, radius, density):
+    """A sphere resting on a ground plane must report contact force equal to its weight."""
+    mass = density * (4.0 / 3.0) * np.pi * radius**3
+    gravity = 9.81
+
+    builder = newton.ModelBuilder()
+    builder.default_shape_cfg.density = density
+    builder.add_ground_plane()
+    body = builder.add_body(xform=wp.transform(wp.vec3(0.0, 0.0, radius), wp.quat_identity()))
+    builder.add_shape_sphere(body=body, radius=radius)
+    model = builder.finalize(device=device)
+    model.request_contact_attributes("force")
+
+    solver = newton.solvers.SolverXPBD(model, iterations=32)
+    state_in = model.state()
+    state_out = model.state()
+    control = model.control()
+    contacts = model.contacts()
+    newton.eval_fk(model, model.joint_q, model.joint_qd, state_in)
+
+    dt = 1.0 / 60.0
+    num_substeps = 8
+    sub_dt = dt / num_substeps
+    settle_steps = 120
+    avg_steps = 60
+
+    for _ in range(settle_steps):
+        for _ in range(num_substeps):
+            state_in.clear_forces()
+            model.collide(state_in, contacts)
+            solver.step(state_in, state_out, control, contacts, sub_dt)
+            state_in, state_out = state_out, state_in
+
+    force_acc = np.zeros(3)
+    for _ in range(avg_steps):
+        for _ in range(num_substeps):
+            state_in.clear_forces()
+            model.collide(state_in, contacts)
+            solver.step(state_in, state_out, control, contacts, sub_dt)
+            state_in, state_out = state_out, state_in
+        solver.update_contacts(contacts, state_in)
+        ncontacts = int(contacts.rigid_contact_count.numpy()[0])
+        if ncontacts > 0:
+            f = contacts.force.numpy()[:ncontacts, :3]
+            force_acc += np.sum(f, axis=0)
+
+    avg_force = force_acc / avg_steps
+    expected_fz = mass * gravity
+    np.testing.assert_allclose(avg_force[2], -expected_fz, rtol=0.05, err_msg="Vertical contact force should match -mg")
+    np.testing.assert_allclose(avg_force[0], 0.0, atol=0.5, err_msg="Horizontal X force should be ~0")
+    np.testing.assert_allclose(avg_force[1], 0.0, atol=0.5, err_msg="Horizontal Y force should be ~0")
+
+
+def test_xpbd_contact_force_sphere_on_plane(test, device):
+    _test_xpbd_contact_force_sphere_on_plane(test, device, radius=0.25, density=1000.0)
+
+
+def test_xpbd_contact_force_heavy_sphere_on_plane(test, device):
+    _test_xpbd_contact_force_sphere_on_plane(test, device, radius=0.5, density=2000.0)
+
+
+def test_xpbd_contact_force_box_on_plane(test, device):
+    """A box on a ground plane has multiple contact points; total force must equal mg, not N*mg.
+
+    This specifically tests the fix for the N*contact force inflation bug when
+    ``rigid_contact_con_weighting`` is enabled (the default).  A box generates 4
+    bottom-face contacts, so without the fix the summed force would be ~4x the
+    true weight.
+    """
+    hx, hy, hz = 0.5, 0.5, 0.5
+    density = 1000.0
+    volume = (2.0 * hx) * (2.0 * hy) * (2.0 * hz)
+    mass = density * volume
+    gravity = 9.81
+
+    builder = newton.ModelBuilder()
+    builder.default_shape_cfg.density = density
+    builder.add_ground_plane()
+    body = builder.add_body(xform=wp.transform(wp.vec3(0.0, 0.0, hz), wp.quat_identity()))
+    builder.add_shape_box(body=body, hx=hx, hy=hy, hz=hz)
+    model = builder.finalize(device=device)
+    model.request_contact_attributes("force")
+
+    solver = newton.solvers.SolverXPBD(model, iterations=32, rigid_contact_con_weighting=True)
+    state_in = model.state()
+    state_out = model.state()
+    control = model.control()
+    contacts = model.contacts()
+    newton.eval_fk(model, model.joint_q, model.joint_qd, state_in)
+
+    dt = 1.0 / 60.0
+    num_substeps = 8
+    sub_dt = dt / num_substeps
+    settle_steps = 120
+    avg_steps = 60
+
+    for _ in range(settle_steps):
+        for _ in range(num_substeps):
+            state_in.clear_forces()
+            model.collide(state_in, contacts)
+            solver.step(state_in, state_out, control, contacts, sub_dt)
+            state_in, state_out = state_out, state_in
+
+    force_acc = np.zeros(3)
+    for _ in range(avg_steps):
+        for _ in range(num_substeps):
+            state_in.clear_forces()
+            model.collide(state_in, contacts)
+            solver.step(state_in, state_out, control, contacts, sub_dt)
+            state_in, state_out = state_out, state_in
+        solver.update_contacts(contacts, state_in)
+        ncontacts = int(contacts.rigid_contact_count.numpy()[0])
+        test.assertGreater(ncontacts, 1, "Box should generate multiple contact points")
+        if ncontacts > 0:
+            f = contacts.force.numpy()[:ncontacts, :3]
+            force_acc += np.sum(f, axis=0)
+
+    avg_force = force_acc / avg_steps
+    expected_fz = mass * gravity
+    np.testing.assert_allclose(
+        avg_force[2],
+        -expected_fz,
+        rtol=0.10,
+        err_msg="Total vertical contact force over multiple contacts should match -mg, not N*mg",
+    )
+    np.testing.assert_allclose(avg_force[0], 0.0, atol=1.0, err_msg="Horizontal X force should be ~0")
+    np.testing.assert_allclose(avg_force[1], 0.0, atol=1.0, err_msg="Horizontal Y force should be ~0")
+
+
+def test_xpbd_contact_force_mini_pyramid(test, device):
+    """Two-layer pyramid: ground reaction forces must reflect stacked weight.
+
+    Layout (Z-up):
+        - Ground plane at z=0 (shape 0, body -1)
+        - Two bottom cubes (bodies 0, 1) side-by-side on the ground
+        - One top cube (body 2) centered on top of both
+
+    All cubes have the same mass m.  At steady state the ground pushes up on
+    each bottom cube with 1.5*mg (own weight + half the top cube).
+
+    Only ground-contact forces are checked here.  Inter-body forces between
+    dynamic bodies are under-reported by the per-body contact weighting
+    scheme (``rigid_contact_con_weighting``) because a body's weight mixes
+    contacts from different pairs.
+    """
+    h = 0.5
+    density = 1000.0
+    volume = (2.0 * h) ** 3
+    mass = density * volume
+    gravity = 9.81
+    mg = mass * gravity
+
+    builder = newton.ModelBuilder()
+    builder.default_shape_cfg.density = density
+    builder.add_ground_plane()
+
+    b0 = builder.add_body(xform=wp.transform(wp.vec3(-h, 0.0, h), wp.quat_identity()))
+    builder.add_shape_box(body=b0, hx=h, hy=h, hz=h)
+    b1 = builder.add_body(xform=wp.transform(wp.vec3(h, 0.0, h), wp.quat_identity()))
+    builder.add_shape_box(body=b1, hx=h, hy=h, hz=h)
+    b2 = builder.add_body(xform=wp.transform(wp.vec3(0.0, 0.0, 3.0 * h), wp.quat_identity()))
+    builder.add_shape_box(body=b2, hx=h, hy=h, hz=h)
+
+    model = builder.finalize(device=device)
+    model.request_contact_attributes("force")
+
+    solver = newton.solvers.SolverXPBD(model, iterations=32, rigid_contact_con_weighting=True)
+    state_in = model.state()
+    state_out = model.state()
+    control = model.control()
+    contacts = model.contacts()
+    newton.eval_fk(model, model.joint_q, model.joint_qd, state_in)
+
+    dt = 1.0 / 60.0
+    num_substeps = 8
+    sub_dt = dt / num_substeps
+    settle_steps = 200
+    avg_steps = 60
+
+    for _ in range(settle_steps):
+        for _ in range(num_substeps):
+            state_in.clear_forces()
+            model.collide(state_in, contacts)
+            solver.step(state_in, state_out, control, contacts, sub_dt)
+            state_in, state_out = state_out, state_in
+
+    shape_body_np = model.shape_body.numpy()
+    ground_shape = 0
+
+    ground_fz_on_b0 = 0.0
+    ground_fz_on_b1 = 0.0
+
+    for _ in range(avg_steps):
+        for _ in range(num_substeps):
+            state_in.clear_forces()
+            model.collide(state_in, contacts)
+            solver.step(state_in, state_out, control, contacts, sub_dt)
+            state_in, state_out = state_out, state_in
+        solver.update_contacts(contacts, state_in)
+
+        nc = int(contacts.rigid_contact_count.numpy()[0])
+        if nc == 0:
+            continue
+        forces = contacts.force.numpy()[:nc, :3]
+        s0 = contacts.rigid_contact_shape0.numpy()[:nc]
+        s1 = contacts.rigid_contact_shape1.numpy()[:nc]
+        for ci in range(nc):
+            if s0[ci] != ground_shape:
+                continue
+            fz = forces[ci, 2]
+            body_b = shape_body_np[s1[ci]] if s1[ci] >= 0 else -1
+            if body_b == b0:
+                ground_fz_on_b0 += -fz
+            elif body_b == b1:
+                ground_fz_on_b1 += -fz
+
+    ground_fz_on_b0 /= avg_steps
+    ground_fz_on_b1 /= avg_steps
+
+    np.testing.assert_allclose(
+        ground_fz_on_b0,
+        1.5 * mg,
+        rtol=0.15,
+        err_msg=f"Ground reaction on bottom cube 0 should be ~1.5*mg={1.5 * mg:.0f}, got {ground_fz_on_b0:.0f}",
+    )
+    np.testing.assert_allclose(
+        ground_fz_on_b1,
+        1.5 * mg,
+        rtol=0.15,
+        err_msg=f"Ground reaction on bottom cube 1 should be ~1.5*mg={1.5 * mg:.0f}, got {ground_fz_on_b1:.0f}",
+    )
+
+
+def test_xpbd_contact_force_zero_when_no_contact(test, device):
+    """A sphere in free-fall (no ground) should produce zero contact force."""
+    radius = 0.25
+
+    builder = newton.ModelBuilder()
+    body = builder.add_body(xform=wp.transform(wp.vec3(0.0, 0.0, 5.0), wp.quat_identity()))
+    builder.add_shape_sphere(body=body, radius=radius)
+    model = builder.finalize(device=device)
+    model.request_contact_attributes("force")
+
+    solver = newton.solvers.SolverXPBD(model, iterations=2)
+    state_in = model.state()
+    state_out = model.state()
+    control = model.control()
+    contacts = model.contacts()
+    newton.eval_fk(model, model.joint_q, model.joint_qd, state_in)
+
+    dt = 1.0 / 60.0
+    state_in.clear_forces()
+    model.collide(state_in, contacts)
+    solver.step(state_in, state_out, control, contacts, dt)
+    solver.update_contacts(contacts, state_out)
+
+    ncontacts = int(contacts.rigid_contact_count.numpy()[0])
+    if ncontacts > 0:
+        forces = contacts.force.numpy()[:ncontacts]
+        np.testing.assert_allclose(forces, 0.0, atol=1e-6, err_msg="No contact force expected in free-fall")
+
+
+def test_xpbd_contact_force_zero_when_not_touching(test, device):
+    """A sphere near a ground plane with a large gap: contact pair exists but force is zero."""
+    radius = 0.25
+    gap = 1.0
+    # Place sphere so it's within the gap (contact pair generated) but not penetrating.
+    # Ground is at z=0, sphere center at z = radius + 0.5*gap (well above surface).
+    z = radius + 0.5 * gap
+
+    builder = newton.ModelBuilder()
+    builder.default_shape_cfg.gap = gap
+    builder.add_ground_plane()
+    body = builder.add_body(xform=wp.transform(wp.vec3(0.0, 0.0, z), wp.quat_identity()))
+    builder.add_shape_sphere(body=body, radius=radius)
+    model = builder.finalize(device=device)
+    model.set_gravity(wp.vec3(0.0, 0.0, 0.0))
+    model.request_contact_attributes("force")
+
+    solver = newton.solvers.SolverXPBD(model, iterations=2)
+    state_in = model.state()
+    state_out = model.state()
+    control = model.control()
+    contacts = model.contacts()
+    newton.eval_fk(model, model.joint_q, model.joint_qd, state_in)
+
+    state_in.clear_forces()
+    model.collide(state_in, contacts)
+
+    ncontacts = int(contacts.rigid_contact_count.numpy()[0])
+    test.assertGreater(ncontacts, 0, "Gap should cause a contact pair to be generated")
+
+    solver.step(state_in, state_out, control, contacts, 1.0 / 60.0)
+    solver.update_contacts(contacts, state_out)
+
+    forces = contacts.force.numpy()[:ncontacts, :3]
+    np.testing.assert_allclose(
+        forces,
+        0.0,
+        atol=1e-6,
+        err_msg="Contact pair within gap but not touching should report zero force",
+    )
+
+
+def test_xpbd_update_contacts_requires_force_attribute(test, device):
+    """update_contacts should raise ValueError when contacts.force is not allocated."""
+    builder = newton.ModelBuilder()
+    builder.add_ground_plane()
+    body = builder.add_body(xform=wp.transform(wp.vec3(0.0, 0.0, 0.25), wp.quat_identity()))
+    builder.add_shape_sphere(body=body, radius=0.25)
+    model = builder.finalize(device=device)
+
+    solver = newton.solvers.SolverXPBD(model, iterations=2)
+    state_in = model.state()
+    state_out = model.state()
+    control = model.control()
+    contacts = model.contacts()
+
+    state_in.clear_forces()
+    model.collide(state_in, contacts)
+    solver.step(state_in, state_out, control, contacts, 1.0 / 60.0)
+
+    test.assertIsNone(contacts.force)
+    with test.assertRaises(ValueError):
+        solver.update_contacts(contacts)
+
+
 devices = get_test_devices(mode="basic")
 
 
@@ -515,6 +842,62 @@ class TestSolverXPBD(unittest.TestCase):
     check_output=False,
 )
 
+add_function_test(
+    TestSolverXPBD,
+    "test_xpbd_contact_force_sphere_on_plane",
+    test_xpbd_contact_force_sphere_on_plane,
+    devices=devices,
+    check_output=False,
+)
+
+add_function_test(
+    TestSolverXPBD,
+    "test_xpbd_contact_force_heavy_sphere_on_plane",
+    test_xpbd_contact_force_heavy_sphere_on_plane,
+    devices=devices,
+    check_output=False,
+)
+
+add_function_test(
+    TestSolverXPBD,
+    "test_xpbd_contact_force_box_on_plane",
+    test_xpbd_contact_force_box_on_plane,
+    devices=devices,
+    check_output=False,
+)
+
+add_function_test(
+    TestSolverXPBD,
+    "test_xpbd_contact_force_mini_pyramid",
+    test_xpbd_contact_force_mini_pyramid,
+    devices=devices,
+    check_output=False,
+)
+
+add_function_test(
+    TestSolverXPBD,
+    "test_xpbd_contact_force_zero_when_no_contact",
+    test_xpbd_contact_force_zero_when_no_contact,
+    devices=devices,
+    check_output=False,
+)
+
+add_function_test(
+    TestSolverXPBD,
+    "test_xpbd_contact_force_zero_when_not_touching",
+    test_xpbd_contact_force_zero_when_not_touching,
+    devices=devices,
+    check_output=False,
+)
+
+add_function_test(
+    TestSolverXPBD,
+    "test_xpbd_update_contacts_requires_force_attribute",
+    test_xpbd_update_contacts_requires_force_attribute,
+    devices=devices,
+    check_output=False,
+)
+
 
 if __name__ == "__main__":
     unittest.main(verbosity=2, failfast=True)
diff --git a/newton/tests/test_viewer_picking.py b/newton/tests/test_viewer_picking.py
index bba9793da2..fab0f85ffb 100644
--- a/newton/tests/test_viewer_picking.py
+++ b/newton/tests/test_viewer_picking.py
@@ -174,7 +174,6 @@ def test_apply_picking_force_when_not_picking(self):
 
         state.body_f.zero_()
         picking._apply_picking_force(state)
-        wp.synchronize()
 
         # No body picked -> no force applied
         forces = state.body_f.numpy()
@@ -233,7 +232,6 @@ def test_picking_setup_device(test: TestPickingSetup, device):
     # update and apply_force should not crash
     picking.update(ray_start, ray_dir)
     picking._apply_picking_force(state)
-    wp.synchronize()
 
     picking.release()
     test.assertFalse(picking.is_picking())
diff --git a/uv.lock b/uv.lock
index 7a55756b1b..b6caffcdc3 100644
--- a/uv.lock
+++ b/uv.lock
@@ -3841,100 +3841,100 @@ wheels = [
 
 [[package]]
 name = "pillow"
-version = "12.1.1"
-source = { registry = "https://pypi.org/simple" }
-sdist = { url = "https://files.pythonhosted.org/packages/1f/42/5c74462b4fd957fcd7b13b04fb3205ff8349236ea74c7c375766d6c82288/pillow-12.1.1.tar.gz", hash = "sha256:9ad8fa5937ab05218e2b6a4cff30295ad35afd2f83ac592e68c0d871bb0fdbc4", size = 46980264, upload-time = "2026-02-11T04:23:07.146Z" }
-wheels = [
-    { url = "https://files.pythonhosted.org/packages/1d/30/5bd3d794762481f8c8ae9c80e7b76ecea73b916959eb587521358ef0b2f9/pillow-12.1.1-cp310-cp310-macosx_10_10_x86_64.whl", hash = "sha256:1f1625b72740fdda5d77b4def688eb8fd6490975d06b909fd19f13f391e077e0", size = 5304099, upload-time = "2026-02-11T04:20:06.13Z" },
-    { url = "https://files.pythonhosted.org/packages/bd/c1/aab9e8f3eeb4490180e357955e15c2ef74b31f64790ff356c06fb6cf6d84/pillow-12.1.1-cp310-cp310-macosx_11_0_arm64.whl", hash = "sha256:178aa072084bd88ec759052feca8e56cbb14a60b39322b99a049e58090479713", size = 4657880, upload-time = "2026-02-11T04:20:09.291Z" },
-    { url = "https://files.pythonhosted.org/packages/f1/0a/9879e30d56815ad529d3985aeff5af4964202425c27261a6ada10f7cbf53/pillow-12.1.1-cp310-cp310-manylinux2014_aarch64.manylinux_2_17_aarch64.whl", hash = "sha256:b66e95d05ba806247aaa1561f080abc7975daf715c30780ff92a20e4ec546e1b", size = 6222587, upload-time = "2026-02-11T04:20:10.82Z" },
-    { url = "https://files.pythonhosted.org/packages/5a/5f/a1b72ff7139e4f89014e8d451442c74a774d5c43cd938fb0a9f878576b37/pillow-12.1.1-cp310-cp310-manylinux2014_x86_64.manylinux_2_17_x86_64.whl", hash = "sha256:89c7e895002bbe49cdc5426150377cbbc04767d7547ed145473f496dfa40408b", size = 8027678, upload-time = "2026-02-11T04:20:12.455Z" },
-    { url = "https://files.pythonhosted.org/packages/e2/c2/c7cb187dac79a3d22c3ebeae727abee01e077c8c7d930791dc592f335153/pillow-12.1.1-cp310-cp310-manylinux_2_27_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:3a5cbdcddad0af3da87cb16b60d23648bc3b51967eb07223e9fed77a82b457c4", size = 6335777, upload-time = "2026-02-11T04:20:14.441Z" },
-    { url = "https://files.pythonhosted.org/packages/0c/7b/f9b09a7804ec7336effb96c26d37c29d27225783dc1501b7d62dcef6ae25/pillow-12.1.1-cp310-cp310-manylinux_2_27_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:9f51079765661884a486727f0729d29054242f74b46186026582b4e4769918e4", size = 7027140, upload-time = "2026-02-11T04:20:16.387Z" },
-    { url = "https://files.pythonhosted.org/packages/98/b2/2fa3c391550bd421b10849d1a2144c44abcd966daadd2f7c12e19ea988c4/pillow-12.1.1-cp310-cp310-musllinux_1_2_aarch64.whl", hash = "sha256:99c1506ea77c11531d75e3a412832a13a71c7ebc8192ab9e4b2e355555920e3e", size = 6449855, upload-time = "2026-02-11T04:20:18.554Z" },
-    { url = "https://files.pythonhosted.org/packages/96/ff/9caf4b5b950c669263c39e96c78c0d74a342c71c4f43fd031bb5cb7ceac9/pillow-12.1.1-cp310-cp310-musllinux_1_2_x86_64.whl", hash = "sha256:36341d06738a9f66c8287cf8b876d24b18db9bd8740fa0672c74e259ad408cff", size = 7151329, upload-time = "2026-02-11T04:20:20.646Z" },
-    { url = "https://files.pythonhosted.org/packages/7b/f8/4b24841f582704da675ca535935bccb32b00a6da1226820845fac4a71136/pillow-12.1.1-cp310-cp310-win32.whl", hash = "sha256:6c52f062424c523d6c4db85518774cc3d50f5539dd6eed32b8f6229b26f24d40", size = 6325574, upload-time = "2026-02-11T04:20:22.43Z" },
-    { url = "https://files.pythonhosted.org/packages/f8/f9/9f6b01c0881d7036063aa6612ef04c0e2cad96be21325a1e92d0203f8e91/pillow-12.1.1-cp310-cp310-win_amd64.whl", hash = "sha256:c6008de247150668a705a6338156efb92334113421ceecf7438a12c9a12dab23", size = 7032347, upload-time = "2026-02-11T04:20:23.932Z" },
-    { url = "https://files.pythonhosted.org/packages/79/13/c7922edded3dcdaf10c59297540b72785620abc0538872c819915746757d/pillow-12.1.1-cp310-cp310-win_arm64.whl", hash = "sha256:1a9b0ee305220b392e1124a764ee4265bd063e54a751a6b62eff69992f457fa9", size = 2453457, upload-time = "2026-02-11T04:20:25.392Z" },
-    { url = "https://files.pythonhosted.org/packages/2b/46/5da1ec4a5171ee7bf1a0efa064aba70ba3d6e0788ce3f5acd1375d23c8c0/pillow-12.1.1-cp311-cp311-macosx_10_10_x86_64.whl", hash = "sha256:e879bb6cd5c73848ef3b2b48b8af9ff08c5b71ecda8048b7dd22d8a33f60be32", size = 5304084, upload-time = "2026-02-11T04:20:27.501Z" },
-    { url = "https://files.pythonhosted.org/packages/78/93/a29e9bc02d1cf557a834da780ceccd54e02421627200696fcf805ebdc3fb/pillow-12.1.1-cp311-cp311-macosx_11_0_arm64.whl", hash = "sha256:365b10bb9417dd4498c0e3b128018c4a624dc11c7b97d8cc54effe3b096f4c38", size = 4657866, upload-time = "2026-02-11T04:20:29.827Z" },
-    { url = "https://files.pythonhosted.org/packages/13/84/583a4558d492a179d31e4aae32eadce94b9acf49c0337c4ce0b70e0a01f2/pillow-12.1.1-cp311-cp311-manylinux2014_aarch64.manylinux_2_17_aarch64.whl", hash = "sha256:d4ce8e329c93845720cd2014659ca67eac35f6433fd3050393d85f3ecef0dad5", size = 6232148, upload-time = "2026-02-11T04:20:31.329Z" },
-    { url = "https://files.pythonhosted.org/packages/d5/e2/53c43334bbbb2d3b938978532fbda8e62bb6e0b23a26ce8592f36bcc4987/pillow-12.1.1-cp311-cp311-manylinux2014_x86_64.manylinux_2_17_x86_64.whl", hash = "sha256:fc354a04072b765eccf2204f588a7a532c9511e8b9c7f900e1b64e3e33487090", size = 8038007, upload-time = "2026-02-11T04:20:34.225Z" },
-    { url = "https://files.pythonhosted.org/packages/b8/a6/3d0e79c8a9d58150dd98e199d7c1c56861027f3829a3a60b3c2784190180/pillow-12.1.1-cp311-cp311-manylinux_2_27_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:7e7976bf1910a8116b523b9f9f58bf410f3e8aa330cd9a2bb2953f9266ab49af", size = 6345418, upload-time = "2026-02-11T04:20:35.858Z" },
-    { url = "https://files.pythonhosted.org/packages/a2/c8/46dfeac5825e600579157eea177be43e2f7ff4a99da9d0d0a49533509ac5/pillow-12.1.1-cp311-cp311-manylinux_2_27_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:597bd9c8419bc7c6af5604e55847789b69123bbe25d65cc6ad3012b4f3c98d8b", size = 7034590, upload-time = "2026-02-11T04:20:37.91Z" },
-    { url = "https://files.pythonhosted.org/packages/af/bf/e6f65d3db8a8bbfeaf9e13cc0417813f6319863a73de934f14b2229ada18/pillow-12.1.1-cp311-cp311-musllinux_1_2_aarch64.whl", hash = "sha256:2c1fc0f2ca5f96a3c8407e41cca26a16e46b21060fe6d5b099d2cb01412222f5", size = 6458655, upload-time = "2026-02-11T04:20:39.496Z" },
-    { url = "https://files.pythonhosted.org/packages/f9/c2/66091f3f34a25894ca129362e510b956ef26f8fb67a0e6417bc5744e56f1/pillow-12.1.1-cp311-cp311-musllinux_1_2_x86_64.whl", hash = "sha256:578510d88c6229d735855e1f278aa305270438d36a05031dfaae5067cc8eb04d", size = 7159286, upload-time = "2026-02-11T04:20:41.139Z" },
-    { url = "https://files.pythonhosted.org/packages/7b/5a/24bc8eb526a22f957d0cec6243146744966d40857e3d8deb68f7902ca6c1/pillow-12.1.1-cp311-cp311-win32.whl", hash = "sha256:7311c0a0dcadb89b36b7025dfd8326ecfa36964e29913074d47382706e516a7c", size = 6328663, upload-time = "2026-02-11T04:20:43.184Z" },
-    { url = "https://files.pythonhosted.org/packages/31/03/bef822e4f2d8f9d7448c133d0a18185d3cce3e70472774fffefe8b0ed562/pillow-12.1.1-cp311-cp311-win_amd64.whl", hash = "sha256:fbfa2a7c10cc2623f412753cddf391c7f971c52ca40a3f65dc5039b2939e8563", size = 7031448, upload-time = "2026-02-11T04:20:44.696Z" },
-    { url = "https://files.pythonhosted.org/packages/49/70/f76296f53610bd17b2e7d31728b8b7825e3ac3b5b3688b51f52eab7c0818/pillow-12.1.1-cp311-cp311-win_arm64.whl", hash = "sha256:b81b5e3511211631b3f672a595e3221252c90af017e399056d0faabb9538aa80", size = 2453651, upload-time = "2026-02-11T04:20:46.243Z" },
-    { url = "https://files.pythonhosted.org/packages/07/d3/8df65da0d4df36b094351dce696f2989bec731d4f10e743b1c5f4da4d3bf/pillow-12.1.1-cp312-cp312-macosx_10_13_x86_64.whl", hash = "sha256:ab323b787d6e18b3d91a72fc99b1a2c28651e4358749842b8f8dfacd28ef2052", size = 5262803, upload-time = "2026-02-11T04:20:47.653Z" },
-    { url = "https://files.pythonhosted.org/packages/d6/71/5026395b290ff404b836e636f51d7297e6c83beceaa87c592718747e670f/pillow-12.1.1-cp312-cp312-macosx_11_0_arm64.whl", hash = "sha256:adebb5bee0f0af4909c30db0d890c773d1a92ffe83da908e2e9e720f8edf3984", size = 4657601, upload-time = "2026-02-11T04:20:49.328Z" },
-    { url = "https://files.pythonhosted.org/packages/b1/2e/1001613d941c67442f745aff0f7cc66dd8df9a9c084eb497e6a543ee6f7e/pillow-12.1.1-cp312-cp312-manylinux2014_aarch64.manylinux_2_17_aarch64.whl", hash = "sha256:bb66b7cc26f50977108790e2456b7921e773f23db5630261102233eb355a3b79", size = 6234995, upload-time = "2026-02-11T04:20:51.032Z" },
-    { url = "https://files.pythonhosted.org/packages/07/26/246ab11455b2549b9233dbd44d358d033a2f780fa9007b61a913c5b2d24e/pillow-12.1.1-cp312-cp312-manylinux2014_x86_64.manylinux_2_17_x86_64.whl", hash = "sha256:aee2810642b2898bb187ced9b349e95d2a7272930796e022efaf12e99dccd293", size = 8045012, upload-time = "2026-02-11T04:20:52.882Z" },
-    { url = "https://files.pythonhosted.org/packages/b2/8b/07587069c27be7535ac1fe33874e32de118fbd34e2a73b7f83436a88368c/pillow-12.1.1-cp312-cp312-manylinux_2_27_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:a0b1cd6232e2b618adcc54d9882e4e662a089d5768cd188f7c245b4c8c44a397", size = 6349638, upload-time = "2026-02-11T04:20:54.444Z" },
-    { url = "https://files.pythonhosted.org/packages/ff/79/6df7b2ee763d619cda2fb4fea498e5f79d984dae304d45a8999b80d6cf5c/pillow-12.1.1-cp312-cp312-manylinux_2_27_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:7aac39bcf8d4770d089588a2e1dd111cbaa42df5a94be3114222057d68336bd0", size = 7041540, upload-time = "2026-02-11T04:20:55.97Z" },
-    { url = "https://files.pythonhosted.org/packages/2c/5e/2ba19e7e7236d7529f4d873bdaf317a318896bac289abebd4bb00ef247f0/pillow-12.1.1-cp312-cp312-musllinux_1_2_aarch64.whl", hash = "sha256:ab174cd7d29a62dd139c44bf74b698039328f45cb03b4596c43473a46656b2f3", size = 6462613, upload-time = "2026-02-11T04:20:57.542Z" },
-    { url = "https://files.pythonhosted.org/packages/03/03/31216ec124bb5c3dacd74ce8efff4cc7f52643653bad4825f8f08c697743/pillow-12.1.1-cp312-cp312-musllinux_1_2_x86_64.whl", hash = "sha256:339ffdcb7cbeaa08221cd401d517d4b1fe7a9ed5d400e4a8039719238620ca35", size = 7166745, upload-time = "2026-02-11T04:20:59.196Z" },
-    { url = "https://files.pythonhosted.org/packages/1f/e7/7c4552d80052337eb28653b617eafdef39adfb137c49dd7e831b8dc13bc5/pillow-12.1.1-cp312-cp312-win32.whl", hash = "sha256:5d1f9575a12bed9e9eedd9a4972834b08c97a352bd17955ccdebfeca5913fa0a", size = 6328823, upload-time = "2026-02-11T04:21:01.385Z" },
-    { url = "https://files.pythonhosted.org/packages/3d/17/688626d192d7261bbbf98846fc98995726bddc2c945344b65bec3a29d731/pillow-12.1.1-cp312-cp312-win_amd64.whl", hash = "sha256:21329ec8c96c6e979cd0dfd29406c40c1d52521a90544463057d2aaa937d66a6", size = 7033367, upload-time = "2026-02-11T04:21:03.536Z" },
-    { url = "https://files.pythonhosted.org/packages/ed/fe/a0ef1f73f939b0eca03ee2c108d0043a87468664770612602c63266a43c4/pillow-12.1.1-cp312-cp312-win_arm64.whl", hash = "sha256:af9a332e572978f0218686636610555ae3defd1633597be015ed50289a03c523", size = 2453811, upload-time = "2026-02-11T04:21:05.116Z" },
-    { url = "https://files.pythonhosted.org/packages/d5/11/6db24d4bd7685583caeae54b7009584e38da3c3d4488ed4cd25b439de486/pillow-12.1.1-cp313-cp313-ios_13_0_arm64_iphoneos.whl", hash = "sha256:d242e8ac078781f1de88bf823d70c1a9b3c7950a44cdf4b7c012e22ccbcd8e4e", size = 4062689, upload-time = "2026-02-11T04:21:06.804Z" },
-    { url = "https://files.pythonhosted.org/packages/33/c0/ce6d3b1fe190f0021203e0d9b5b99e57843e345f15f9ef22fcd43842fd21/pillow-12.1.1-cp313-cp313-ios_13_0_arm64_iphonesimulator.whl", hash = "sha256:02f84dfad02693676692746df05b89cf25597560db2857363a208e393429f5e9", size = 4138535, upload-time = "2026-02-11T04:21:08.452Z" },
-    { url = "https://files.pythonhosted.org/packages/a0/c6/d5eb6a4fb32a3f9c21a8c7613ec706534ea1cf9f4b3663e99f0d83f6fca8/pillow-12.1.1-cp313-cp313-ios_13_0_x86_64_iphonesimulator.whl", hash = "sha256:e65498daf4b583091ccbb2556c7000abf0f3349fcd57ef7adc9a84a394ed29f6", size = 3601364, upload-time = "2026-02-11T04:21:10.194Z" },
-    { url = "https://files.pythonhosted.org/packages/14/a1/16c4b823838ba4c9c52c0e6bbda903a3fe5a1bdbf1b8eb4fff7156f3e318/pillow-12.1.1-cp313-cp313-macosx_10_13_x86_64.whl", hash = "sha256:6c6db3b84c87d48d0088943bf33440e0c42370b99b1c2a7989216f7b42eede60", size = 5262561, upload-time = "2026-02-11T04:21:11.742Z" },
-    { url = "https://files.pythonhosted.org/packages/bb/ad/ad9dc98ff24f485008aa5cdedaf1a219876f6f6c42a4626c08bc4e80b120/pillow-12.1.1-cp313-cp313-macosx_11_0_arm64.whl", hash = "sha256:8b7e5304e34942bf62e15184219a7b5ad4ff7f3bb5cca4d984f37df1a0e1aee2", size = 4657460, upload-time = "2026-02-11T04:21:13.786Z" },
-    { url = "https://files.pythonhosted.org/packages/9e/1b/f1a4ea9a895b5732152789326202a82464d5254759fbacae4deea3069334/pillow-12.1.1-cp313-cp313-manylinux2014_aarch64.manylinux_2_17_aarch64.whl", hash = "sha256:18e5bddd742a44b7e6b1e773ab5db102bd7a94c32555ba656e76d319d19c3850", size = 6232698, upload-time = "2026-02-11T04:21:15.949Z" },
-    { url = "https://files.pythonhosted.org/packages/95/f4/86f51b8745070daf21fd2e5b1fe0eb35d4db9ca26e6d58366562fb56a743/pillow-12.1.1-cp313-cp313-manylinux2014_x86_64.manylinux_2_17_x86_64.whl", hash = "sha256:fc44ef1f3de4f45b50ccf9136999d71abb99dca7706bc75d222ed350b9fd2289", size = 8041706, upload-time = "2026-02-11T04:21:17.723Z" },
-    { url = "https://files.pythonhosted.org/packages/29/9b/d6ecd956bb1266dd1045e995cce9b8d77759e740953a1c9aad9502a0461e/pillow-12.1.1-cp313-cp313-manylinux_2_27_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:5a8eb7ed8d4198bccbd07058416eeec51686b498e784eda166395a23eb99138e", size = 6346621, upload-time = "2026-02-11T04:21:19.547Z" },
-    { url = "https://files.pythonhosted.org/packages/71/24/538bff45bde96535d7d998c6fed1a751c75ac7c53c37c90dc2601b243893/pillow-12.1.1-cp313-cp313-manylinux_2_27_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:47b94983da0c642de92ced1702c5b6c292a84bd3a8e1d1702ff923f183594717", size = 7038069, upload-time = "2026-02-11T04:21:21.378Z" },
-    { url = "https://files.pythonhosted.org/packages/94/0e/58cb1a6bc48f746bc4cb3adb8cabff73e2742c92b3bf7a220b7cf69b9177/pillow-12.1.1-cp313-cp313-musllinux_1_2_aarch64.whl", hash = "sha256:518a48c2aab7ce596d3bf79d0e275661b846e86e4d0e7dec34712c30fe07f02a", size = 6460040, upload-time = "2026-02-11T04:21:23.148Z" },
-    { url = "https://files.pythonhosted.org/packages/6c/57/9045cb3ff11eeb6c1adce3b2d60d7d299d7b273a2e6c8381a524abfdc474/pillow-12.1.1-cp313-cp313-musllinux_1_2_x86_64.whl", hash = "sha256:a550ae29b95c6dc13cf69e2c9dc5747f814c54eeb2e32d683e5e93af56caa029", size = 7164523, upload-time = "2026-02-11T04:21:25.01Z" },
-    { url = "https://files.pythonhosted.org/packages/73/f2/9be9cb99f2175f0d4dbadd6616ce1bf068ee54a28277ea1bf1fbf729c250/pillow-12.1.1-cp313-cp313-win32.whl", hash = "sha256:a003d7422449f6d1e3a34e3dd4110c22148336918ddbfc6a32581cd54b2e0b2b", size = 6332552, upload-time = "2026-02-11T04:21:27.238Z" },
-    { url = "https://files.pythonhosted.org/packages/3f/eb/b0834ad8b583d7d9d42b80becff092082a1c3c156bb582590fcc973f1c7c/pillow-12.1.1-cp313-cp313-win_amd64.whl", hash = "sha256:344cf1e3dab3be4b1fa08e449323d98a2a3f819ad20f4b22e77a0ede31f0faa1", size = 7040108, upload-time = "2026-02-11T04:21:29.462Z" },
-    { url = "https://files.pythonhosted.org/packages/d5/7d/fc09634e2aabdd0feabaff4a32f4a7d97789223e7c2042fd805ea4b4d2c2/pillow-12.1.1-cp313-cp313-win_arm64.whl", hash = "sha256:5c0dd1636633e7e6a0afe7bf6a51a14992b7f8e60de5789018ebbdfae55b040a", size = 2453712, upload-time = "2026-02-11T04:21:31.072Z" },
-    { url = "https://files.pythonhosted.org/packages/19/2a/b9d62794fc8a0dd14c1943df68347badbd5511103e0d04c035ffe5cf2255/pillow-12.1.1-cp313-cp313t-macosx_10_13_x86_64.whl", hash = "sha256:0330d233c1a0ead844fc097a7d16c0abff4c12e856c0b325f231820fee1f39da", size = 5264880, upload-time = "2026-02-11T04:21:32.865Z" },
-    { url = "https://files.pythonhosted.org/packages/26/9d/e03d857d1347fa5ed9247e123fcd2a97b6220e15e9cb73ca0a8d91702c6e/pillow-12.1.1-cp313-cp313t-macosx_11_0_arm64.whl", hash = "sha256:5dae5f21afb91322f2ff791895ddd8889e5e947ff59f71b46041c8ce6db790bc", size = 4660616, upload-time = "2026-02-11T04:21:34.97Z" },
-    { url = "https://files.pythonhosted.org/packages/f7/ec/8a6d22afd02570d30954e043f09c32772bfe143ba9285e2fdb11284952cd/pillow-12.1.1-cp313-cp313t-manylinux2014_aarch64.manylinux_2_17_aarch64.whl", hash = "sha256:2e0c664be47252947d870ac0d327fea7e63985a08794758aa8af5b6cb6ec0c9c", size = 6269008, upload-time = "2026-02-11T04:21:36.623Z" },
-    { url = "https://files.pythonhosted.org/packages/3d/1d/6d875422c9f28a4a361f495a5f68d9de4a66941dc2c619103ca335fa6446/pillow-12.1.1-cp313-cp313t-manylinux2014_x86_64.manylinux_2_17_x86_64.whl", hash = "sha256:691ab2ac363b8217f7d31b3497108fb1f50faab2f75dfb03284ec2f217e87bf8", size = 8073226, upload-time = "2026-02-11T04:21:38.585Z" },
-    { url = "https://files.pythonhosted.org/packages/a1/cd/134b0b6ee5eda6dc09e25e24b40fdafe11a520bc725c1d0bbaa5e00bf95b/pillow-12.1.1-cp313-cp313t-manylinux_2_27_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:e9e8064fb1cc019296958595f6db671fba95209e3ceb0c4734c9baf97de04b20", size = 6380136, upload-time = "2026-02-11T04:21:40.562Z" },
-    { url = "https://files.pythonhosted.org/packages/7a/a9/7628f013f18f001c1b98d8fffe3452f306a70dc6aba7d931019e0492f45e/pillow-12.1.1-cp313-cp313t-manylinux_2_27_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:472a8d7ded663e6162dafdf20015c486a7009483ca671cece7a9279b512fcb13", size = 7067129, upload-time = "2026-02-11T04:21:42.521Z" },
-    { url = "https://files.pythonhosted.org/packages/1e/f8/66ab30a2193b277785601e82ee2d49f68ea575d9637e5e234faaa98efa4c/pillow-12.1.1-cp313-cp313t-musllinux_1_2_aarch64.whl", hash = "sha256:89b54027a766529136a06cfebeecb3a04900397a3590fd252160b888479517bf", size = 6491807, upload-time = "2026-02-11T04:21:44.22Z" },
-    { url = "https://files.pythonhosted.org/packages/da/0b/a877a6627dc8318fdb84e357c5e1a758c0941ab1ddffdafd231983788579/pillow-12.1.1-cp313-cp313t-musllinux_1_2_x86_64.whl", hash = "sha256:86172b0831b82ce4f7877f280055892b31179e1576aa00d0df3bb1bbf8c3e524", size = 7190954, upload-time = "2026-02-11T04:21:46.114Z" },
-    { url = "https://files.pythonhosted.org/packages/83/43/6f732ff85743cf746b1361b91665d9f5155e1483817f693f8d57ea93147f/pillow-12.1.1-cp313-cp313t-win32.whl", hash = "sha256:44ce27545b6efcf0fdbdceb31c9a5bdea9333e664cda58a7e674bb74608b3986", size = 6336441, upload-time = "2026-02-11T04:21:48.22Z" },
-    { url = "https://files.pythonhosted.org/packages/3b/44/e865ef3986611bb75bfabdf94a590016ea327833f434558801122979cd0e/pillow-12.1.1-cp313-cp313t-win_amd64.whl", hash = "sha256:a285e3eb7a5a45a2ff504e31f4a8d1b12ef62e84e5411c6804a42197c1cf586c", size = 7045383, upload-time = "2026-02-11T04:21:50.015Z" },
-    { url = "https://files.pythonhosted.org/packages/a8/c6/f4fb24268d0c6908b9f04143697ea18b0379490cb74ba9e8d41b898bd005/pillow-12.1.1-cp313-cp313t-win_arm64.whl", hash = "sha256:cc7d296b5ea4d29e6570dabeaed58d31c3fea35a633a69679fb03d7664f43fb3", size = 2456104, upload-time = "2026-02-11T04:21:51.633Z" },
-    { url = "https://files.pythonhosted.org/packages/03/d0/bebb3ffbf31c5a8e97241476c4cf8b9828954693ce6744b4a2326af3e16b/pillow-12.1.1-cp314-cp314-ios_13_0_arm64_iphoneos.whl", hash = "sha256:417423db963cb4be8bac3fc1204fe61610f6abeed1580a7a2cbb2fbda20f12af", size = 4062652, upload-time = "2026-02-11T04:21:53.19Z" },
-    { url = "https://files.pythonhosted.org/packages/2d/c0/0e16fb0addda4851445c28f8350d8c512f09de27bbb0d6d0bbf8b6709605/pillow-12.1.1-cp314-cp314-ios_13_0_arm64_iphonesimulator.whl", hash = "sha256:b957b71c6b2387610f556a7eb0828afbe40b4a98036fc0d2acfa5a44a0c2036f", size = 4138823, upload-time = "2026-02-11T04:22:03.088Z" },
-    { url = "https://files.pythonhosted.org/packages/6b/fb/6170ec655d6f6bb6630a013dd7cf7bc218423d7b5fa9071bf63dc32175ae/pillow-12.1.1-cp314-cp314-ios_13_0_x86_64_iphonesimulator.whl", hash = "sha256:097690ba1f2efdeb165a20469d59d8bb03c55fb6621eb2041a060ae8ea3e9642", size = 3601143, upload-time = "2026-02-11T04:22:04.909Z" },
-    { url = "https://files.pythonhosted.org/packages/59/04/dc5c3f297510ba9a6837cbb318b87dd2b8f73eb41a43cc63767f65cb599c/pillow-12.1.1-cp314-cp314-macosx_10_15_x86_64.whl", hash = "sha256:2815a87ab27848db0321fb78c7f0b2c8649dee134b7f2b80c6a45c6831d75ccd", size = 5266254, upload-time = "2026-02-11T04:22:07.656Z" },
-    { url = "https://files.pythonhosted.org/packages/05/30/5db1236b0d6313f03ebf97f5e17cda9ca060f524b2fcc875149a8360b21c/pillow-12.1.1-cp314-cp314-macosx_11_0_arm64.whl", hash = "sha256:f7ed2c6543bad5a7d5530eb9e78c53132f93dfa44a28492db88b41cdab885202", size = 4657499, upload-time = "2026-02-11T04:22:09.613Z" },
-    { url = "https://files.pythonhosted.org/packages/6f/18/008d2ca0eb612e81968e8be0bbae5051efba24d52debf930126d7eaacbba/pillow-12.1.1-cp314-cp314-manylinux2014_aarch64.manylinux_2_17_aarch64.whl", hash = "sha256:652a2c9ccfb556235b2b501a3a7cf3742148cd22e04b5625c5fe057ea3e3191f", size = 6232137, upload-time = "2026-02-11T04:22:11.434Z" },
-    { url = "https://files.pythonhosted.org/packages/70/f1/f14d5b8eeb4b2cd62b9f9f847eb6605f103df89ef619ac68f92f748614ea/pillow-12.1.1-cp314-cp314-manylinux2014_x86_64.manylinux_2_17_x86_64.whl", hash = "sha256:d6e4571eedf43af33d0fc233a382a76e849badbccdf1ac438841308652a08e1f", size = 8042721, upload-time = "2026-02-11T04:22:13.321Z" },
-    { url = "https://files.pythonhosted.org/packages/5a/d6/17824509146e4babbdabf04d8171491fa9d776f7061ff6e727522df9bd03/pillow-12.1.1-cp314-cp314-manylinux_2_27_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:b574c51cf7d5d62e9be37ba446224b59a2da26dc4c1bb2ecbe936a4fb1a7cb7f", size = 6347798, upload-time = "2026-02-11T04:22:15.449Z" },
-    { url = "https://files.pythonhosted.org/packages/d1/ee/c85a38a9ab92037a75615aba572c85ea51e605265036e00c5b67dfafbfe2/pillow-12.1.1-cp314-cp314-manylinux_2_27_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:a37691702ed687799de29a518d63d4682d9016932db66d4e90c345831b02fb4e", size = 7039315, upload-time = "2026-02-11T04:22:17.24Z" },
-    { url = "https://files.pythonhosted.org/packages/ec/f3/bc8ccc6e08a148290d7523bde4d9a0d6c981db34631390dc6e6ec34cacf6/pillow-12.1.1-cp314-cp314-musllinux_1_2_aarch64.whl", hash = "sha256:f95c00d5d6700b2b890479664a06e754974848afaae5e21beb4d83c106923fd0", size = 6462360, upload-time = "2026-02-11T04:22:19.111Z" },
-    { url = "https://files.pythonhosted.org/packages/f6/ab/69a42656adb1d0665ab051eec58a41f169ad295cf81ad45406963105408f/pillow-12.1.1-cp314-cp314-musllinux_1_2_x86_64.whl", hash = "sha256:559b38da23606e68681337ad74622c4dbba02254fc9cb4488a305dd5975c7eeb", size = 7165438, upload-time = "2026-02-11T04:22:21.041Z" },
-    { url = "https://files.pythonhosted.org/packages/02/46/81f7aa8941873f0f01d4b55cc543b0a3d03ec2ee30d617a0448bf6bd6dec/pillow-12.1.1-cp314-cp314-win32.whl", hash = "sha256:03edcc34d688572014ff223c125a3f77fb08091e4607e7745002fc214070b35f", size = 6431503, upload-time = "2026-02-11T04:22:22.833Z" },
-    { url = "https://files.pythonhosted.org/packages/40/72/4c245f7d1044b67affc7f134a09ea619d4895333d35322b775b928180044/pillow-12.1.1-cp314-cp314-win_amd64.whl", hash = "sha256:50480dcd74fa63b8e78235957d302d98d98d82ccbfac4c7e12108ba9ecbdba15", size = 7176748, upload-time = "2026-02-11T04:22:24.64Z" },
-    { url = "https://files.pythonhosted.org/packages/e4/ad/8a87bdbe038c5c698736e3348af5c2194ffb872ea52f11894c95f9305435/pillow-12.1.1-cp314-cp314-win_arm64.whl", hash = "sha256:5cb1785d97b0c3d1d1a16bc1d710c4a0049daefc4935f3a8f31f827f4d3d2e7f", size = 2544314, upload-time = "2026-02-11T04:22:26.685Z" },
-    { url = "https://files.pythonhosted.org/packages/6c/9d/efd18493f9de13b87ede7c47e69184b9e859e4427225ea962e32e56a49bc/pillow-12.1.1-cp314-cp314t-macosx_10_15_x86_64.whl", hash = "sha256:1f90cff8aa76835cba5769f0b3121a22bd4eb9e6884cfe338216e557a9a548b8", size = 5268612, upload-time = "2026-02-11T04:22:29.884Z" },
-    { url = "https://files.pythonhosted.org/packages/f8/f1/4f42eb2b388eb2ffc660dcb7f7b556c1015c53ebd5f7f754965ef997585b/pillow-12.1.1-cp314-cp314t-macosx_11_0_arm64.whl", hash = "sha256:1f1be78ce9466a7ee64bfda57bdba0f7cc499d9794d518b854816c41bf0aa4e9", size = 4660567, upload-time = "2026-02-11T04:22:31.799Z" },
-    { url = "https://files.pythonhosted.org/packages/01/54/df6ef130fa43e4b82e32624a7b821a2be1c5653a5fdad8469687a7db4e00/pillow-12.1.1-cp314-cp314t-manylinux2014_aarch64.manylinux_2_17_aarch64.whl", hash = "sha256:42fc1f4677106188ad9a55562bbade416f8b55456f522430fadab3cef7cd4e60", size = 6269951, upload-time = "2026-02-11T04:22:33.921Z" },
-    { url = "https://files.pythonhosted.org/packages/a9/48/618752d06cc44bb4aae8ce0cd4e6426871929ed7b46215638088270d9b34/pillow-12.1.1-cp314-cp314t-manylinux2014_x86_64.manylinux_2_17_x86_64.whl", hash = "sha256:98edb152429ab62a1818039744d8fbb3ccab98a7c29fc3d5fcef158f3f1f68b7", size = 8074769, upload-time = "2026-02-11T04:22:35.877Z" },
-    { url = "https://files.pythonhosted.org/packages/c3/bd/f1d71eb39a72fa088d938655afba3e00b38018d052752f435838961127d8/pillow-12.1.1-cp314-cp314t-manylinux_2_27_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:d470ab1178551dd17fdba0fef463359c41aaa613cdcd7ff8373f54be629f9f8f", size = 6381358, upload-time = "2026-02-11T04:22:37.698Z" },
-    { url = "https://files.pythonhosted.org/packages/64/ef/c784e20b96674ed36a5af839305f55616f8b4f8aa8eeccf8531a6e312243/pillow-12.1.1-cp314-cp314t-manylinux_2_27_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:6408a7b064595afcab0a49393a413732a35788f2a5092fdc6266952ed67de586", size = 7068558, upload-time = "2026-02-11T04:22:39.597Z" },
-    { url = "https://files.pythonhosted.org/packages/73/cb/8059688b74422ae61278202c4e1ad992e8a2e7375227be0a21c6b87ca8d5/pillow-12.1.1-cp314-cp314t-musllinux_1_2_aarch64.whl", hash = "sha256:5d8c41325b382c07799a3682c1c258469ea2ff97103c53717b7893862d0c98ce", size = 6493028, upload-time = "2026-02-11T04:22:42.73Z" },
-    { url = "https://files.pythonhosted.org/packages/c6/da/e3c008ed7d2dd1f905b15949325934510b9d1931e5df999bb15972756818/pillow-12.1.1-cp314-cp314t-musllinux_1_2_x86_64.whl", hash = "sha256:c7697918b5be27424e9ce568193efd13d925c4481dd364e43f5dff72d33e10f8", size = 7191940, upload-time = "2026-02-11T04:22:44.543Z" },
-    { url = "https://files.pythonhosted.org/packages/01/4a/9202e8d11714c1fc5951f2e1ef362f2d7fbc595e1f6717971d5dd750e969/pillow-12.1.1-cp314-cp314t-win32.whl", hash = "sha256:d2912fd8114fc5545aa3a4b5576512f64c55a03f3ebcca4c10194d593d43ea36", size = 6438736, upload-time = "2026-02-11T04:22:46.347Z" },
-    { url = "https://files.pythonhosted.org/packages/f3/ca/cbce2327eb9885476b3957b2e82eb12c866a8b16ad77392864ad601022ce/pillow-12.1.1-cp314-cp314t-win_amd64.whl", hash = "sha256:4ceb838d4bd9dab43e06c363cab2eebf63846d6a4aeaea283bbdfd8f1a8ed58b", size = 7182894, upload-time = "2026-02-11T04:22:48.114Z" },
-    { url = "https://files.pythonhosted.org/packages/ec/d2/de599c95ba0a973b94410477f8bf0b6f0b5e67360eb89bcb1ad365258beb/pillow-12.1.1-cp314-cp314t-win_arm64.whl", hash = "sha256:7b03048319bfc6170e93bd60728a1af51d3dd7704935feb228c4d4faab35d334", size = 2546446, upload-time = "2026-02-11T04:22:50.342Z" },
-    { url = "https://files.pythonhosted.org/packages/56/11/5d43209aa4cb58e0cc80127956ff1796a68b928e6324bbf06ef4db34367b/pillow-12.1.1-pp311-pypy311_pp73-macosx_10_15_x86_64.whl", hash = "sha256:600fd103672b925fe62ed08e0d874ea34d692474df6f4bf7ebe148b30f89f39f", size = 5228606, upload-time = "2026-02-11T04:22:52.106Z" },
-    { url = "https://files.pythonhosted.org/packages/5f/d5/3b005b4e4fda6698b371fa6c21b097d4707585d7db99e98d9b0b87ac612a/pillow-12.1.1-pp311-pypy311_pp73-macosx_11_0_arm64.whl", hash = "sha256:665e1b916b043cef294bc54d47bf02d87e13f769bc4bc5fa225a24b3a6c5aca9", size = 4622321, upload-time = "2026-02-11T04:22:53.827Z" },
-    { url = "https://files.pythonhosted.org/packages/df/36/ed3ea2d594356fd8037e5a01f6156c74bc8d92dbb0fa60746cc96cabb6e8/pillow-12.1.1-pp311-pypy311_pp73-manylinux2014_aarch64.manylinux_2_17_aarch64.whl", hash = "sha256:495c302af3aad1ca67420ddd5c7bd480c8867ad173528767d906428057a11f0e", size = 5247579, upload-time = "2026-02-11T04:22:56.094Z" },
-    { url = "https://files.pythonhosted.org/packages/54/9a/9cc3e029683cf6d20ae5085da0dafc63148e3252c2f13328e553aaa13cfb/pillow-12.1.1-pp311-pypy311_pp73-manylinux2014_x86_64.manylinux_2_17_x86_64.whl", hash = "sha256:8fd420ef0c52c88b5a035a0886f367748c72147b2b8f384c9d12656678dfdfa9", size = 6989094, upload-time = "2026-02-11T04:22:58.288Z" },
-    { url = "https://files.pythonhosted.org/packages/00/98/fc53ab36da80b88df0967896b6c4b4cd948a0dc5aa40a754266aa3ae48b3/pillow-12.1.1-pp311-pypy311_pp73-manylinux_2_27_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:f975aa7ef9684ce7e2c18a3aa8f8e2106ce1e46b94ab713d156b2898811651d3", size = 5313850, upload-time = "2026-02-11T04:23:00.554Z" },
-    { url = "https://files.pythonhosted.org/packages/30/02/00fa585abfd9fe9d73e5f6e554dc36cc2b842898cbfc46d70353dae227f8/pillow-12.1.1-pp311-pypy311_pp73-manylinux_2_27_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:8089c852a56c2966cf18835db62d9b34fef7ba74c726ad943928d494fa7f4735", size = 5963343, upload-time = "2026-02-11T04:23:02.934Z" },
-    { url = "https://files.pythonhosted.org/packages/f2/26/c56ce33ca856e358d27fda9676c055395abddb82c35ac0f593877ed4562e/pillow-12.1.1-pp311-pypy311_pp73-win_amd64.whl", hash = "sha256:cb9bb857b2d057c6dfc72ac5f3b44836924ba15721882ef103cecb40d002d80e", size = 7029880, upload-time = "2026-02-11T04:23:04.783Z" },
+version = "12.2.0"
+source = { registry = "https://pypi.org/simple" }
+sdist = { url = "https://files.pythonhosted.org/packages/8c/21/c2bcdd5906101a30244eaffc1b6e6ce71a31bd0742a01eb89e660ebfac2d/pillow-12.2.0.tar.gz", hash = "sha256:a830b1a40919539d07806aa58e1b114df53ddd43213d9c8b75847eee6c0182b5", size = 46987819, upload-time = "2026-04-01T14:46:17.687Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/3a/aa/d0b28e1c811cd4d5f5c2bfe2e022292bd255ae5744a3b9ac7d6c8f72dd75/pillow-12.2.0-cp310-cp310-macosx_10_10_x86_64.whl", hash = "sha256:a4e8f36e677d3336f35089648c8955c51c6d386a13cf6ee9c189c5f5bd713a9f", size = 5354355, upload-time = "2026-04-01T14:42:15.402Z" },
+    { url = "https://files.pythonhosted.org/packages/27/8e/1d5b39b8ae2bd7650d0c7b6abb9602d16043ead9ebbfef4bc4047454da2a/pillow-12.2.0-cp310-cp310-macosx_11_0_arm64.whl", hash = "sha256:2e589959f10d9824d39b350472b92f0ce3b443c0a3442ebf41c40cb8361c5b97", size = 4695871, upload-time = "2026-04-01T14:42:18.234Z" },
+    { url = "https://files.pythonhosted.org/packages/f0/c5/dcb7a6ca6b7d3be41a76958e90018d56c8462166b3ef223150360850c8da/pillow-12.2.0-cp310-cp310-manylinux2014_aarch64.manylinux_2_17_aarch64.whl", hash = "sha256:a52edc8bfff4429aaabdf4d9ee0daadbbf8562364f940937b941f87a4290f5ff", size = 6269734, upload-time = "2026-04-01T14:42:20.608Z" },
+    { url = "https://files.pythonhosted.org/packages/ea/f1/aa1bb13b2f4eba914e9637893c73f2af8e48d7d4023b9d3750d4c5eb2d0c/pillow-12.2.0-cp310-cp310-manylinux2014_x86_64.manylinux_2_17_x86_64.whl", hash = "sha256:975385f4776fafde056abb318f612ef6285b10a1f12b8570f3647ad0d74b48ec", size = 8076080, upload-time = "2026-04-01T14:42:23.095Z" },
+    { url = "https://files.pythonhosted.org/packages/a1/2a/8c79d6a53169937784604a8ae8d77e45888c41537f7f6f65ed1f407fe66d/pillow-12.2.0-cp310-cp310-manylinux_2_27_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:bd9c0c7a0c681a347b3194c500cb1e6ca9cab053ea4d82a5cf45b6b754560136", size = 6382236, upload-time = "2026-04-01T14:42:25.82Z" },
+    { url = "https://files.pythonhosted.org/packages/b5/42/bbcb6051030e1e421d103ce7a8ecadf837aa2f39b8f82ef1a8d37c3d4ebc/pillow-12.2.0-cp310-cp310-manylinux_2_27_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:88d387ff40b3ff7c274947ed3125dedf5262ec6919d83946753b5f3d7c67ea4c", size = 7070220, upload-time = "2026-04-01T14:42:28.68Z" },
+    { url = "https://files.pythonhosted.org/packages/3f/e1/c2a7d6dd8cfa6b231227da096fd2d58754bab3603b9d73bf609d3c18b64f/pillow-12.2.0-cp310-cp310-musllinux_1_2_aarch64.whl", hash = "sha256:51c4167c34b0d8ba05b547a3bb23578d0ba17b80a5593f93bd8ecb123dd336a3", size = 6493124, upload-time = "2026-04-01T14:42:31.579Z" },
+    { url = "https://files.pythonhosted.org/packages/5f/41/7c8617da5d32e1d2f026e509484fdb6f3ad7efaef1749a0c1928adbb099e/pillow-12.2.0-cp310-cp310-musllinux_1_2_x86_64.whl", hash = "sha256:34c0d99ecccea270c04882cb3b86e7b57296079c9a4aff88cb3b33563d95afaa", size = 7194324, upload-time = "2026-04-01T14:42:34.615Z" },
+    { url = "https://files.pythonhosted.org/packages/2d/de/a777627e19fd6d62f84070ee1521adde5eeda4855b5cf60fe0b149118bca/pillow-12.2.0-cp310-cp310-win32.whl", hash = "sha256:b85f66ae9eb53e860a873b858b789217ba505e5e405a24b85c0464822fe88032", size = 6376363, upload-time = "2026-04-01T14:42:37.19Z" },
+    { url = "https://files.pythonhosted.org/packages/e7/34/fc4cb5204896465842767b96d250c08410f01f2f28afc43b257de842eed5/pillow-12.2.0-cp310-cp310-win_amd64.whl", hash = "sha256:673aa32138f3e7531ccdbca7b3901dba9b70940a19ccecc6a37c77d5fdeb05b5", size = 7083523, upload-time = "2026-04-01T14:42:39.62Z" },
+    { url = "https://files.pythonhosted.org/packages/2d/a0/32852d36bc7709f14dc3f64f929a275e958ad8c19a6deba9610d458e28b3/pillow-12.2.0-cp310-cp310-win_arm64.whl", hash = "sha256:3e080565d8d7c671db5802eedfb438e5565ffa40115216eabb8cd52d0ecce024", size = 2463318, upload-time = "2026-04-01T14:42:42.063Z" },
+    { url = "https://files.pythonhosted.org/packages/68/e1/748f5663efe6edcfc4e74b2b93edfb9b8b99b67f21a854c3ae416500a2d9/pillow-12.2.0-cp311-cp311-macosx_10_10_x86_64.whl", hash = "sha256:8be29e59487a79f173507c30ddf57e733a357f67881430449bb32614075a40ab", size = 5354347, upload-time = "2026-04-01T14:42:44.255Z" },
+    { url = "https://files.pythonhosted.org/packages/47/a1/d5ff69e747374c33a3b53b9f98cca7889fce1fd03d79cdc4e1bccc6c5a87/pillow-12.2.0-cp311-cp311-macosx_11_0_arm64.whl", hash = "sha256:71cde9a1e1551df7d34a25462fc60325e8a11a82cc2e2f54578e5e9a1e153d65", size = 4695873, upload-time = "2026-04-01T14:42:46.452Z" },
+    { url = "https://files.pythonhosted.org/packages/df/21/e3fbdf54408a973c7f7f89a23b2cb97a7ef30c61ab4142af31eee6aebc88/pillow-12.2.0-cp311-cp311-manylinux2014_aarch64.manylinux_2_17_aarch64.whl", hash = "sha256:f490f9368b6fc026f021db16d7ec2fbf7d89e2edb42e8ec09d2c60505f5729c7", size = 6280168, upload-time = "2026-04-01T14:42:49.228Z" },
+    { url = "https://files.pythonhosted.org/packages/d3/f1/00b7278c7dd52b17ad4329153748f87b6756ec195ff786c2bdf12518337d/pillow-12.2.0-cp311-cp311-manylinux2014_x86_64.manylinux_2_17_x86_64.whl", hash = "sha256:8bd7903a5f2a4545f6fd5935c90058b89d30045568985a71c79f5fd6edf9b91e", size = 8088188, upload-time = "2026-04-01T14:42:51.735Z" },
+    { url = "https://files.pythonhosted.org/packages/ad/cf/220a5994ef1b10e70e85748b75649d77d506499352be135a4989c957b701/pillow-12.2.0-cp311-cp311-manylinux_2_27_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:3997232e10d2920a68d25191392e3a4487d8183039e1c74c2297f00ed1c50705", size = 6394401, upload-time = "2026-04-01T14:42:54.343Z" },
+    { url = "https://files.pythonhosted.org/packages/e9/bd/e51a61b1054f09437acfbc2ff9106c30d1eb76bc1453d428399946781253/pillow-12.2.0-cp311-cp311-manylinux_2_27_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:e74473c875d78b8e9d5da2a70f7099549f9eb37ded4e2f6a463e60125bccd176", size = 7079655, upload-time = "2026-04-01T14:42:56.954Z" },
+    { url = "https://files.pythonhosted.org/packages/6b/3d/45132c57d5fb4b5744567c3817026480ac7fc3ce5d4c47902bc0e7f6f853/pillow-12.2.0-cp311-cp311-musllinux_1_2_aarch64.whl", hash = "sha256:56a3f9c60a13133a98ecff6197af34d7824de9b7b38c3654861a725c970c197b", size = 6503105, upload-time = "2026-04-01T14:42:59.847Z" },
+    { url = "https://files.pythonhosted.org/packages/7d/2e/9df2fc1e82097b1df3dce58dc43286aa01068e918c07574711fcc53e6fb4/pillow-12.2.0-cp311-cp311-musllinux_1_2_x86_64.whl", hash = "sha256:90e6f81de50ad6b534cab6e5aef77ff6e37722b2f5d908686f4a5c9eba17a909", size = 7203402, upload-time = "2026-04-01T14:43:02.664Z" },
+    { url = "https://files.pythonhosted.org/packages/bd/2e/2941e42858ebb67e50ae741473de81c2984e6eff7b397017623c676e2e8d/pillow-12.2.0-cp311-cp311-win32.whl", hash = "sha256:8c984051042858021a54926eb597d6ee3012393ce9c181814115df4c60b9a808", size = 6378149, upload-time = "2026-04-01T14:43:05.274Z" },
+    { url = "https://files.pythonhosted.org/packages/69/42/836b6f3cd7f3e5fa10a1f1a5420447c17966044c8fbf589cc0452d5502db/pillow-12.2.0-cp311-cp311-win_amd64.whl", hash = "sha256:6e6b2a0c538fc200b38ff9eb6628228b77908c319a005815f2dde585a0664b60", size = 7082626, upload-time = "2026-04-01T14:43:08.557Z" },
+    { url = "https://files.pythonhosted.org/packages/c2/88/549194b5d6f1f494b485e493edc6693c0a16f4ada488e5bd974ed1f42fad/pillow-12.2.0-cp311-cp311-win_arm64.whl", hash = "sha256:9a8a34cc89c67a65ea7437ce257cea81a9dad65b29805f3ecee8c8fe8ff25ffe", size = 2463531, upload-time = "2026-04-01T14:43:10.743Z" },
+    { url = "https://files.pythonhosted.org/packages/58/be/7482c8a5ebebbc6470b3eb791812fff7d5e0216c2be3827b30b8bb6603ed/pillow-12.2.0-cp312-cp312-macosx_10_13_x86_64.whl", hash = "sha256:2d192a155bbcec180f8564f693e6fd9bccff5a7af9b32e2e4bf8c9c69dbad6b5", size = 5308279, upload-time = "2026-04-01T14:43:13.246Z" },
+    { url = "https://files.pythonhosted.org/packages/d8/95/0a351b9289c2b5cbde0bacd4a83ebc44023e835490a727b2a3bd60ddc0f4/pillow-12.2.0-cp312-cp312-macosx_11_0_arm64.whl", hash = "sha256:f3f40b3c5a968281fd507d519e444c35f0ff171237f4fdde090dd60699458421", size = 4695490, upload-time = "2026-04-01T14:43:15.584Z" },
+    { url = "https://files.pythonhosted.org/packages/de/af/4e8e6869cbed569d43c416fad3dc4ecb944cb5d9492defaed89ddd6fe871/pillow-12.2.0-cp312-cp312-manylinux2014_aarch64.manylinux_2_17_aarch64.whl", hash = "sha256:03e7e372d5240cc23e9f07deca4d775c0817bffc641b01e9c3af208dbd300987", size = 6284462, upload-time = "2026-04-01T14:43:18.268Z" },
+    { url = "https://files.pythonhosted.org/packages/e9/9e/c05e19657fd57841e476be1ab46c4d501bffbadbafdc31a6d665f8b737b6/pillow-12.2.0-cp312-cp312-manylinux2014_x86_64.manylinux_2_17_x86_64.whl", hash = "sha256:b86024e52a1b269467a802258c25521e6d742349d760728092e1bc2d135b4d76", size = 8094744, upload-time = "2026-04-01T14:43:20.716Z" },
+    { url = "https://files.pythonhosted.org/packages/2b/54/1789c455ed10176066b6e7e6da1b01e50e36f94ba584dc68d9eebfe9156d/pillow-12.2.0-cp312-cp312-manylinux_2_27_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:7371b48c4fa448d20d2714c9a1f775a81155050d383333e0a6c15b1123dda005", size = 6398371, upload-time = "2026-04-01T14:43:23.443Z" },
+    { url = "https://files.pythonhosted.org/packages/43/e3/fdc657359e919462369869f1c9f0e973f353f9a9ee295a39b1fea8ee1a77/pillow-12.2.0-cp312-cp312-manylinux_2_27_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:62f5409336adb0663b7caa0da5c7d9e7bdbaae9ce761d34669420c2a801b2780", size = 7087215, upload-time = "2026-04-01T14:43:26.758Z" },
+    { url = "https://files.pythonhosted.org/packages/8b/f8/2f6825e441d5b1959d2ca5adec984210f1ec086435b0ed5f52c19b3b8a6e/pillow-12.2.0-cp312-cp312-musllinux_1_2_aarch64.whl", hash = "sha256:01afa7cf67f74f09523699b4e88c73fb55c13346d212a59a2db1f86b0a63e8c5", size = 6509783, upload-time = "2026-04-01T14:43:29.56Z" },
+    { url = "https://files.pythonhosted.org/packages/67/f9/029a27095ad20f854f9dba026b3ea6428548316e057e6fc3545409e86651/pillow-12.2.0-cp312-cp312-musllinux_1_2_x86_64.whl", hash = "sha256:fc3d34d4a8fbec3e88a79b92e5465e0f9b842b628675850d860b8bd300b159f5", size = 7212112, upload-time = "2026-04-01T14:43:32.091Z" },
+    { url = "https://files.pythonhosted.org/packages/be/42/025cfe05d1be22dbfdb4f264fe9de1ccda83f66e4fc3aac94748e784af04/pillow-12.2.0-cp312-cp312-win32.whl", hash = "sha256:58f62cc0f00fd29e64b29f4fd923ffdb3859c9f9e6105bfc37ba1d08994e8940", size = 6378489, upload-time = "2026-04-01T14:43:34.601Z" },
+    { url = "https://files.pythonhosted.org/packages/5d/7b/25a221d2c761c6a8ae21bfa3874988ff2583e19cf8a27bf2fee358df7942/pillow-12.2.0-cp312-cp312-win_amd64.whl", hash = "sha256:7f84204dee22a783350679a0333981df803dac21a0190d706a50475e361c93f5", size = 7084129, upload-time = "2026-04-01T14:43:37.213Z" },
+    { url = "https://files.pythonhosted.org/packages/10/e1/542a474affab20fd4a0f1836cb234e8493519da6b76899e30bcc5d990b8b/pillow-12.2.0-cp312-cp312-win_arm64.whl", hash = "sha256:af73337013e0b3b46f175e79492d96845b16126ddf79c438d7ea7ff27783a414", size = 2463612, upload-time = "2026-04-01T14:43:39.421Z" },
+    { url = "https://files.pythonhosted.org/packages/4a/01/53d10cf0dbad820a8db274d259a37ba50b88b24768ddccec07355382d5ad/pillow-12.2.0-cp313-cp313-ios_13_0_arm64_iphoneos.whl", hash = "sha256:8297651f5b5679c19968abefd6bb84d95fe30ef712eb1b2d9b2d31ca61267f4c", size = 4100837, upload-time = "2026-04-01T14:43:41.506Z" },
+    { url = "https://files.pythonhosted.org/packages/0f/98/f3a6657ecb698c937f6c76ee564882945f29b79bad496abcba0e84659ec5/pillow-12.2.0-cp313-cp313-ios_13_0_arm64_iphonesimulator.whl", hash = "sha256:50d8520da2a6ce0af445fa6d648c4273c3eeefbc32d7ce049f22e8b5c3daecc2", size = 4176528, upload-time = "2026-04-01T14:43:43.773Z" },
+    { url = "https://files.pythonhosted.org/packages/69/bc/8986948f05e3ea490b8442ea1c1d4d990b24a7e43d8a51b2c7d8b1dced36/pillow-12.2.0-cp313-cp313-ios_13_0_x86_64_iphonesimulator.whl", hash = "sha256:766cef22385fa1091258ad7e6216792b156dc16d8d3fa607e7545b2b72061f1c", size = 3640401, upload-time = "2026-04-01T14:43:45.87Z" },
+    { url = "https://files.pythonhosted.org/packages/34/46/6c717baadcd62bc8ed51d238d521ab651eaa74838291bda1f86fe1f864c9/pillow-12.2.0-cp313-cp313-macosx_10_13_x86_64.whl", hash = "sha256:5d2fd0fa6b5d9d1de415060363433f28da8b1526c1c129020435e186794b3795", size = 5308094, upload-time = "2026-04-01T14:43:48.438Z" },
+    { url = "https://files.pythonhosted.org/packages/71/43/905a14a8b17fdb1ccb58d282454490662d2cb89a6bfec26af6d3520da5ec/pillow-12.2.0-cp313-cp313-macosx_11_0_arm64.whl", hash = "sha256:56b25336f502b6ed02e889f4ece894a72612fe885889a6e8c4c80239ff6e5f5f", size = 4695402, upload-time = "2026-04-01T14:43:51.292Z" },
+    { url = "https://files.pythonhosted.org/packages/73/dd/42107efcb777b16fa0393317eac58f5b5cf30e8392e266e76e51cff28c3d/pillow-12.2.0-cp313-cp313-manylinux2014_aarch64.manylinux_2_17_aarch64.whl", hash = "sha256:f1c943e96e85df3d3478f7b691f229887e143f81fedab9b20205349ab04d73ed", size = 6280005, upload-time = "2026-04-01T14:43:54.242Z" },
+    { url = "https://files.pythonhosted.org/packages/a8/68/b93e09e5e8549019e61acf49f65b1a8530765a7f812c77a7461bca7e4494/pillow-12.2.0-cp313-cp313-manylinux2014_x86_64.manylinux_2_17_x86_64.whl", hash = "sha256:03f6fab9219220f041c74aeaa2939ff0062bd5c364ba9ce037197f4c6d498cd9", size = 8090669, upload-time = "2026-04-01T14:43:57.335Z" },
+    { url = "https://files.pythonhosted.org/packages/4b/6e/3ccb54ce8ec4ddd1accd2d89004308b7b0b21c4ac3d20fa70af4760a4330/pillow-12.2.0-cp313-cp313-manylinux_2_27_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:5cdfebd752ec52bf5bb4e35d9c64b40826bc5b40a13df7c3cda20a2c03a0f5ed", size = 6395194, upload-time = "2026-04-01T14:43:59.864Z" },
+    { url = "https://files.pythonhosted.org/packages/67/ee/21d4e8536afd1a328f01b359b4d3997b291ffd35a237c877b331c1c3b71c/pillow-12.2.0-cp313-cp313-manylinux_2_27_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:eedf4b74eda2b5a4b2b2fb4c006d6295df3bf29e459e198c90ea48e130dc75c3", size = 7082423, upload-time = "2026-04-01T14:44:02.74Z" },
+    { url = "https://files.pythonhosted.org/packages/78/5f/e9f86ab0146464e8c133fe85df987ed9e77e08b29d8d35f9f9f4d6f917ba/pillow-12.2.0-cp313-cp313-musllinux_1_2_aarch64.whl", hash = "sha256:00a2865911330191c0b818c59103b58a5e697cae67042366970a6b6f1b20b7f9", size = 6505667, upload-time = "2026-04-01T14:44:05.381Z" },
+    { url = "https://files.pythonhosted.org/packages/ed/1e/409007f56a2fdce61584fd3acbc2bbc259857d555196cedcadc68c015c82/pillow-12.2.0-cp313-cp313-musllinux_1_2_x86_64.whl", hash = "sha256:1e1757442ed87f4912397c6d35a0db6a7b52592156014706f17658ff58bbf795", size = 7208580, upload-time = "2026-04-01T14:44:08.39Z" },
+    { url = "https://files.pythonhosted.org/packages/23/c4/7349421080b12fb35414607b8871e9534546c128a11965fd4a7002ccfbee/pillow-12.2.0-cp313-cp313-win32.whl", hash = "sha256:144748b3af2d1b358d41286056d0003f47cb339b8c43a9ea42f5fea4d8c66b6e", size = 6375896, upload-time = "2026-04-01T14:44:11.197Z" },
+    { url = "https://files.pythonhosted.org/packages/3f/82/8a3739a5e470b3c6cbb1d21d315800d8e16bff503d1f16b03a4ec3212786/pillow-12.2.0-cp313-cp313-win_amd64.whl", hash = "sha256:390ede346628ccc626e5730107cde16c42d3836b89662a115a921f28440e6a3b", size = 7081266, upload-time = "2026-04-01T14:44:13.947Z" },
+    { url = "https://files.pythonhosted.org/packages/c3/25/f968f618a062574294592f668218f8af564830ccebdd1fa6200f598e65c5/pillow-12.2.0-cp313-cp313-win_arm64.whl", hash = "sha256:8023abc91fba39036dbce14a7d6535632f99c0b857807cbbbf21ecc9f4717f06", size = 2463508, upload-time = "2026-04-01T14:44:16.312Z" },
+    { url = "https://files.pythonhosted.org/packages/4d/a4/b342930964e3cb4dce5038ae34b0eab4653334995336cd486c5a8c25a00c/pillow-12.2.0-cp313-cp313t-macosx_10_13_x86_64.whl", hash = "sha256:042db20a421b9bafecc4b84a8b6e444686bd9d836c7fd24542db3e7df7baad9b", size = 5309927, upload-time = "2026-04-01T14:44:18.89Z" },
+    { url = "https://files.pythonhosted.org/packages/9f/de/23198e0a65a9cf06123f5435a5d95cea62a635697f8f03d134d3f3a96151/pillow-12.2.0-cp313-cp313t-macosx_11_0_arm64.whl", hash = "sha256:dd025009355c926a84a612fecf58bb315a3f6814b17ead51a8e48d3823d9087f", size = 4698624, upload-time = "2026-04-01T14:44:21.115Z" },
+    { url = "https://files.pythonhosted.org/packages/01/a6/1265e977f17d93ea37aa28aa81bad4fa597933879fac2520d24e021c8da3/pillow-12.2.0-cp313-cp313t-manylinux2014_aarch64.manylinux_2_17_aarch64.whl", hash = "sha256:88ddbc66737e277852913bd1e07c150cc7bb124539f94c4e2df5344494e0a612", size = 6321252, upload-time = "2026-04-01T14:44:23.663Z" },
+    { url = "https://files.pythonhosted.org/packages/3c/83/5982eb4a285967baa70340320be9f88e57665a387e3a53a7f0db8231a0cd/pillow-12.2.0-cp313-cp313t-manylinux2014_x86_64.manylinux_2_17_x86_64.whl", hash = "sha256:d362d1878f00c142b7e1a16e6e5e780f02be8195123f164edf7eddd911eefe7c", size = 8126550, upload-time = "2026-04-01T14:44:26.772Z" },
+    { url = "https://files.pythonhosted.org/packages/4e/48/6ffc514adce69f6050d0753b1a18fd920fce8cac87620d5a31231b04bfc5/pillow-12.2.0-cp313-cp313t-manylinux_2_27_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:2c727a6d53cb0018aadd8018c2b938376af27914a68a492f59dfcaca650d5eea", size = 6433114, upload-time = "2026-04-01T14:44:29.615Z" },
+    { url = "https://files.pythonhosted.org/packages/36/a3/f9a77144231fb8d40ee27107b4463e205fa4677e2ca2548e14da5cf18dce/pillow-12.2.0-cp313-cp313t-manylinux_2_27_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:efd8c21c98c5cc60653bcb311bef2ce0401642b7ce9d09e03a7da87c878289d4", size = 7115667, upload-time = "2026-04-01T14:44:32.773Z" },
+    { url = "https://files.pythonhosted.org/packages/c1/fc/ac4ee3041e7d5a565e1c4fd72a113f03b6394cc72ab7089d27608f8aaccb/pillow-12.2.0-cp313-cp313t-musllinux_1_2_aarch64.whl", hash = "sha256:9f08483a632889536b8139663db60f6724bfcb443c96f1b18855860d7d5c0fd4", size = 6538966, upload-time = "2026-04-01T14:44:35.252Z" },
+    { url = "https://files.pythonhosted.org/packages/c0/a8/27fb307055087f3668f6d0a8ccb636e7431d56ed0750e07a60547b1e083e/pillow-12.2.0-cp313-cp313t-musllinux_1_2_x86_64.whl", hash = "sha256:dac8d77255a37e81a2efcbd1fc05f1c15ee82200e6c240d7e127e25e365c39ea", size = 7238241, upload-time = "2026-04-01T14:44:37.875Z" },
+    { url = "https://files.pythonhosted.org/packages/ad/4b/926ab182c07fccae9fcb120043464e1ff1564775ec8864f21a0ebce6ac25/pillow-12.2.0-cp313-cp313t-win32.whl", hash = "sha256:ee3120ae9dff32f121610bb08e4313be87e03efeadfc6c0d18f89127e24d0c24", size = 6379592, upload-time = "2026-04-01T14:44:40.336Z" },
+    { url = "https://files.pythonhosted.org/packages/c2/c4/f9e476451a098181b30050cc4c9a3556b64c02cf6497ea421ac047e89e4b/pillow-12.2.0-cp313-cp313t-win_amd64.whl", hash = "sha256:325ca0528c6788d2a6c3d40e3568639398137346c3d6e66bb61db96b96511c98", size = 7085542, upload-time = "2026-04-01T14:44:43.251Z" },
+    { url = "https://files.pythonhosted.org/packages/00/a4/285f12aeacbe2d6dc36c407dfbbe9e96d4a80b0fb710a337f6d2ad978c75/pillow-12.2.0-cp313-cp313t-win_arm64.whl", hash = "sha256:2e5a76d03a6c6dcef67edabda7a52494afa4035021a79c8558e14af25313d453", size = 2465765, upload-time = "2026-04-01T14:44:45.996Z" },
+    { url = "https://files.pythonhosted.org/packages/bf/98/4595daa2365416a86cb0d495248a393dfc84e96d62ad080c8546256cb9c0/pillow-12.2.0-cp314-cp314-ios_13_0_arm64_iphoneos.whl", hash = "sha256:3adc9215e8be0448ed6e814966ecf3d9952f0ea40eb14e89a102b87f450660d8", size = 4100848, upload-time = "2026-04-01T14:44:48.48Z" },
+    { url = "https://files.pythonhosted.org/packages/0b/79/40184d464cf89f6663e18dfcf7ca21aae2491fff1a16127681bf1fa9b8cf/pillow-12.2.0-cp314-cp314-ios_13_0_arm64_iphonesimulator.whl", hash = "sha256:6a9adfc6d24b10f89588096364cc726174118c62130c817c2837c60cf08a392b", size = 4176515, upload-time = "2026-04-01T14:44:51.353Z" },
+    { url = "https://files.pythonhosted.org/packages/b0/63/703f86fd4c422a9cf722833670f4f71418fb116b2853ff7da722ea43f184/pillow-12.2.0-cp314-cp314-ios_13_0_x86_64_iphonesimulator.whl", hash = "sha256:6a6e67ea2e6feda684ed370f9a1c52e7a243631c025ba42149a2cc5934dec295", size = 3640159, upload-time = "2026-04-01T14:44:53.588Z" },
+    { url = "https://files.pythonhosted.org/packages/71/e0/fb22f797187d0be2270f83500aab851536101b254bfa1eae10795709d283/pillow-12.2.0-cp314-cp314-macosx_10_15_x86_64.whl", hash = "sha256:2bb4a8d594eacdfc59d9e5ad972aa8afdd48d584ffd5f13a937a664c3e7db0ed", size = 5312185, upload-time = "2026-04-01T14:44:56.039Z" },
+    { url = "https://files.pythonhosted.org/packages/ba/8c/1a9e46228571de18f8e28f16fabdfc20212a5d019f3e3303452b3f0a580d/pillow-12.2.0-cp314-cp314-macosx_11_0_arm64.whl", hash = "sha256:80b2da48193b2f33ed0c32c38140f9d3186583ce7d516526d462645fd98660ae", size = 4695386, upload-time = "2026-04-01T14:44:58.663Z" },
+    { url = "https://files.pythonhosted.org/packages/70/62/98f6b7f0c88b9addd0e87c217ded307b36be024d4ff8869a812b241d1345/pillow-12.2.0-cp314-cp314-manylinux2014_aarch64.manylinux_2_17_aarch64.whl", hash = "sha256:22db17c68434de69d8ecfc2fe821569195c0c373b25cccb9cbdacf2c6e53c601", size = 6280384, upload-time = "2026-04-01T14:45:01.5Z" },
+    { url = "https://files.pythonhosted.org/packages/5e/03/688747d2e91cfbe0e64f316cd2e8005698f76ada3130d0194664174fa5de/pillow-12.2.0-cp314-cp314-manylinux2014_x86_64.manylinux_2_17_x86_64.whl", hash = "sha256:7b14cc0106cd9aecda615dd6903840a058b4700fcb817687d0ee4fc8b6e389be", size = 8091599, upload-time = "2026-04-01T14:45:04.5Z" },
+    { url = "https://files.pythonhosted.org/packages/f6/35/577e22b936fcdd66537329b33af0b4ccfefaeabd8aec04b266528cddb33c/pillow-12.2.0-cp314-cp314-manylinux_2_27_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:8cbeb542b2ebc6fcdacabf8aca8c1a97c9b3ad3927d46b8723f9d4f033288a0f", size = 6396021, upload-time = "2026-04-01T14:45:07.117Z" },
+    { url = "https://files.pythonhosted.org/packages/11/8d/d2532ad2a603ca2b93ad9f5135732124e57811d0168155852f37fbce2458/pillow-12.2.0-cp314-cp314-manylinux_2_27_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:4bfd07bc812fbd20395212969e41931001fd59eb55a60658b0e5710872e95286", size = 7083360, upload-time = "2026-04-01T14:45:09.763Z" },
+    { url = "https://files.pythonhosted.org/packages/5e/26/d325f9f56c7e039034897e7380e9cc202b1e368bfd04d4cbe6a441f02885/pillow-12.2.0-cp314-cp314-musllinux_1_2_aarch64.whl", hash = "sha256:9aba9a17b623ef750a4d11b742cbafffeb48a869821252b30ee21b5e91392c50", size = 6507628, upload-time = "2026-04-01T14:45:12.378Z" },
+    { url = "https://files.pythonhosted.org/packages/5f/f7/769d5632ffb0988f1c5e7660b3e731e30f7f8ec4318e94d0a5d674eb65a4/pillow-12.2.0-cp314-cp314-musllinux_1_2_x86_64.whl", hash = "sha256:deede7c263feb25dba4e82ea23058a235dcc2fe1f6021025dc71f2b618e26104", size = 7209321, upload-time = "2026-04-01T14:45:15.122Z" },
+    { url = "https://files.pythonhosted.org/packages/6a/7a/c253e3c645cd47f1aceea6a8bacdba9991bf45bb7dfe927f7c893e89c93c/pillow-12.2.0-cp314-cp314-win32.whl", hash = "sha256:632ff19b2778e43162304d50da0181ce24ac5bb8180122cbe1bf4673428328c7", size = 6479723, upload-time = "2026-04-01T14:45:17.797Z" },
+    { url = "https://files.pythonhosted.org/packages/cd/8b/601e6566b957ca50e28725cb6c355c59c2c8609751efbecd980db44e0349/pillow-12.2.0-cp314-cp314-win_amd64.whl", hash = "sha256:4e6c62e9d237e9b65fac06857d511e90d8461a32adcc1b9065ea0c0fa3a28150", size = 7217400, upload-time = "2026-04-01T14:45:20.529Z" },
+    { url = "https://files.pythonhosted.org/packages/d6/94/220e46c73065c3e2951bb91c11a1fb636c8c9ad427ac3ce7d7f3359b9b2f/pillow-12.2.0-cp314-cp314-win_arm64.whl", hash = "sha256:b1c1fbd8a5a1af3412a0810d060a78b5136ec0836c8a4ef9aa11807f2a22f4e1", size = 2554835, upload-time = "2026-04-01T14:45:23.162Z" },
+    { url = "https://files.pythonhosted.org/packages/b6/ab/1b426a3974cb0e7da5c29ccff4807871d48110933a57207b5a676cccc155/pillow-12.2.0-cp314-cp314t-macosx_10_15_x86_64.whl", hash = "sha256:57850958fe9c751670e49b2cecf6294acc99e562531f4bd317fa5ddee2068463", size = 5314225, upload-time = "2026-04-01T14:45:25.637Z" },
+    { url = "https://files.pythonhosted.org/packages/19/1e/dce46f371be2438eecfee2a1960ee2a243bbe5e961890146d2dee1ff0f12/pillow-12.2.0-cp314-cp314t-macosx_11_0_arm64.whl", hash = "sha256:d5d38f1411c0ed9f97bcb49b7bd59b6b7c314e0e27420e34d99d844b9ce3b6f3", size = 4698541, upload-time = "2026-04-01T14:45:28.355Z" },
+    { url = "https://files.pythonhosted.org/packages/55/c3/7fbecf70adb3a0c33b77a300dc52e424dc22ad8cdc06557a2e49523b703d/pillow-12.2.0-cp314-cp314t-manylinux2014_aarch64.manylinux_2_17_aarch64.whl", hash = "sha256:5c0a9f29ca8e79f09de89293f82fc9b0270bb4af1d58bc98f540cc4aedf03166", size = 6322251, upload-time = "2026-04-01T14:45:30.924Z" },
+    { url = "https://files.pythonhosted.org/packages/1c/3c/7fbc17cfb7e4fe0ef1642e0abc17fc6c94c9f7a16be41498e12e2ba60408/pillow-12.2.0-cp314-cp314t-manylinux2014_x86_64.manylinux_2_17_x86_64.whl", hash = "sha256:1610dd6c61621ae1cf811bef44d77e149ce3f7b95afe66a4512f8c59f25d9ebe", size = 8127807, upload-time = "2026-04-01T14:45:33.908Z" },
+    { url = "https://files.pythonhosted.org/packages/ff/c3/a8ae14d6defd2e448493ff512fae903b1e9bd40b72efb6ec55ce0048c8ce/pillow-12.2.0-cp314-cp314t-manylinux_2_27_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:0a34329707af4f73cf1782a36cd2289c0368880654a2c11f027bcee9052d35dd", size = 6433935, upload-time = "2026-04-01T14:45:36.623Z" },
+    { url = "https://files.pythonhosted.org/packages/6e/32/2880fb3a074847ac159d8f902cb43278a61e85f681661e7419e6596803ed/pillow-12.2.0-cp314-cp314t-manylinux_2_27_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:8e9c4f5b3c546fa3458a29ab22646c1c6c787ea8f5ef51300e5a60300736905e", size = 7116720, upload-time = "2026-04-01T14:45:39.258Z" },
+    { url = "https://files.pythonhosted.org/packages/46/87/495cc9c30e0129501643f24d320076f4cc54f718341df18cc70ec94c44e1/pillow-12.2.0-cp314-cp314t-musllinux_1_2_aarch64.whl", hash = "sha256:fb043ee2f06b41473269765c2feae53fc2e2fbf96e5e22ca94fb5ad677856f06", size = 6540498, upload-time = "2026-04-01T14:45:41.879Z" },
+    { url = "https://files.pythonhosted.org/packages/18/53/773f5edca692009d883a72211b60fdaf8871cbef075eaa9d577f0a2f989e/pillow-12.2.0-cp314-cp314t-musllinux_1_2_x86_64.whl", hash = "sha256:f278f034eb75b4e8a13a54a876cc4a5ab39173d2cdd93a638e1b467fc545ac43", size = 7239413, upload-time = "2026-04-01T14:45:44.705Z" },
+    { url = "https://files.pythonhosted.org/packages/c9/e4/4b64a97d71b2a83158134abbb2f5bd3f8a2ea691361282f010998f339ec7/pillow-12.2.0-cp314-cp314t-win32.whl", hash = "sha256:6bb77b2dcb06b20f9f4b4a8454caa581cd4dd0643a08bacf821216a16d9c8354", size = 6482084, upload-time = "2026-04-01T14:45:47.568Z" },
+    { url = "https://files.pythonhosted.org/packages/ba/13/306d275efd3a3453f72114b7431c877d10b1154014c1ebbedd067770d629/pillow-12.2.0-cp314-cp314t-win_amd64.whl", hash = "sha256:6562ace0d3fb5f20ed7290f1f929cae41b25ae29528f2af1722966a0a02e2aa1", size = 7225152, upload-time = "2026-04-01T14:45:50.032Z" },
+    { url = "https://files.pythonhosted.org/packages/ff/6e/cf826fae916b8658848d7b9f38d88da6396895c676e8086fc0988073aaf8/pillow-12.2.0-cp314-cp314t-win_arm64.whl", hash = "sha256:aa88ccfe4e32d362816319ed727a004423aab09c5cea43c01a4b435643fa34eb", size = 2556579, upload-time = "2026-04-01T14:45:52.529Z" },
+    { url = "https://files.pythonhosted.org/packages/4e/b7/2437044fb910f499610356d1352e3423753c98e34f915252aafecc64889f/pillow-12.2.0-pp311-pypy311_pp73-macosx_10_15_x86_64.whl", hash = "sha256:0538bd5e05efec03ae613fd89c4ce0368ecd2ba239cc25b9f9be7ed426b0af1f", size = 5273969, upload-time = "2026-04-01T14:45:55.538Z" },
+    { url = "https://files.pythonhosted.org/packages/f6/f4/8316e31de11b780f4ac08ef3654a75555e624a98db1056ecb2122d008d5a/pillow-12.2.0-pp311-pypy311_pp73-macosx_11_0_arm64.whl", hash = "sha256:394167b21da716608eac917c60aa9b969421b5dcbbe02ae7f013e7b85811c69d", size = 4659674, upload-time = "2026-04-01T14:45:58.093Z" },
+    { url = "https://files.pythonhosted.org/packages/d4/37/664fca7201f8bb2aa1d20e2c3d5564a62e6ae5111741966c8319ca802361/pillow-12.2.0-pp311-pypy311_pp73-manylinux2014_aarch64.manylinux_2_17_aarch64.whl", hash = "sha256:5d04bfa02cc2d23b497d1e90a0f927070043f6cbf303e738300532379a4b4e0f", size = 5288479, upload-time = "2026-04-01T14:46:01.141Z" },
+    { url = "https://files.pythonhosted.org/packages/49/62/5b0ed78fce87346be7a5cfcfaaad91f6a1f98c26f86bdbafa2066c647ef6/pillow-12.2.0-pp311-pypy311_pp73-manylinux2014_x86_64.manylinux_2_17_x86_64.whl", hash = "sha256:0c838a5125cee37e68edec915651521191cef1e6aa336b855f495766e77a366e", size = 7032230, upload-time = "2026-04-01T14:46:03.874Z" },
+    { url = "https://files.pythonhosted.org/packages/c3/28/ec0fc38107fc32536908034e990c47914c57cd7c5a3ece4d8d8f7ffd7e27/pillow-12.2.0-pp311-pypy311_pp73-manylinux_2_27_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:4a6c9fa44005fa37a91ebfc95d081e8079757d2e904b27103f4f5fa6f0bf78c0", size = 5355404, upload-time = "2026-04-01T14:46:06.33Z" },
+    { url = "https://files.pythonhosted.org/packages/5e/8b/51b0eddcfa2180d60e41f06bd6d0a62202b20b59c68f5a132e615b75aecf/pillow-12.2.0-pp311-pypy311_pp73-manylinux_2_27_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:25373b66e0dd5905ed63fa3cae13c82fbddf3079f2c8bf15c6fb6a35586324c1", size = 6002215, upload-time = "2026-04-01T14:46:08.83Z" },
+    { url = "https://files.pythonhosted.org/packages/bc/60/5382c03e1970de634027cee8e1b7d39776b778b81812aaf45b694dfe9e28/pillow-12.2.0-pp311-pypy311_pp73-win_amd64.whl", hash = "sha256:bfa9c230d2fe991bed5318a5f119bd6780cda2915cca595393649fc118ab895e", size = 7080946, upload-time = "2026-04-01T14:46:11.734Z" },
 ]
 
 [[package]]

From 69d349139df077613eed9ddaa0f99a0386a4686c Mon Sep 17 00:00:00 2001
From: twidmer <twidmer@nvidia.com>
Date: Thu, 16 Apr 2026 09:50:13 +0200
Subject: [PATCH 09/10] Ran ruff

---
 newton/_src/geometry/narrow_phase.py      |  8 ++---
 newton/tests/test_speculative_contacts.py | 42 +++++++++++++++++++----
 2 files changed, 38 insertions(+), 12 deletions(-)

diff --git a/newton/_src/geometry/narrow_phase.py b/newton/_src/geometry/narrow_phase.py
index 1575bb29e2..13ea0daa93 100644
--- a/newton/_src/geometry/narrow_phase.py
+++ b/newton/_src/geometry/narrow_phase.py
@@ -1231,9 +1231,7 @@ def narrow_phase_process_mesh_plane_contacts_kernel(
 
             if wp.static(speculative):
                 vel_rel = shape_lin_vel[plane_shape] - shape_lin_vel[mesh_shape]
-                rel_speed = (
-                    wp.length(vel_rel) + shape_ang_speed_bound[mesh_shape] + shape_ang_speed_bound[plane_shape]
-                )
+                rel_speed = wp.length(vel_rel) + shape_ang_speed_bound[mesh_shape] + shape_ang_speed_bound[plane_shape]
                 gap_sum = gap_sum + wp.min(rel_speed * speculative_dt, max_speculative_extension)
 
             # Strided loop over vertices across all threads in the launch
@@ -1374,9 +1372,7 @@ def narrow_phase_process_mesh_plane_contacts_reduce_kernel(
 
             if wp.static(speculative):
                 vel_rel = shape_lin_vel[plane_shape] - shape_lin_vel[mesh_shape]
-                rel_speed = (
-                    wp.length(vel_rel) + shape_ang_speed_bound[mesh_shape] + shape_ang_speed_bound[plane_shape]
-                )
+                rel_speed = wp.length(vel_rel) + shape_ang_speed_bound[mesh_shape] + shape_ang_speed_bound[plane_shape]
                 gap_sum = gap_sum + wp.min(rel_speed * speculative_dt, max_speculative_extension)
 
             # Process this block's chunk of vertices — write contacts directly
diff --git a/newton/tests/test_speculative_contacts.py b/newton/tests/test_speculative_contacts.py
index d8a36b60a0..80bbb98cd0 100644
--- a/newton/tests/test_speculative_contacts.py
+++ b/newton/tests/test_speculative_contacts.py
@@ -265,17 +265,47 @@ def _make_thin_wall_mesh(hx=0.02, hy=1.0, hz=1.0):
     tris = np.array(
         [
             # -X face
-            0, 3, 7,  0, 7, 4,
+            0,
+            3,
+            7,
+            0,
+            7,
+            4,
             # +X face
-            1, 5, 6,  1, 6, 2,
+            1,
+            5,
+            6,
+            1,
+            6,
+            2,
             # -Y face
-            0, 4, 5,  0, 5, 1,
+            0,
+            4,
+            5,
+            0,
+            5,
+            1,
             # +Y face
-            3, 2, 6,  3, 6, 7,
+            3,
+            2,
+            6,
+            3,
+            6,
+            7,
             # -Z face
-            0, 1, 2,  0, 2, 3,
+            0,
+            1,
+            2,
+            0,
+            2,
+            3,
             # +Z face
-            4, 7, 6,  4, 6, 5,
+            4,
+            7,
+            6,
+            4,
+            6,
+            5,
         ],
         dtype=np.int32,
     )

From b739859178625a4c81e8d162c76f9ae410b7c8e5 Mon Sep 17 00:00:00 2001
From: twidmer <twidmer@nvidia.com>
Date: Thu, 16 Apr 2026 10:17:38 +0200
Subject: [PATCH 10/10] Implement CodeRabbit comments

---
 CHANGELOG.md                         | 1 -
 newton/_src/geometry/narrow_phase.py | 8 ++++----
 newton/_src/geometry/sdf_contact.py  | 7 ++-----
 3 files changed, 6 insertions(+), 10 deletions(-)

diff --git a/CHANGELOG.md b/CHANGELOG.md
index 45e243e230..a8fe5ae11e 100644
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@@ -78,7 +78,6 @@
 - Add RJ45 plug-socket insertion example with SDF contacts, latch joint, and interactive gizmo
 - Add `SpeculativeContactConfig` and speculative contact support in `CollisionPipeline` to detect contacts for fast-moving objects before they tunnel through thin geometry
 - Add `TRIANGLE_PRISM` support-function type for heightfield triangles, extruding 1 m along the heightfield's local -Z so GJK/MPR naturally resolves shapes on the back side
-- Add `ViewerGL.log_scalar()` for live scalar time-series plots in the viewer
 
 ### Changed
 
diff --git a/newton/_src/geometry/narrow_phase.py b/newton/_src/geometry/narrow_phase.py
index 467ba9bb1f..4a655532c1 100644
--- a/newton/_src/geometry/narrow_phase.py
+++ b/newton/_src/geometry/narrow_phase.py
@@ -150,7 +150,7 @@ def create_narrow_phase_primitive_kernel(writer_func: Any, speculative: bool = F
     Returns:
         A warp kernel for primitive collision detection
     """
-    _module = f"narrow_phase_primitive_{writer_func.__name__}"
+    _module = f"narrow_phase_primitive_{writer_func.__name__}_{speculative}"
 
     @wp.kernel(enable_backward=False, module=_module)
     def narrow_phase_primitive_kernel(
@@ -658,7 +658,7 @@ def create_narrow_phase_kernel_gjk_mpr(
     """
     _sf = support_func.__name__ if support_func is not None else "default"
     _ppc = post_process_contact.__name__ if post_process_contact is not None else "default"
-    _module = f"narrow_phase_gjk_mpr_{external_aabb}_{writer_func.__name__}_{_sf}_{_ppc}"
+    _module = f"narrow_phase_gjk_mpr_{external_aabb}_{writer_func.__name__}_{_sf}_{_ppc}_{speculative}"
 
     @wp.kernel(enable_backward=False, module=_module)
     def narrow_phase_kernel_gjk_mpr(
@@ -957,7 +957,7 @@ def narrow_phase_find_mesh_triangle_overlaps_kernel(
 
 
 def create_narrow_phase_process_mesh_triangle_contacts_kernel(writer_func: Any, speculative: bool = False):
-    _module = f"narrow_phase_mesh_tri_{writer_func.__name__}"
+    _module = f"narrow_phase_mesh_tri_{writer_func.__name__}_{speculative}"
 
     @wp.kernel(enable_backward=False, module=_module)
     def narrow_phase_process_mesh_triangle_contacts_kernel(
@@ -1163,7 +1163,7 @@ def create_narrow_phase_process_mesh_plane_contacts_kernel(
     Returns:
         A warp kernel that processes mesh-plane collisions
     """
-    _module = f"narrow_phase_mesh_plane_{writer_func.__name__}_{reduce_contacts}"
+    _module = f"narrow_phase_mesh_plane_{writer_func.__name__}_{reduce_contacts}_{speculative}"
 
     @wp.kernel(enable_backward=False, module=_module)
     def narrow_phase_process_mesh_plane_contacts_kernel(
diff --git a/newton/_src/geometry/sdf_contact.py b/newton/_src/geometry/sdf_contact.py
index 825206e836..43d618e49e 100644
--- a/newton/_src/geometry/sdf_contact.py
+++ b/newton/_src/geometry/sdf_contact.py
@@ -39,10 +39,7 @@ def _query_mesh_face_normal(
     sign = float(0.0)
     res = wp.mesh_query_point_sign_normal(mesh_id, point_local, max_dist, sign, face_index, face_u, face_v)
     if res:
-        n = wp.mesh_eval_face_normal(mesh_id, face_index)
-        if sign < 0.0:
-            n = -n
-        return n
+        return wp.mesh_eval_face_normal(mesh_id, face_index)
     return wp.vec3(0.0, 1.0, 0.0)
 
 
@@ -1034,7 +1031,7 @@ def create_narrow_phase_process_mesh_mesh_contacts_kernel(
     # compiled code, otherwise FMA-fusion or register-allocation
     # differences between independent JIT compilations can produce subtly
     # different floating-point results, breaking bit-exact reproducibility.
-    _module = f"sdf_contact_{writer_func.__name__}_{enable_heightfields}_{reduce_contacts}"
+    _module = f"sdf_contact_{writer_func.__name__}_{enable_heightfields}_{reduce_contacts}_{speculative}"
 
     @wp.kernel(enable_backward=False, module=_module)
     def mesh_sdf_collision_kernel(