dimforge/rapier

This system is a high-performance, cross-platform physics engine library that simulates rigid body dynamics, soft-body deformation, and articulated multibody systems. It provides comprehensive tools for loading robot models from URDF and MJCF formats, alongside robust character and vehicle controllers for interactive applications. The engine supports both 2D and 3D simulations with optional SIMD acceleration and double-precision math, ensuring stability and determinism across various hardware architectures.

18 changes.

The project restructured into a monorepo with official bindings for Bevy, Python, C, and TypeScript, while introducing a new CI pipeline and contributor guidelines. Internally, the physics engine underwent significant architectural changes, including a unified joint system, a persistent contact graph solver, and a Multi-SAP broad-phase, alongside the removal of legacy collision detection modules. The testbed was rewritten to support advanced debugging and simulation state snapshotting, enhancing both developer experience and performance.

32 changes.

This period focused on expanding the physics engine's capabilities with comprehensive soft-body simulation, including both constraint-based and FEM solvers, alongside a new multibody joint system with inverse kinematics. Significant architectural overhauls were made to the collision detection pipeline, introducing BVH-based broad-phase detection, SIMD-accelerated contact solving, and parallel staging for improved performance. The release also introduced extensive loader support for URDF and MJCF robot models, new character and vehicle controllers, and bindings for the Bevy game engine.

New 3D example files have been added to the testbed, including ports of box3d benchmarks (such as joint grids, junkyards, pyramids, and rain simulations) and various feature demos (like compound shapes, collision groups, and character controllers). These additions provide users with visual references for complex physics setups and performance testing scenarios.

examples3d · high confidence

New 3D assets are now available in the \assets/3d\ directory, including a T12 quadruped robot defined by URDF files (with flipped and original axis variants) and an Agility Robotics Cassie robot defined by MuJoCo XML files. Additionally, several decimated OBJ mesh files have been added for testing and visualization, including a camel, chair, cup, dilo, feline, and genus3 model.

assets · high confidence

This change introduces the \bevy\_rapier\ integration, adding new components and modules for physics-based control. It includes \KinematicCharacterController\ and \RayCastVehicleController\ for moving characters and vehicles, along with \PdController\ and \PidController\ for driving rigid-body targets. The update also adds joint definitions (\FixedJoint\, \GenericJoint\, etc.) and a CI ambiguity detection tool to ensure system scheduling correctness.

(repo-wide) · high confidence

This release introduces the bevy\_rapier bindings, providing 2D and 3D physics integration for the Bevy game engine. The package includes a comprehensive set of examples demonstrating core physics features such as rigid body dynamics, collision groups, custom contact filtering, character controllers, and breakable joints. It also includes documentation and licensing files to support adoption.

bindings · high confidence

The 3D testbed now includes a double-precision (f64) variant, providing two demonstration examples: a trimesh simulation that generates a heightfield ground and drops cubes onto it, and a debug-serialized example that loads a previously saved physics world state from a binary file and restores it for interactive simulation.

examples3d-f64 · high confidence

Introduces a new soft-body physics system, allowing deformable bodies made of particles linked by elastic constraints to be simulated alongside rigid bodies. This includes the \SoftBody\ struct, a \SoftCollisionMesh\ system that maps collision geometry to the computational mesh via direct or skinned binding modes, and support for self-collisions, volume preservation, and tearing.

_src/dynamics/soft\_body, src/dynamics/solver/soft\constraint · high confidence

Adds the \rapier3d-urdf\ crate, enabling users to convert URDF robot descriptions into Rapier rigid-bodies, colliders, and joints. The loader supports optional mesh formats (STL, Collada, Wavefront) and provides configurable options for mass properties, collider generation, and multibody joint behavior, including kinematic flags and self-contact disabling.

crates/rapier3d-urdf/src · high confidence

Adds a new staged solver implementation for physics islands that enables parallel constraint solving within a single island. The solver partitions work into completion-gated stages (body initialization, contact/joint generation, and solve passes) using a custom atomic synchronization mechanism, allowing multiple CPU cores to process disjoint constraint colors and joint chunks simultaneously. It supports multi-group substepping for high mass-ratio stability, SIMD-optimized contact and joint resolution, and handles rigid bodies, multibody joints, and soft-body constraints in a unified parallel pipeline.

_src/dynamics/solver/staged\_island\solver · high confidence

This change introduces the \ImpulseJoint\ type, \ImpulseJointHandle\, and \ImpulseJointSet\ in the \src/dynamics/joint/impulse\_joint\ module, establishing the core data structures for managing impulse-based joints (such as hinges, sliders, and springs) between rigid bodies. The \ImpulseJointSet\ provides the API for inserting, querying, and managing these joints, including methods like \joints\_between\ and \attached\_joints\ to inspect connectivity, while internal fields like \assembly\_epoch\ and \island\_events\ support solver optimization and persistent island management.

_src/dynamics/joint/impulse\joint · high confidence

The crate (renamed from rapier3d-stl) has been expanded to load STL, Collada (.dae), and Wavefront (.obj) files. Support for each format is now optional and controlled by feature flags (stl, collada, wavefront), which are enabled by default. Users can now load meshes from different file types using the same load\_from\_path API, with automatic format detection based on file extension.

crates/rapier3d-meshloader · high confidence

The testbed now includes a comprehensive suite of new stress-test scenes for both 2D and 3D physics. These examples exercise the solver under heavy load, covering rigid-body stacks (pyramids, vertical stacks, boxes), complex articulation (ragdolls, joint chains), continuous collision detection (CCD) with various shapes, and soft-body physics (blobs, cloth, FEM beams, ropes, jellies, and slabs). Users can now run these scenarios to benchmark performance, validate stability, and observe how the engine handles large numbers of bodies, soft-vs-soft contacts, and intra-island parallelism.

_examples2d/stress\_tests, examples3d/stress\tests · high confidence

The examples2d directory now includes a comprehensive suite of new demonstration files, including Box2D benchmark ports (such as b2d\_compounds, b2d\_junkyard, b2d\_rain, and b2d\_spinner), new feature showcases (like character\_controller2, collision\_groups2, and ccd2), and utility demos (such as add\_remove2 and debug\_angular\_limits2). These additions provide users with concrete examples of advanced physics capabilities, including continuous collision detection, character controllers, collision filtering, and performance-intensive scenarios.

examples2d · high confidence

Soft bodies can now use a Finite Element Method (FEM) solver instead of the previous soft-constraint approach. This opt-in path assembles a system matrix A = M + hD + h²K and solves it using a direct skyline Cholesky factorization for smaller bodies or a block-Jacobi preconditioned conjugate gradient solver for larger ones. The implementation supports corotational linear elasticity and stable Neo-Hookean material models, along with volume, spring, and dihedral bending elements, providing a more physically accurate simulation for soft bodies that opt into the FEM path.

_src/dynamics/solver/soft\_fem, src\testbed/graphics · high confidence

The website documentation now includes a comprehensive set of JavaScript code snippets for both 2D and 3D physics simulations. These examples cover core concepts such as creating and configuring rigid bodies, colliders, and joints, as well as advanced features like character controllers, soft bodies, PID controllers, and scene queries. The 2D examples also demonstrate advanced collision detection, debug rendering, and standalone usage without bundlers, providing developers with ready-to-use patterns for integrating the physics engine into their applications.

website/docs-examples/2d/javascript, website/docs-examples/3d/javascript · high confidence

The \rapier3d-mjcf\ crate is introduced to load MuJoCo MJCF XML files into Rapier physics scenes. It provides an \MjcfRobot\ API to convert MJCF definitions into rigid bodies, colliders, and joints. Additionally, it exposes \MjcfContactHooks\ to support MJCF-specific contact behaviors, allowing users to exclude specific collider pairs from collision detection and apply per-pair friction overrides during the physics simulation.

crates/rapier3d-mjcf/src · high confidence

The \rapier3d-mjcf\ crate now includes a loader that parses MuJoCo XML (MJCF) files and converts them into Rapier rigid bodies, colliders, joints, and actuators. Users can load models via \MjcfRobot::from\_file\ or \from\_str\, with the loader handling the translation of MJCF geoms (spheres, boxes, capsules, cylinders, ellipsoids, meshes, heightfields) into Rapier colliders, and joints (hinge, slide, ball, free) into either impulse joints or multibody chains. The loader supports mass property derivation from geometry or explicit inertial tags, joint limits, motors, springs, and damping. It provides options to control collider creation, contact filtering, and multibody behavior (e.g., skipping loop closures or motors). Post-insertion, users can apply controls, read sensors, and handle gravity compensation via the returned \MjcfRobotHandles\.

crates/rapier3d-mjcf/src/loader · high confidence

The \examples2d/utils\ directory now includes a \character\ module that provides a dual-mode character controller for the 2D testbed, allowing users to switch between a kinematic position-based controller and a PID-based controller via a UI overlay. It also adds an \svg\ module (available on non-WASM targets) that can tessellate SVG strings into triangle meshes, enabling the use of vector graphics as collision shapes or visual assets in the testbed.

examples2d/utils · high confidence

Added a new \character\ module to the 3D examples utilities, providing a \KinematicCharacterController\ and a \PidController\ for user-controlled movement. This utility allows users to switch between kinematic position-based movement and PID-controlled dynamic movement within the testbed, handling input mapping, collision detection, and visual feedback (color changes based on grounded state).

examples3d/utils · high confidence

The \src/control\ module introduces three new capabilities for non-physics-based object control. First, a \KinematicCharacterController\ enables classic game movement including walking, sliding on slopes, climbing stairs via autostepping, and snapping to ground. Second, \PdController\ and \PidController\ structures allow rigid bodies to be driven toward target poses and velocities using proportional-derivative or proportional-integral-derivative logic. Third, a \DynamicRayCastVehicleController\ simulates vehicles using ray-casting for wheel-ground interaction, exposing tuning parameters for suspension, friction, and steering.

src/control · high confidence

A new debug-render pipeline has been introduced to visualize the physics engine state, providing a pluggable backend interface for rendering colored lines and polylines. Users can now toggle specific rendering modes via flags, including rigid-body axes, impulse and multibody joints, collider AABBs, solver contacts, and geometric contacts. The pipeline also supports soft-body visualization, allowing elements to be colored by structural load or stress, and includes pseudo-normal rendering for triangle meshes and polylines. The default style uses HSLA colors and applies multipliers to indicate body states such as sleeping, sleep-eligible, or disabled.

_src/pipeline/debug\_render\pipeline · high confidence

A new pure-Rust crate, \mjcf-rs\, has been added to parse MuJoCo XML (MJCF) files into a typed AST. It handles recursive \\<include\>\ resolution, \\<default\>\ class inheritance, and normalizes angle units to radians. The parser supports a wide range of MJCF elements including assets (meshes, hfields, textures, materials), kinematic bodies, joints, geoms, contacts, equalities, actuators, sensors, and keyframes. It also supports loading mesh normals and normals smoothing attributes. This crate is designed to be paired with \rapier3d-mjcf\ for simulation, as it does not perform any physics simulation itself.

crates/mjcf-rs · high confidence

The physics engine now includes a new multibody joint system that simulates articulated bodies using a reduced-coordinates formalism. This feature introduces a \MultibodyJointSet\ to manage linked rigid bodies, allowing users to create complex chains and trees of connected parts. The system supports advanced joint behaviors including per-axis locking, passive springs, dry friction, and motor constraints. Additionally, it provides a built-in inverse kinematics solver, enabling users to calculate the joint displacements required to move a specific link to a target pose, with options to constrain which axes and joints are allowed to move during the calculation.

_src/dynamics/joint/multibody\joint · high confidence

The physics module now provides explicit snapshot and restore capabilities for the simulation state, allowing users to save and reload the full physics world (including bodies, colliders, joints, and soft bodies) using bincode serialization. Additionally, it introduces a unified \PhysicsEvents\ struct that aggregates collision and contact force events into a single polling interface, simplifying how users access real-time physics feedback.

_src\testbed/physics · high confidence

This release introduces soft-body simulation, allowing users to create and simulate deformable objects using either a constraint-based or FEM solver. It also adds per-body solver iteration control via \RigidBody::additional\_solver\_iterations\, enabling targeted stability for high mass-ratio scenarios like heavy chains or stacks. The broad-phase filtering has been optimized to suppress unnecessary fixed-vs-fixed pairs, improving performance in static-heavy scenes, and the CCD system now provides a default tier that prevents fast dynamic bodies from tunneling through fixed colliders without requiring the \ccd\_enabled\ flag.

crates/rapier3d · high confidence

The testbed has been rewritten to use Kiss3d instead of Bevy, introducing a new mouse-grabbing interaction that lets you click-drag dynamic bodies (rigid bodies, multibody links, and soft bodies) using a kinematic anchor and motor joint. A new debug-rendering system visualizes physics internals (contacts, solver contacts, collider AABBs, and soft-body stress) via Kiss3d polylines, and the graphics manager now uses instanced meshes for common primitive shapes to improve rendering performance. The testbed also adds a new settings system that allows examples to define live-editable parameters without requiring a simulation restart, and includes a new hover-highlighting feature that visually indicates the body under the cursor.

_src\testbed · high confidence

The entire contact generation subsystem in src/geometry/contact\_generator has been removed. This includes the contact dispatcher, all primitive contact generators (for shapes like balls, capsules, cuboids, and polygons), and the contact generation context structures. Users relying on the engine's built-in collision detection for these primitive shapes will no longer have this functionality available in this module.

_src/geometry/contact\generator · high confidence

The entire \src/geometry/proximity\_detector\ module has been deleted, removing all internal implementations for primitive proximity detection (such as ball-ball, cuboid-cuboid, and polygon-polygon) and the dispatcher that routed shape pairs to these algorithms. This change eliminates the local collision-detection logic from this location, indicating that proximity detection capabilities have been moved or refactored into a different part of the codebase.

_src/geometry/proximity\detector · high confidence

The repository has been restructured into a monorepo that includes the engine source, documentation website, and language bindings (C, Python, JavaScript, Bevy). This change introduces new contributor guidelines, a code of conduct, and a detailed architecture document. To support this structure, a new CI pipeline has been added to enforce formatting, documentation standards, and cross-platform determinism (including SIMD and parallel execution parity). A custom publish script has also been implemented to handle the shared source tree layout for crates.io releases.

(repo-wide) · high confidence

The library now supports no-std environments by adding \\#!\[no\_std\]\ and conditional \std\/\alloc\ imports, while removing the dependency on \ncollide\ in favor of \parry\ for shape and broad-phase logic. Math primitives previously defined locally in \src/lib.rs\ are now re-exported directly from \parry\, and the \utils.rs\ module containing legacy sign and basis traits has been removed as part of this consolidation.

src · high confidence

The physics engine now uses a two-tiered island splitting strategy to optimize performance: a fast local search handles most connectivity changes in O(smaller piece) time, deferring to a slower global union-find only when necessary. This significantly reduces simulation overhead in scenes with many dynamic bodies. Additionally, users can now control how friction and restitution values are combined when colliders interact by choosing from six rules (Average, Min, Multiply, Max, ClampedSum, GeometricMean), with the higher-priority rule taking precedence when colliders disagree.

src/dynamics · high confidence

The physics simulation engine has been restructured into a new \PhysicsPipeline\ module that introduces automatic containment of non-finite (NaN or infinite) state. Bodies, colliders, and soft bodies that produce invalid values are now automatically disabled and quarantined, preventing simulation corruption and crashes. The pipeline also features a new staged solver for velocity constraints, enabling intra-island parallelism to improve performance on multi-core systems. Additionally, the step loop now includes refined CCD substepping and motion clamping, along with deferred BVH optimization to reduce synchronization overhead during collision detection.

_src/pipeline/physics\pipeline · high confidence

The contact constraint solver has been refactored to use a new SIMD-optimized implementation that supports warmstarting (reusing impulses from previous steps for faster convergence) and implements a coupled 2x2 solve for Coulomb friction in 3D, improving stability for stacked or multi-point contacts. The new solver also includes deterministic tangent basis computation to prevent jitter in quiescent contacts and adds support for twist friction constraints in 3D.

_src/dynamics/solver/contact\constraint · high confidence

The broad-phase collision detection has been replaced with a new BroadPhaseBvh implementation that uses a Bounding Volume Hierarchy (BVH) to efficiently identify potential collider pairs. This change introduces adaptive change-detection margins that scale with collider size, configurable BVH optimization strategies (subtree optimizer vs. none), and deferred optimization passes to allow concurrent execution with the narrow phase. The system now filters out same-parent collider pairs and respects collision groups directly during the broad-phase traversal, reducing unnecessary narrow-phase checks. Additionally, it supports soft-body collision detection and includes parallel update capabilities for improved performance in large, mostly-static worlds.

_src/geometry/broad\_phase\bvh · high confidence

The \src/data\ module now includes several new internal data structures: \Coarena\ for managing data associated with items in another Arena, \ModifiedObjects\ to track objects with modification flags, \PubSub\ for an internal publish-subscribe mechanism, and \UnionFind\ for deterministic disjoint-set operations. Additionally, the \Arena\ and \Graph\ structures have been updated to use \u32\ indices instead of \usize\/\u64\ for better determinism and memory efficiency, and the \Graph\ now supports O(1) edge unlinking via doubly-linked adjacency lists.

src/data · high confidence

The narrow-phase collision detection has been restructured into dedicated modules (contacts, intersections, pair management, pair update, queries, and soft contacts) to support soft-body physics and improve performance. Contact and intersection pair updates now run in parallel when the \parallel\ feature is enabled, using a broadcast parallel-for strategy. The system introduces soft-body contact detection, allowing deformable colliders to participate in collision resolution alongside rigid bodies. Contact recycling is optimized to skip full updates when relative pose drift is minimal, and begin/end-touch transitions are deferred and processed in sorted order to ensure deterministic event emission and wake-up behavior across both serial and parallel execution paths.

_src/geometry/narrow\phase · high confidence

The performance counters in \src/counters\ now expose \reset()\ methods on \Counters\, \CollisionDetectionCounters\, \SolverCounters\, and \StagesCounters\, allowing users to clear accumulated timing data without recreating the counter structures. The API has been updated to return \Duration\ types for raw time queries (e.g., \step\_time\, \custom\_time\) and added dedicated \\_ms\ variants (e.g., \step\_time\_ms\) for millisecond precision. New timing metrics have been added to track specific engine phases: \final\_broad\_phase\_time\ for scene query validity, \island\_constraints\_collection\_time\ for persistent solver structure maintenance, \user\_changes\ for propagating user updates, and solver internals like \velocity\_writeback\_time\ and assembly sub-times. Additionally, the internal \Timer\ implementation now relies on the \profiler\ feature flag for high-resolution timing, defaulting to zero-cost no-ops when the feature is disabled.

src/counters · high confidence

The collision detection system has been significantly restructured. The broad-phase has been replaced with a new Multi-SAP implementation, and the previous WAABB hierarchy has been removed. Collision filtering is now handled by a new \InteractionGroups\ system supporting configurable membership and filter groups with AND/OR test modes. The engine now supports manifold reduction and solver-side clustering of contact manifolds to improve performance with composite shapes. Additionally, a new \MeshConverter\ utility has been added to facilitate converting loaded meshes into colliders via various strategies like convex hull or decomposition.

src/geometry · high confidence

The solver's internal architecture has been restructured to improve cache coherence and parallelism. The previous per-step collection of contact manifolds has been replaced by a persistent, incrementally-maintained \SolverContactGraph\ that organizes contacts into color-based buckets, eliminating the need for per-step sorting. Body state is now stored in a Structure-of-Arrays (SoA) layout via \SolverBodies\, enabling efficient SIMD gathering and scattering of velocities and poses. The old \IslandSolver\ and \ParallelIslandSolver\ implementations have been removed in favor of this new unified approach.

src/dynamics/solver · high confidence

The \src\_testbed/objects\ module has been completely removed, deleting all Kiss3d-specific graphics wrappers (Ball, Box, Capsule, Convex, HeightField, Mesh, Plane, Polyline) and their central \Node\ enum. This eliminates the legacy Kiss3d rendering path from the testbed, clearing the way for the renderer migration to Bevy.

_src\testbed/objects · high confidence

The Continuous Collision Detection (CCD) system has been rewritten to support soft bodies, allowing fast dynamic bodies to sweep against deformable collision meshes in addition to fixed geometry. The solver now distinguishes between 'bullet' bodies (which sweep all non-bullet targets) and non-bullet fast bodies (which only sweep fixed and soft targets), improving performance by reducing unnecessary sweep queries. A new caching mechanism for fixed targets avoids re-scanning the entire broad-phase BVH when the scene is static, and the solver now respects user-defined \filter\_contact\_pair\ hooks during CCD resolution to ensure consistent collision filtering. Additionally, mesh-like shapes (tri-meshes, polylines, heightfields) are excluded from being swept as the moving shape, relying instead on speculative contacts.

src/dynamics/ccd · high confidence

Users can now use the new PhysicsWorld struct to manage the entire physics simulation state (rigid bodies, colliders, joints, soft bodies) in a single object, replacing the previous verbose setup. The event system has been reworked: the old proximity and contact events are replaced by collision events (Started/Stopped) and new contact force events, controlled via per-collider ActiveEvents flags. Additionally, a new PhysicsHooks trait allows custom collision filtering and contact modification, including a helper for one-way platforms.

src/pipeline · high confidence

The \src/utils\ module has been refactored to introduce a comprehensive set of generic traits (such as \ScalarType\, \DotProduct\, \CrossProduct\, \RotationOps\, and \PoseOps\) that abstract over both scalar (\Real\) and SIMD (\SimdReal\) math backends. This change unifies the code paths by allowing the physics engine to use a single implementation for core vector and matrix operations regardless of whether it is running in scalar or SIMD mode, while also adding support for glam-based vector types in 2D and 3D configurations.

src/utils · high confidence

The joint system has been refactored to use a single \GenericJoint\ backend for all joint types, replacing the previous separate structs and the \JointParams\ enum. This change introduces a new \JointAxesMask\ API to define degrees of freedom and adds \MotorModel\ support for configurable motor behavior (acceleration-based vs. force-based). New joint types are now available: \PinSlotJoint\ (2D groove joint), \RopeJoint\ (distance-limiting), and \SpringJoint\ (spring-damper). Existing joints like \FixedJoint\ and \SphericalJoint\ have been updated to use the new builder patterns and generic data structures, while the legacy \BallJoint\ and \JointSet\ implementations have been removed.

src/dynamics/joint · high confidence

The joint constraint solver has been refactored to use a unified, generic constraint system that supports both scalar and SIMD (wide) execution paths. This change replaces the previous specialized position-based ball joint constraints with a new velocity-based constraint architecture, introducing \GenericJointConstraint\ and \JointConstraintBuilder\ types. The new system handles motors, limits, and locked axes for generic joints across both rigid bodies and multibody links, while maintaining backward compatibility through SIMD-optimized paths for standard rigid-body joints. Users benefit from improved performance via SIMD processing and more consistent behavior across different joint types, including better support for complex multibody hierarchies.

_src/dynamics/solver/joint\constraint · high confidence

The website directory has been reorganized to support a new multi-language user guide system and integrated WebAssembly demos. A new templating architecture allows a single source of truth to generate documentation variants for Rust, Bevy, JavaScript, C, and Python, with a new plugin handling the injection of code examples at build time. The site now includes a dedicated demos page that embeds compiled 2D and 3D testbeds as WebAssembly, alongside auto-generated API references for the JavaScript, C, and Python bindings. Configuration files for Node.js (v16.20.2), Yarn, and Docusaurus 3 have been added, along with scripts to build demos and API docs, and an audit document detailing the state of the user guide content.

website · high confidence

Added regression test for HalfSpace broad-phase stall; Added regression tests for 2D physics stability and correctness; Added regression tests for URDF loading stability and axis conventions; Added test coverage for MJCF loader features and regression fixes.

This release adds the first official bindings for the Rapier physics engine, providing integration layers for multiple ecosystems. The Bevy bindings (\bevy\_rapier2d\ and \bevy\_rapier3d\) allow Rust developers to use Rapier within the Bevy game engine, supporting features like debug rendering, soft-body physics, and URDF/MJCF loading. Python bindings (\rapier-py-3d\) expose the 3D engine via PyO3, while C bindings (\rapier2d-ffi\, \rapier3d-ffi\, and their f64 variants) provide a stable C ABI for use in other languages. Additionally, TypeScript/Wasm bindings (\rapier.js\) are introduced for web-based physics simulations, including a testbed for visualization.

(dependencies) · high confidence

Written by watchdog.canine.dev from the codebase's own history, inside the signed delivery this page is composed from.

• CAI 71 → 66 (-4.7)
• Rubric changed (rubric-2026.09.10 → rubric-2026.09.18) — scores are not directly comparable.

• Code Health 73 → 74 (+0.9)
• Architecture 81 → 84 (+2.8)
• Maturity 66 → 66 (+0.0)
• Readiness 71 → 64 (-6.9)
• Security 80 → 82 (+1.7)
• Event Sourcing 100 → 100 (+0.0)
• Accessibility 63 (new)
• Performance 94 (new)

• ClassTooLong: Collider (typescript/src.ts/geometry/collider.ts)
• ClassTooLong: QueryPipeline (python/rapier-py-3d/src/pipeline.rs)
• ClassTooLong: RawShape (typescript/src/geometry/shape.rs)
• ClassTooLong: Shape (typescript/src.ts/geometry/shape.ts)
• ClassTooLong: World (typescript/src.ts/pipeline/world.ts)
• ColliderDesc.convexDecomposition (cognitive 19) (typescript/src.ts/geometry/collider.ts)
• Dependency hygiene PARTLY measured — npm pinning read, dependency currency not (no pnpm-resolved versions to grade)
• Documentation: no installation or build instructions
• Documentation: no usage examples
• Duplicated block (10 lines × 2) (python/rapier-py-3d/src/controllers.rs)
• Duplicated block (10 lines × 2) (python/rapier-py-3d/src/joints.rs)
• Duplicated block (10 lines × 23) (examples2d/b2d_compounds.rs)
• Duplicated block (10 lines × 3) (python/rapier-py-3d/src/joints.rs)
• Duplicated block (10–17 lines × 2) (src_testbed/graphics.rs)
• Duplicated block (11 lines × 2) (python/rapier-py-3d/src/controllers.rs)
• Duplicated block (11 lines × 2) (python/rapier-py-3d/src/events_hooks.rs)
• Duplicated block (11 lines × 2) (python/rapier-py-3d/src/geometry.rs)
• Duplicated block (11 lines × 2) (python/rapier-py-3d/src/joints.rs)
• Duplicated block (11 lines × 2) (python/rapier-py-3d/src/joints.rs)
• Duplicated block (11 lines × 2) (typescript/src/dynamics/joint.rs)
• …and 149 more

• BlockMatrix::from_pairs (cognitive 18) (src/dynamics/solver/soft_fem/soft_fem_sparse.rs)
• ClassTooLong: Collider (bindings/python/rapier-py-3d/src/geometry.rs)
• ClassTooLong: Collider (bindings/typescript/src.ts/geometry/collider.ts)
• ClassTooLong: PersistentIslands (src/dynamics/island_manager/persistent.rs)
• ClassTooLong: PhysicsWorld (bindings/python/rapier-py-3d/src/pipeline.rs)
• ClassTooLong: PhysicsWorld (src/pipeline/physics_world.rs)
• ClassTooLong: QueryPipeline (bindings/python/rapier-py-3d/src/pipeline.rs)
• ClassTooLong: RapierContextSimulation (bindings/bevy_rapier/src/plugin/context/mod.rs)
• ClassTooLong: RawColliderSet (bindings/typescript/src/geometry/collider_set.rs)
• ClassTooLong: RawShape (bindings/typescript/src/geometry/shape.rs)
• ClassTooLong: RawSoftBodySet (bindings/typescript/src/dynamics/soft_body.rs)
• ClassTooLong: RigidBody (bindings/python/rapier-py-3d/src/dynamics.rs)
• ClassTooLong: RprSoftBodyDesc (bindings/c/src/soft_desc.rs)
• ClassTooLong: Shape (bindings/typescript/src.ts/geometry/shape.ts)
• ClassTooLong: SoftBody (bindings/python/rapier-py-3d/src/soft_body.rs)
• ClassTooLong: SoftBodyDesc (bindings/typescript/src.ts/dynamics/soft_body.ts)
• ClassTooLong: TestbedViewer (src_testbed/viewer.rs)
• ClassTooLong: World (bindings/typescript/src.ts/pipeline/world.ts)
• ColliderDesc.convexDecomposition (cognitive 19) (bindings/typescript/src.ts/geometry/collider.ts)
• ColliderView::raw_scale_by (cognitive 21) (bindings/bevy_rapier/src/geometry/shape_views/collider_view.rs)
• …and 768 more

• 11 commits — 7 feature/other, 4 fixes

• src/dynamics — 3 commits
• (root) — 1 commit
• bindings/c — 1 commit
• bindings/python — 1 commit
• c/testbed — 1 commit
• crates/rapier2d — 1 commit
• crates/rapier3d-urdf — 1 commit
• src/control — 1 commit
• website/static — 1 commit

• fix: Fix CCD fixed target cache invalidation (#1003)
• fix: Fix various CCD and broad-phase related bugs (#1012)
• fix: fix character controller manifold collection (#1004)
• fix: fix(urdf): compose origin rpy as fixed-axis roll-pitch-yaw (#1014)
• change: Release 0.36.0 (#1017)
• change: chore: reorganize bindings directories + bring in bevy_rapier (#1016)
• change: feat(python): add more control other multibodies throug the python bindings (#1025)
• change: feat(website): update the user-guide (#1015)
• change: feat: make CoefficientCombineRule::combine public (#1007)
• change: feat: add C bindings (#1013)
• change: feat: add support for soft-bodies (#1010)

• Unchanged — 0 containers · 1 contexts · 0 edges

Written by watchdog.canine.dev from the codebase's own history, inside the signed delivery this page is composed from.

dimforge/rapier was measured the same way every project in this corpus was: the same rubric, at a pinned commit, with the result published in full. Point a surveyor at a repository you know and see whether you agree with it.