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

167-170: Pipeline failure: KeyError on empty ArticulationView selection.

GPU unit tests hit “No matching articulations”. Either handle empty matches more gracefully (return an empty view with all-zero slices) or include the pattern in the error to aid debugging.

Proposed minimal improvement:

-            raise KeyError("No matching articulations")
+            raise KeyError(f"No matching articulations for pattern '{pattern}'")

Optionally, add a flag allow_empty=False in the ctor that, when True, initializes an empty view (all counts/slices zero) instead of raising.

newton/_src/solvers/mujoco/solver_mujoco.py (2)

1618-1645: Collapse shape filters to body excludes: correct but optimize membership and reuse sets.

Logic is sound; however, using list membership inside a nested product is O(N·S1·S2). Convert filters to a set and cache per‑body colliding shapes to cut cost.

Apply:

 @staticmethod
 def find_body_collision_filter_pairs(colliding_shapes, shape_filters, shape_bodies, body_shapes):
-    """For shape collision filter pairs, find body collision filter pairs that are contained within."""
-    colliding_shapes = set(colliding_shapes)
-    body_filters = set()
-    body_non_filterable = set()
-    remaining_shape_filters = []
-    for sp in shape_filters:
+    """For shape collision filter pairs, find body collision filter pairs that are contained within."""
+    colliding_shapes = set(colliding_shapes)
+    # O(1) membership
+    sf_set = set(tuple(p) for p in shape_filters)
+    body_filters: set[tuple[int, int]] = set()
+    body_non_filterable: set[tuple[int, int]] = set()
+    remaining_shape_filters = []
+    # cache per-body colliding shapes
+    coll_by_body: dict[int, set[int]] = {}
+    for sp in shape_filters:
         if sp[0] not in colliding_shapes or sp[1] not in colliding_shapes:
             continue
         b1, b2 = shape_bodies[sp[0]], shape_bodies[sp[1]]
         bp = min(b1, b2), max(b1, b2)
         if bp in body_filters:
             continue
         if bp in body_non_filterable:
             remaining_shape_filters.append(sp)
             continue
-        b1_shapes = {s for s in body_shapes[bp[0]] if s in colliding_shapes}
-        b2_shapes = {s for s in body_shapes[bp[1]] if s in colliding_shapes}
-        if all(
-            (bs1, bs2) in shape_filters or (bs2, bs1) in shape_filters for bs1, bs2 in product(b1_shapes, b2_shapes)
-        ):
+        b1_shapes = coll_by_body.setdefault(bp[0], {s for s in body_shapes[bp[0]] if s in colliding_shapes})
+        b2_shapes = coll_by_body.setdefault(bp[1], {s for s in body_shapes[bp[1]] if s in colliding_shapes})
+        if all(((a, b) in sf_set) or ((b, a) in sf_set) for a, b in product(b1_shapes, b2_shapes)):
             body_filters.add(bp)
         else:
             body_non_filterable.add(bp)
             remaining_shape_filters.append(sp)
     return list(body_filters), remaining_shape_filters

---

2356-2359: Skip excludes involving the world body.

MuJoCo excludes between world and a body are unnecessary and may be unsupported. Also, per prior learning, Newton already skips collisions between global shapes across builders.

Guard:

-for b1, b2 in body_filters:
+for b1, b2 in body_filters:
+    if -1 in (b1, b2):
+        continue
     mb1, mb2 = body_mapping[b1], body_mapping[b2]
     spec.add_exclude(bodyname1=spec.bodies[mb1].name, bodyname2=spec.bodies[mb2].name)

Configuration used: Path: .coderabbit.yml

Review profile: CHILL

Plan: Pro

Learnt from: shi-eric
PR: newton-physics/newton#521
File: newton/examples/example_cloth_hanging.py:36-36
Timestamp: 2025-08-12T05:17:34.423Z
Learning: The Newton migration guide (docs/migration.rst) is specifically for documenting how to migrate existing warp.sim functionality to Newton equivalents. New Newton-only features that didn't exist in warp.sim do not need migration documentation.

Learnt from: eric-heiden
PR: newton-physics/newton#587
File: newton/_src/sim/builder.py:656-661
Timestamp: 2025-08-20T18:02:36.099Z
Learning: In Newton physics, collisions between shapes with body index -1 (world-attached/global shapes) are automatically skipped by the collision system, so no manual collision filter pairs need to be added between global shapes from different builders.