diff --git a/.github/workflows/bevy-rapier.yml b/.github/workflows/bevy-rapier.yml
new file mode 100644
index 000000000..81364b50e
--- /dev/null
+++ b/.github/workflows/bevy-rapier.yml
@@ -0,0 +1,142 @@
+name: Bevy plugin
+
+# `bindings/bevy_rapier` is its own Cargo workspace (it tracks Bevy's main branch), building
+# `bevy_rapier2d` and `bevy_rapier3d` against the rapier crates of this repository. It runs
+# on engine changes too, so a rapier change breaking the plugin is caught in its own PR.
+on:
+  push:
+    branches: [master]
+    paths:
+      - "bindings/bevy_rapier/**"
+      - "src/**"
+      - "crates/rapier*/**"
+      - "crates/mjcf-rs/**"
+      - "Cargo.toml"
+      - "website/docs-examples/*/bevy/**"
+      - ".github/workflows/bevy-rapier.yml"
+  pull_request:
+    branches: [master]
+    paths:
+      - "bindings/bevy_rapier/**"
+      - "src/**"
+      - "crates/rapier*/**"
+      - "crates/mjcf-rs/**"
+      - "Cargo.toml"
+      - "website/docs-examples/*/bevy/**"
+      - ".github/workflows/bevy-rapier.yml"
+  workflow_dispatch:
+
+# A new push to a PR cancels the still-running build of the previous push.
+concurrency:
+  group: ${{ github.workflow }}-${{ github.ref }}
+  cancel-in-progress: ${{ github.event_name == 'pull_request' }}
+
+env:
+  CARGO_TERM_COLOR: always
+  CARGO_INCREMENTAL: 0
+  CARGO_PROFILE_DEV_DEBUG: none
+
+defaults:
+  run:
+    working-directory: bindings/bevy_rapier
+
+jobs:
+  check-fmt:
+    runs-on: ubuntu-latest
+    steps:
+      - uses: actions/checkout@v4
+      - uses: dtolnay/rust-toolchain@stable
+        with:
+          components: rustfmt
+      - name: Check formatting
+        run: cargo fmt --all -- --check
+  doc:
+    runs-on: ubuntu-latest
+    env:
+      RUSTDOCFLAGS: -D warnings
+    steps:
+      - uses: actions/checkout@v4
+      - uses: dtolnay/rust-toolchain@stable
+      - uses: Swatinem/rust-cache@v2
+        with:
+          workspaces: bindings/bevy_rapier
+      - run: sudo apt update && sudo apt-get install pkg-config libx11-dev libasound2-dev libudev-dev libwayland-dev libxkbcommon-dev
+      - name: Cargo doc
+        run: cargo doc --no-deps
+  test:
+    runs-on: ubuntu-latest
+    env:
+      RUSTFLAGS: -D warnings
+    steps:
+      - uses: actions/checkout@v4
+      - uses: dtolnay/rust-toolchain@stable
+        with:
+          components: clippy
+      - uses: Swatinem/rust-cache@v2
+        with:
+          workspaces: bindings/bevy_rapier
+      - run: sudo apt update && sudo apt-get install pkg-config libx11-dev libasound2-dev libudev-dev libwayland-dev libxkbcommon-dev
+      - run: cargo install cargo-all-features
+      - name: Clippy for bevy_rapier2d
+        run: cargo clippy --verbose -p bevy_rapier2d --examples
+      - name: Clippy for bevy_rapier3d
+        run: cargo clippy --verbose -p bevy_rapier3d --examples
+      - name: Clippy for bevy_rapier2d (debug-render, simd, serde)
+        run: cargo clippy --verbose -p bevy_rapier2d --features debug-render-2d,simd8,serde-serialize,picking-backend
+      - name: Clippy for bevy_rapier3d (debug-render, simd, serde)
+        run: cargo clippy --verbose -p bevy_rapier3d --features debug-render-3d,simd8,serde-serialize,picking-backend
+      - name: Test for bevy_rapier2d
+        run: cargo test --verbose -p bevy_rapier2d
+      - name: Test for bevy_rapier3d
+        run: cargo test --verbose -p bevy_rapier3d
+      - name: Test for no conflicting system order ambiguity
+        run: cargo run --bin ambiguity_detection
+      - name: Check all features individually
+        run: cargo check-all-features
+  test-wasm:
+    runs-on: ubuntu-latest
+    env:
+      RUSTFLAGS: -D warnings
+    steps:
+      - uses: actions/checkout@v4
+      - uses: dtolnay/rust-toolchain@stable
+        with:
+          components: clippy
+          targets: wasm32-unknown-unknown
+      - uses: Swatinem/rust-cache@v2
+        with:
+          workspaces: bindings/bevy_rapier
+      - name: Clippy bevy_rapier2d
+        run: cd bevy_rapier2d && cargo clippy --verbose --features bevy/webgl2 --target wasm32-unknown-unknown
+      - name: Clippy bevy_rapier3d
+        run: cd bevy_rapier3d && cargo clippy --verbose --features bevy/webgl2 --target wasm32-unknown-unknown
+  dependencies:
+    runs-on: ubuntu-latest
+    steps:
+      - uses: actions/checkout@v4
+      - name: Check dependencies
+        uses: EmbarkStudios/cargo-deny-action@v2
+        with:
+          manifest-path: bindings/bevy_rapier/Cargo.toml
+  # Checks the Bevy documentation snippets compile against the in-tree bevy_rapier. Both
+  # snippet crates are standalone workspaces sharing one target directory.
+  website-bevy-snippets:
+    runs-on: ubuntu-latest
+    env:
+      CARGO_TARGET_DIR: ${{ github.workspace }}/website/docs-examples/target
+    defaults:
+      run:
+        working-directory: website/docs-examples
+    steps:
+      - uses: actions/checkout@v4
+      - uses: dtolnay/rust-toolchain@stable
+      - uses: Swatinem/rust-cache@v2
+        with:
+          workspaces: |
+            website/docs-examples/2d/bevy -> ../../target
+            website/docs-examples/3d/bevy -> ../../target
+      - run: sudo apt update && sudo apt-get install pkg-config libx11-dev libasound2-dev libudev-dev libwayland-dev libxkbcommon-dev
+      - name: Check the 2D snippets
+        run: cd 2d/bevy && cargo check --examples
+      - name: Check the 3D snippets
+        run: cd 3d/bevy && cargo check --examples
diff --git a/.github/workflows/c-bindings.yml b/.github/workflows/c-bindings.yml
index df4ebcc5b..b6ed38845 100644
--- a/.github/workflows/c-bindings.yml
+++ b/.github/workflows/c-bindings.yml
@@ -2,10 +2,10 @@ name: C bindings
 on:
   push:
     branches: [master]
-    paths: ['c/**', 'src/**', 'crates/rapier*/**', 'Cargo.toml', '.github/workflows/c-bindings.yml']
+    paths: ['bindings/c/**', 'src/**', 'crates/rapier*/**', 'Cargo.toml', '.github/workflows/c-bindings.yml']
   pull_request:
     branches: [master]
-    paths: ['c/**', 'src/**', 'crates/rapier*/**', 'Cargo.toml', '.github/workflows/c-bindings.yml']
+    paths: ['bindings/c/**', 'src/**', 'crates/rapier*/**', 'Cargo.toml', '.github/workflows/c-bindings.yml']
   workflow_dispatch:
 jobs:
   native:
@@ -26,7 +26,7 @@ jobs:
         if: runner.os == 'Linux'
         run: sudo apt-get update && sudo apt-get install -y libx11-dev libxrandr-dev libxinerama-dev libxcursor-dev libxi-dev libgl1-mesa-dev
       - name: Configure
-        run: cmake -S c -B build/c -DRAPIER_DIMENSION=${{ matrix.variant.dimension }} -DRAPIER_PRECISION=${{ matrix.precision }} -DRAPIER_ENABLE_PARALLEL=${{ matrix.variant.parallel }} -DRAPIER_BUILD_TESTBED=ON -DRAPIER_PROFILE=debug -DRAPIER_CARGO_TARGET_DIR=${{ github.workspace }}/target
+        run: cmake -S bindings/c -B build/c -DRAPIER_DIMENSION=${{ matrix.variant.dimension }} -DRAPIER_PRECISION=${{ matrix.precision }} -DRAPIER_ENABLE_PARALLEL=${{ matrix.variant.parallel }} -DRAPIER_BUILD_TESTBED=ON -DRAPIER_PROFILE=debug -DRAPIER_CARGO_TARGET_DIR=${{ github.workspace }}/target
       - name: Build
         run: cmake --build build/c --config Release --parallel 2
       - name: Test
@@ -35,7 +35,7 @@ jobs:
         run: cmake --install build/c --config Release --prefix build/install
       - name: Consume installed package
         run: |
-          cmake -S c/tests/consumer -B build/consumer -DCMAKE_PREFIX_PATH=${{ github.workspace }}/build/install
+          cmake -S bindings/c/tests/consumer -B build/consumer -DCMAKE_PREFIX_PATH=${{ github.workspace }}/build/install
           cmake --build build/consumer --config Release
           ctest --test-dir build/consumer -C Release --output-on-failure
   abi-and-features:
@@ -49,18 +49,18 @@ jobs:
       - run: cargo install cbindgen --version 0.29.4 --locked
       - name: Header matches source
         run: |
-          sh c/tools/generate-header.sh
-          git diff --exit-code -- c/include/rapier.h
+          sh bindings/c/tools/generate-header.sh
+          git diff --exit-code -- bindings/c/include/rapier.h
       - run: cargo fmt -p rapier-c-macros -p rapier3d-ffi -- --check
       - run: cargo test -p rapier-c-macros -p rapier2d-ffi -p rapier3d-ffi -p rapier2d-f64-ffi -p rapier3d-f64-ffi
       - run: cargo clippy -p rapier-c-macros -p rapier2d-ffi -p rapier3d-ffi -p rapier2d-f64-ffi -p rapier3d-f64-ffi --no-deps -- -D warnings
       - name: Every ABI symbol and both linkage modes
-        run: python3 c/tools/test-native.py
+        run: python3 bindings/c/tools/test-native.py
       - name: Optional feature combinations
         run: cargo check -p rapier2d-ffi -p rapier3d-ffi -p rapier2d-f64-ffi -p rapier3d-f64-ffi --features parallel,fem,enhanced-determinism
       - name: Eight-lane SIMD with parallel execution
         run: |
-          cmake -S c -B build/simd8 -DRAPIER_BUILD_TESTBED=ON -DRAPIER_TESTBED_GRAPHICS=OFF -DRAPIER_PROFILE=debug -DRAPIER_SIMD_LANES=8 -DRAPIER_ENABLE_PARALLEL=ON -DRAPIER_CARGO_TARGET_DIR=${{ github.workspace }}/target
+          cmake -S bindings/c -B build/simd8 -DRAPIER_BUILD_TESTBED=ON -DRAPIER_TESTBED_GRAPHICS=OFF -DRAPIER_PROFILE=debug -DRAPIER_SIMD_LANES=8 -DRAPIER_ENABLE_PARALLEL=ON -DRAPIER_CARGO_TARGET_DIR=${{ github.workspace }}/target
           cmake --build build/simd8 --parallel 2
           ctest --test-dir build/simd8 --output-on-failure
 
@@ -72,7 +72,7 @@ jobs:
         run: sudo apt-get update && sudo apt-get install -y doxygen
       - name: Generate and validate all API variants
         run: |
-          cmake -S c/doxygen -B build/c-docs
+          cmake -S bindings/c/doxygen -B build/c-docs
           cmake --build build/c-docs --target rapier_docs --parallel 2
       - name: Upload HTML reference
         uses: actions/upload-artifact@v4
diff --git a/.github/workflows/python-bindings.yml b/.github/workflows/python-bindings.yml
index 362922d02..f47f5420b 100644
--- a/.github/workflows/python-bindings.yml
+++ b/.github/workflows/python-bindings.yml
@@ -9,9 +9,9 @@ on:
 env:
   CARGO_TERM_COLOR: always
 
-# The engine package lives under python/rapier-py-3d (rapier3d, f32); the
-# pure-Python testbed under python/rapier-testbed; the test suite under
-# python/tests.
+# The engine package lives under bindings/python/rapier-py-3d (rapier3d, f32); the
+# pure-Python testbed under bindings/python/rapier-testbed; the test suite under
+# bindings/python/tests.
 jobs:
   lint-rust:
     runs-on: ubuntu-latest
@@ -66,11 +66,11 @@ jobs:
       # environment so the test suite can import it.
       - name: Build & install engine package
         shell: bash
-        run: python -m pip install --no-build-isolation ./python/rapier-py-3d
+        run: python -m pip install --no-build-isolation ./bindings/python/rapier-py-3d
       - name: Install testbed (no deps; engine package already present)
         shell: bash
-        run: python -m pip install --no-deps ./python/rapier-testbed
+        run: python -m pip install --no-deps ./bindings/python/rapier-testbed
       - name: Smoke (import surface)
-        run: python -m pytest python/tests/test_smoke.py python/tests/test_math.py -v
+        run: python -m pytest bindings/python/tests/test_smoke.py bindings/python/tests/test_math.py -v
       - name: Full test suite
-        run: python -m pytest python/tests/ -q --timeout=120
+        run: python -m pytest bindings/python/tests/ -q --timeout=120
diff --git a/.github/workflows/python-wheels.yml b/.github/workflows/python-wheels.yml
index 64d01506e..68b8aa585 100644
--- a/.github/workflows/python-wheels.yml
+++ b/.github/workflows/python-wheels.yml
@@ -22,7 +22,7 @@ on:
   pull_request:
     branches: [master]
     paths:
-      - "python/**"
+      - "bindings/python/**"
       - ".github/workflows/python-wheels.yml"
   workflow_dispatch:
 
@@ -53,7 +53,7 @@ jobs:
           command: build
           target: ${{ matrix.platform.target }}
           manylinux: ${{ matrix.platform.manylinux }}
-          args: --release --out dist -m python/${{ matrix.package.dir }}/Cargo.toml
+          args: --release --out dist -m bindings/python/${{ matrix.package.dir }}/Cargo.toml
           sccache: "true"
       - uses: actions/upload-artifact@v4
         with:
diff --git a/.github/workflows/rapier-ci-build.yml b/.github/workflows/rapier-ci-build.yml
index 2724fb166..aa259fddc 100644
--- a/.github/workflows/rapier-ci-build.yml
+++ b/.github/workflows/rapier-ci-build.yml
@@ -312,7 +312,7 @@ jobs:
         run: cd website/docs-examples && cargo test
   # Checks the JavaScript documentation snippets build against the in-tree bindings, so a
   # snippet may use an API before it is released on npm. The snippet package depends on
-  # `typescript/builds/rapier{2,3}d/pkg` through a `file:` path, which this job builds first
+  # `bindings/typescript/builds/rapier{2,3}d/pkg` through a `file:` path, which this job builds first
   # (the same two steps a local checkout runs).
   website-javascript-snippets:
     runs-on: ubuntu-latest
@@ -323,14 +323,14 @@ jobs:
       - uses: actions/checkout@v4
       - uses: Swatinem/rust-cache@v2
         with:
-          workspaces: typescript
+          workspaces: bindings/typescript
       - name: Generate the binding crates
-        working-directory: ./typescript
+        working-directory: ./bindings/typescript
         run: |
           npm ci
           cargo run -p prepare_builds -- -d dim${{ matrix.dimension == '2d' && '2' || '3' }} -f non-deterministic
       - name: Build the in-tree bindings
-        working-directory: ./typescript/builds/rapier${{ matrix.dimension }}
+        working-directory: ./bindings/typescript/builds/rapier${{ matrix.dimension }}
         run: |
           npm i
           npm run build:wasm
diff --git a/.github/workflows/typescript-bindings.yml b/.github/workflows/typescript-bindings.yml
index 416bdae7d..b0251380e 100644
--- a/.github/workflows/typescript-bindings.yml
+++ b/.github/workflows/typescript-bindings.yml
@@ -9,21 +9,21 @@ on:
         # the `paths` list below only ever gates the `master` pushes.
         tags: ["js-v*"]
         paths:
-            - "typescript/**"
+            - "bindings/typescript/**"
             - ".github/workflows/typescript-bindings.yml"
     pull_request:
         branches: [master]
         paths:
-            - "typescript/**"
+            - "bindings/typescript/**"
             - ".github/workflows/typescript-bindings.yml"
     workflow_dispatch:
 
 env:
     CARGO_TERM_COLOR: always
 
-# The JS/Wasm bindings live under `typescript/`, which is a self-contained Cargo
-# workspace (it pulls `rapier2d`/`rapier3d` from crates.io, not from the crates
-# in this repo). Every step therefore runs inside that directory.
+# The JS/Wasm bindings live under `bindings/typescript/`, which is a self-contained Cargo
+# workspace (its `[patch.crates-io]` builds `rapier2d`/`rapier3d` from the crates
+# of this repo). Every step therefore runs inside that directory.
 
 # Never cancel a run that can publish: interrupting the `publish` job partway
 # leaves some of the twelve packages released and the rest missing.
@@ -36,7 +36,7 @@ jobs:
         runs-on: ubuntu-latest
         defaults:
             run:
-                working-directory: typescript
+                working-directory: bindings/typescript
         steps:
             - uses: actions/checkout@v4
             - uses: actions/setup-node@v4
@@ -54,7 +54,7 @@ jobs:
         runs-on: ${{ matrix.os }}
         defaults:
             run:
-                working-directory: typescript
+                working-directory: bindings/typescript
         env:
             RUSTFLAGS: -D warnings
         steps:
@@ -66,8 +66,8 @@ jobs:
                       ~/.cargo/registry/index/
                       ~/.cargo/registry/cache/
                       ~/.cargo/git/db/
-                      typescript/target/
-                  key: ${{ runner.os }}-cargo-js-${{ hashFiles('typescript/builds/prepare_builds/templates/Cargo.toml.tera') }}
+                      bindings/typescript/target/
+                  key: ${{ runner.os }}-cargo-js-${{ hashFiles('bindings/typescript/builds/prepare_builds/templates/Cargo.toml.tera') }}
                   restore-keys: |
                       ${{ runner.os }}-cargo-js-
             - run: npm ci;
@@ -101,7 +101,7 @@ jobs:
               with:
                   name: pkg no-compat ${{ matrix.os }}
                   path: |
-                      typescript/builds/*/pkg
+                      bindings/typescript/builds/*/pkg
                   overwrite: true
     build-compat:
         strategy:
@@ -110,7 +110,7 @@ jobs:
         runs-on: ${{ matrix.os }}
         defaults:
             run:
-                working-directory: typescript
+                working-directory: bindings/typescript
         env:
             RUSTFLAGS: -D warnings
         steps:
@@ -122,8 +122,8 @@ jobs:
                       ~/.cargo/registry/index/
                       ~/.cargo/registry/cache/
                       ~/.cargo/git/db/
-                      typescript/target/
-                  key: ${{ runner.os }}-cargo-js-${{ hashFiles('typescript/builds/prepare_builds/templates/Cargo.toml.tera') }}
+                      bindings/typescript/target/
+                  key: ${{ runner.os }}-cargo-js-${{ hashFiles('bindings/typescript/builds/prepare_builds/templates/Cargo.toml.tera') }}
                   restore-keys: |
                       ${{ runner.os }}-cargo-js-
             - run: npm ci;
@@ -161,7 +161,7 @@ jobs:
               with:
                   name: pkg compat ${{ matrix.os }}
                   path: |
-                      typescript/rapier-compat/builds/*/pkg
+                      bindings/typescript/rapier-compat/builds/*/pkg
                   overwrite: true
     # Publishes with npm Trusted Publishing: instead of a long-lived `NPM_TOKEN`,
     # npm mints a short-lived credential from the GitHub OIDC token of this very
@@ -186,17 +186,17 @@ jobs:
             id-token: write
         defaults:
             run:
-                working-directory: typescript
+                working-directory: bindings/typescript
         steps:
             - uses: actions/checkout@v4
             - uses: actions/download-artifact@v4
               with:
                   name: pkg no-compat ubuntu-latest
-                  path: typescript/builds
+                  path: bindings/typescript/builds
             - uses: actions/download-artifact@v4
               with:
                   name: pkg compat ubuntu-latest
-                  path: typescript/rapier-compat/builds
+                  path: bindings/typescript/rapier-compat/builds
             # No `registry-url`: that would write an `.npmrc` expecting a
             # `NODE_AUTH_TOKEN`, which trusted publishing replaces.
             - uses: actions/setup-node@v4
diff --git a/.gitignore b/.gitignore
index d3617f5f6..8a8e1f896 100644
--- a/.gitignore
+++ b/.gitignore
@@ -14,10 +14,10 @@ package-lock.json
 # Python bindings: compiled extension modules that `maturin develop` stages
 # next to each package's Python sources (e.g. `_rapier3d.abi3.so`) and the
 # Sphinx build output.
-python/rapier-py-*/python/**/_rapier*.so
-python/rapier-py-*/python/**/_rapier*.pyd
-python/rapier-py-*/python/**/_rapier*.dylib
-python/docs/_build/
+bindings/python/rapier-py-*/python/**/_rapier*.so
+bindings/python/rapier-py-*/python/**/_rapier*.pyd
+bindings/python/rapier-py-*/python/**/_rapier*.dylib
+bindings/python/docs/_build/
 **/__pycache__/
 *.pyc
 *.egg-info/
diff --git a/.run/Check_typescript_bindings__offline_.run.xml b/.run/Check_typescript_bindings__offline_.run.xml
index 5b0ee15a6..2425c2663 100644
--- a/.run/Check_typescript_bindings__offline_.run.xml
+++ b/.run/Check_typescript_bindings__offline_.run.xml
@@ -2,7 +2,7 @@
   <configuration default="false" name="Check typescript bindings (offline)" type="CargoCommandRunConfiguration" factoryName="Cargo Command" folderName="Bindings">
     <option name="buildProfileId" value="dev" />
     <option name="command" value="check --offline" />
-    <option name="workingDirectory" value="file://$PROJECT_DIR$/typescript" />
+    <option name="workingDirectory" value="file://$PROJECT_DIR$/bindings/typescript" />
     <envs />
     <option name="emulateTerminal" value="true" />
     <option name="channel" value="DEFAULT" />
diff --git a/CHANGELOG.md b/CHANGELOG.md
index 96ff52223..2169713c5 100644
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@@ -9,6 +9,12 @@
 - `rapier3d-mjcf`: `MjcfContactHooks::is_excluded` and `MjcfContactHooks::pair_override` to query the
   contact rules of a model.
 
+### Modified
+
+- The C, Python, and JavaScript/TypeScript bindings moved to the `bindings/` directory.
+- The `bevy_rapier2d` and `bevy_rapier3d` plugins now live in this repository, in `bindings/bevy_rapier`, and
+  build against the in-tree rapier crates.
+
 ### Fixed
 
 - `CollisionPipeline::step` no longer trips a debug assertion when a moving body touches another
diff --git a/CONTRIBUTING.md b/CONTRIBUTING.md
index 8cb3ffa56..6fc33a6e2 100644
--- a/CONTRIBUTING.md
+++ b/CONTRIBUTING.md
@@ -13,8 +13,8 @@ features.
 
 
 ## Contributing to the Rust code
-The Rust source code of the Rapier physics engines is available  on our `rapier` repository
-[on GitHub](https://github.com/dimforge/rapier.rs).
+The Rust source code of the Rapier physics engines is available on our `rapier` repository
+[on GitHub](https://github.com/dimforge/rapier).
 
 1. Fork our `rapier` repository [on GitHub](https://github.com/dimforge/rapier).
 2. Clone the repository and make the necessary changes.
@@ -30,44 +30,46 @@ The Rust source code of the Rapier physics engines is available  on our `rapier`
 6. Iterate with the reviewer until the PR gets merged.
 
 ## Contributing to the user-guide [rapier](https://rapier.rs)
-The [official website](https://rapier.rs) for Rapier is built with [Docusaurus 2](https://docusaurus.io/).
-Its source code can be found on our `rapier.rs` repository [on GitHub](https://github.com/dimforge/rapier.rs).
-If you  find a typo or some outdated information on the website, please don't hesitate to reach
+The [official website](https://rapier.rs) for Rapier is built with [Docusaurus 3](https://docusaurus.io/).
+Its source code can be found in the [`website/`](website/) directory of the `rapier` repository: the user guide is
+written once in `website/docs/user_guides/templates`, and its code snippets are compiled from
+`website/docs-examples` (see the [website README](website/README.md)).
+If you find a typo or some outdated information on the website, please don't hesitate to reach
 out! We can't stress enough how helpful it is for you to report (or fix) typo errors.
 
 If you would like to fix it yourself, here is the procedure:
 
-1. Fork our `rapier.rs` repository [on GitHub](https://github.com/dimforge/rapier.rs).
+1. Fork our `rapier` repository [on GitHub](https://github.com/dimforge/rapier).
 2. Clone the repository and make the necessary changes.
 3. In order to debug your changes and check that it works, do the following:
     - `cd website; yarn install; yarn start;` This will open the website on your browser locally.
       The default local address is http://localhost:3000 .
-4. Once you are satisfied with your changes, submit them by [opening a Pull Request](https://github.com/dimforge/rapier.rs/pulls) on GitHub.
+    - If you changed a code snippet, check that it still compiles, e.g., with `cd website/docs-examples; cargo test`
+      for the Rust snippets (see the [docs-examples README](website/docs-examples/README.md) for the other languages).
+4. Once you are satisfied with your changes, submit them by [opening a Pull Request](https://github.com/dimforge/rapier/pulls) on GitHub.
 5. If that Pull Request does something you need urgently, or if you think it has been forgotten, don't hesitate
    to ask **@sebcrozet** directly [on Discord][discord] for a review.
 6. Iterate with the reviewer until the PR gets merged.
 
-## Contributing to the JavaScript/TypeScript bindings
-The source code of the official JavaScript/TypeScript bindings for Rapier are available
-on our `rapier.js` repository [on GitHub](https://github.com/dimforge/rapier.js).
+## Contributing to the bindings and the Bevy plugin
+The official bindings and the Bevy plugin live in the [`bindings/`](bindings/) directory of the `rapier` repository:
+- [`bindings/typescript`](bindings/typescript): the JavaScript/TypeScript bindings. You will need
+  [wasm-pack](https://github.com/rustwasm/wasm-pack) to build them; see its [README](bindings/typescript/README.md).
+- [`bindings/c`](bindings/c): the C and C++ bindings; see its [README](bindings/c/README.md).
+- [`bindings/python`](bindings/python): the Python bindings; see its [README](bindings/python/README.md).
+- [`bindings/bevy_rapier`](bindings/bevy_rapier): the `bevy_rapier2d` and `bevy_rapier3d` plugins for the
+  [Bevy](https://bevyengine.org) game engine. They build against the rapier crates of this repository.
 
-You will have to make sure that you have [wasm-pack](https://github.com/rustwasm/wasm-pack) installed because
-it is responsible for generating the low-level bindings. In order to modify the bindings and test your
-changes you may:
+The procedure is the same as for the Rust code:
 
-1. Fork our `rapier.js` repository [on GitHub](https://github.com/dimforge/rapier.js).
+1. Fork our `rapier` repository [on GitHub](https://github.com/dimforge/rapier).
 2. Clone the repository and make the necessary changes.
-3. In order to debug your changes and check that it works, do the following for the 3D version of rapier (the procedure
-   for the 2D version is similar):
-   - `cd rapier3d; npm install; ./build_all.sh`. This will build the JS bindings, TS type definitions, and generate
-      the documentation. This will take several minutes to complete.
-   - After making changes to the Rust code on that repository, you need to run `./build_rust.sh`.
-   - After making changes to the TypeScript code on that repository, you need to run `./build_typescript.sh`.
-   - To test your changes, go back to the repository's root directory, and do: `cd testbed3d; npm install; npm link ../rapier3d/pkg; npm run start`.
-     This will open the 3D examples on your browser.
-   - Our build system for these JS bindings is still a bit messy right now. If you have any trouble, don't
-     hesitate to contact us [on Discord][discord].
-4. Once you are satisfied with your changes, submit them by [opening a Pull Request](https://github.com/dimforge/rapier.js/pulls) on GitHub.
+3. In order to debug your changes and check that it works:
+   - JavaScript: from `bindings/typescript`, build the packages (see its README), then run the 3D examples with
+     `cd testbed3d; npm install; npm run start` (the procedure for the 2D version is similar).
+   - Bevy: from `bindings/bevy_rapier`, run the tests with `cargo test` and the examples with, e.g.,
+     `cargo run --release -p bevy_rapier3d --example boxes3`.
+4. Once you are satisfied with your changes, submit them by [opening a Pull Request](https://github.com/dimforge/rapier/pulls) on GitHub.
 5. If that Pull Request does something you need urgently, or if you think it has been forgotten, don't hesitate
    to ask **@sebcrozet** directly [on Discord][discord] for a review.
 6. Iterate with the reviewer until the PR gets merged.
diff --git a/Cargo.toml b/Cargo.toml
index 48cd43870..df0682c40 100644
--- a/Cargo.toml
+++ b/Cargo.toml
@@ -1,11 +1,11 @@
 [workspace]
 members = [
-    "c/testbed/tools/logo-mesh",
-    "c/rapier-c-macros",
-    "c/rapier2d-ffi",
-    "c/rapier3d-ffi",
-    "c/rapier2d-f64-ffi",
-    "c/rapier3d-f64-ffi",
+    "bindings/c/testbed/tools/logo-mesh",
+    "bindings/c/rapier-c-macros",
+    "bindings/c/rapier2d-ffi",
+    "bindings/c/rapier3d-ffi",
+    "bindings/c/rapier2d-f64-ffi",
+    "bindings/c/rapier3d-f64-ffi",
     "crates/rapier2d",
     "crates/rapier2d-f64",
     "crates/rapier_testbed2d",
@@ -21,7 +21,7 @@ members = [
     "crates/rapier3d-meshloader",
     "crates/mjcf-rs",
     "crates/rapier3d-mjcf",
-    "python/rapier-py-3d",
+    "bindings/python/rapier-py-3d",
 ]
 # Bare `cargo build` / `cargo test` / `cargo clippy` only touches the
 # pure-Rust crates. The Python-binding crates need a Python build env
@@ -46,9 +46,9 @@ default-members = [
     "crates/mjcf-rs",
     "crates/rapier3d-mjcf",
 ]
-# `typescript/` is the JS/Wasm bindings' own Cargo workspace; keep it out of
-# this one so root-level `cargo` commands never try to absorb its crates.
-exclude = ["typescript"]
+# `bindings/typescript/` and `bindings/bevy_rapier/` have their own Cargo workspaces; keep them out of
+# this one so root-level `cargo` commands never try to absorb their crates.
+exclude = ["bindings/typescript", "bindings/bevy_rapier"]
 resolver = "2"
 
 [workspace.package]
diff --git a/README.md b/README.md
index d8a189776..57a45c700 100644
--- a/README.md
+++ b/README.md
@@ -54,13 +54,14 @@ The easiest way to get started with Rapier is to:
 | Variant | Examples | User-guide snippets |
 | --- | --- | --- |
 | Rust | [`examples2d/`](examples2d/), [`examples3d/`](examples3d/), [`examples3d-f64/`](examples3d-f64/) | [2D](website/docs-examples/2d/rust/examples/), [3D](website/docs-examples/3d/rust/examples/) |
-| C | [`c/examples/`](c/examples/), testbed scenes in [`c/testbed/examples2d/`](c/testbed/examples2d/) and [`c/testbed/examples3d/`](c/testbed/examples3d/) | [2D](website/docs-examples/2d/c/examples/), [3D](website/docs-examples/3d/c/examples/) |
-| JavaScript | testbed demos in [`typescript/testbed2d/src/demos/`](typescript/testbed2d/src/demos/) and [`typescript/testbed3d/src/demos/`](typescript/testbed3d/src/demos/) | [2D](website/docs-examples/2d/javascript/src/snippets/), [3D](website/docs-examples/3d/javascript/src/snippets/) |
-| Python | [`python/examples/`](python/examples/), testbed scenes in [`python/rapier-testbed/rapier_testbed/examples3/`](python/rapier-testbed/rapier_testbed/examples3/) | [3D](website/docs-examples/3d/python/) |
-| Bevy plugin | [`bevy_rapier2d/examples/`](https://github.com/dimforge/bevy_rapier/tree/master/bevy_rapier2d/examples) and [`bevy_rapier3d/examples/`](https://github.com/dimforge/bevy_rapier/tree/master/bevy_rapier3d/examples) in the [bevy_rapier](https://github.com/dimforge/bevy_rapier) repository | [2D](website/docs-examples/2d/bevy/examples/), [3D](website/docs-examples/3d/bevy/examples/) |
+| C | [`bindings/c/examples/`](bindings/c/examples/), testbed scenes in [`bindings/c/testbed/examples2d/`](bindings/c/testbed/examples2d/) and [`bindings/c/testbed/examples3d/`](bindings/c/testbed/examples3d/) | [2D](website/docs-examples/2d/c/examples/), [3D](website/docs-examples/3d/c/examples/) |
+| JavaScript | testbed demos in [`bindings/typescript/testbed2d/src/demos/`](bindings/typescript/testbed2d/src/demos/) and [`bindings/typescript/testbed3d/src/demos/`](bindings/typescript/testbed3d/src/demos/) | [2D](website/docs-examples/2d/javascript/src/snippets/), [3D](website/docs-examples/3d/javascript/src/snippets/) |
+| Python | [`bindings/python/examples/`](bindings/python/examples/), testbed scenes in [`bindings/python/rapier-testbed/rapier_testbed/examples3/`](bindings/python/rapier-testbed/rapier_testbed/examples3/) | [3D](website/docs-examples/3d/python/) |
+| Bevy plugin | [`bindings/bevy_rapier/bevy_rapier2d/examples/`](bindings/bevy_rapier/bevy_rapier2d/examples/) and [`bindings/bevy_rapier/bevy_rapier3d/examples/`](bindings/bevy_rapier/bevy_rapier3d/examples/) | [2D](website/docs-examples/2d/bevy/examples/), [3D](website/docs-examples/3d/bevy/examples/) |
 
 The user-guide snippets are the code shown in the [user guide](https://rapier.rs/docs/): they are compiled (and, for
-C and Python, run) to make sure the guide stays up to date.
+C and Python, run) to make sure the guide stays up to date. The bindings and the Bevy plugin live in the
+[`bindings/`](bindings/) directory.
 
 ## Performance
 
@@ -82,20 +83,20 @@ rapier3d = { version = "*", features = ["parallel"] }
 
 ## C and C++ bindings
 
-See [`c/README.md`](c/README.md) for the C ABI, C++ ownership helpers, native build instructions,
+See [`bindings/c/README.md`](bindings/c/README.md) for the C ABI, C++ ownership helpers, native build instructions,
 and Unity/Unreal integration guidance. The bindings cover 2D/3D and f32/f64, including soft bodies.
 
 ## Python bindings
 
 The Python bindings ship as a single package, `rapier3d`, wrapping the 3D engine with 32-bit floats (there
-are no 2D or f64 Python bindings yet). See [`python/README.md`](python/README.md) for how to build the bindings,
-the docs, and the testbed from a checkout, [`python/docs/`](python/docs/) for the API documentation, and the
+are no 2D or f64 Python bindings yet). See [`bindings/python/README.md`](bindings/python/README.md) for how to build the bindings,
+the docs, and the testbed from a checkout, [`bindings/python/docs/`](bindings/python/docs/) for the API documentation, and the
 [user guide](https://rapier.rs/docs/) for its Python version.
 
 ## AI coding disclaimer and policy
 
 AI coding is extensively used for the implementation and maintenance of the following crates: `mjcf-rs`,
-`rapier3d-mjcf`, as well as the Python bindings (`python/rapier-py*`), including their tests, examples, and docs.
+`rapier3d-mjcf`, as well as the Python bindings (`bindings/python/rapier-py*`), including their tests, examples, and docs.
 
 We actively use AI assistance (with human reviews) for the following tasks:
 - Documentation generation.
diff --git a/bindings/bevy_rapier/.gitignore b/bindings/bevy_rapier/.gitignore
new file mode 100644
index 000000000..307a8f812
--- /dev/null
+++ b/bindings/bevy_rapier/.gitignore
@@ -0,0 +1,4 @@
+/target
+Cargo.lock
+.idea
+.vscode/settings.json
diff --git a/bindings/bevy_rapier/CHANGELOG.md b/bindings/bevy_rapier/CHANGELOG.md
new file mode 100644
index 000000000..ba6707c52
--- /dev/null
+++ b/bindings/bevy_rapier/CHANGELOG.md
@@ -0,0 +1,698 @@
+# Changelog
+
+## Unreleased
+
+### Modified
+
+- Update from rapier `0.33.0-alpha` to rapier `0.35.0-glamx0.2`.
+  See [rapier's changelog](https://github.com/dimforge/rapier/blob/master/CHANGELOG.md) for details.
+  - Removed the `simd-stable` and `simd-nightly` features: SIMD is now always enabled in rapier.
+    The new `simd8` feature widens the solver’s SIMD from 4 to 8 lanes (f32 only, incompatible
+    with `enhanced-determinism`).
+  - `SolverContactView::{friction, restitution}` now read from the contact manifold data (rapier
+    stores them per-manifold), and `SolverContactView::point` is reconstructed from the body-local
+    contact anchors; the public API is preserved.
+  - Custom event handlers assigned to `RapierContextSimulation` must now be `Send + Sync`.
+- Known issue: the `enhanced-determinism` feature currently fails to compile with bevy, because
+  parry enables `glam/scalar-math` which removes the serde impls of `glam::BVec3A`/`BVec4A` that
+  `bevy_reflect` requires unconditionally.
+
+## v0.35.0 (12 July 2026)
+
+### Modified
+
+- Update to bevy 0.19.
+
+## v0.34.0 (14 May 2026)
+
+### Added
+
+- New `change_contexts3` 3D example demonstrating how to move an entity between physics contexts.
+  [#684](https://github.com/dimforge/bevy_rapier/pull/684)
+
+### Modified
+
+- Update from rapier `0.31` to rapier `0.32`. [#692](https://github.com/dimforge/bevy_rapier/pull/692)
+  See [rapier's changelog](https://github.com/dimforge/rapier/blob/master/CHANGELOG.md) for details.
+  - Most `Collider`, joint, and query-pipeline APIs now take `glam` vectors/rotations directly instead of
+    nalgebra `Point`s/`Isometry`s. For example, `Collider::capsule`, `Collider::segment`,
+    `Collider::triangle`, `Collider::voxels`, `RapierQueryPipeline::cast_ray`, `project_point`,
+    `intersect_shape`, `cast_shape`, etc. no longer require `.into()` conversions on input vectors.
+  - `TransformInterpolation::{start, end}` are now `Option<Pose>` instead of `Option<Isometry<f32>>`.
+  - `iso_to_transform` now takes a `&Pose` instead of `&Isometry<Real>`.
+  - `SolverContactView::is_new` now compares an internal float; the public boolean API is preserved.
+  - `ContactPairView::has_any_active_contact` is now a method call on the underlying contact pair.
+- Renamed `Velocity` fields: `linvel` → `linear` and `angvel` → `angular`.
+  [#690](https://github.com/dimforge/bevy_rapier/pull/690)
+
+### Fix
+
+- Fix context swapping failing when physics runs in a schedule other than `PostUpdate`: a stray run
+  of `sync_removals` was removing handles that had just been added.
+  [#684](https://github.com/dimforge/bevy_rapier/pull/684)
+
+## v0.33.0 (06 March 2026)
+
+### Modified
+
+- Update Bevy to `0.18`. [#686](https://github.com/dimforge/bevy_rapier/pull/686)
+  - Examples now require the `bevy_gizmos_render` feature.
+  - The testbed examples moved their UI systems to the new `EguiPrimaryContextPass` schedule.
+
+## v0.32.0 (24 February 2026)
+
+### Added
+
+- Reflection support for `SpringCoefficients` (used by the new contact softness parameters) and, in 3D,
+  for `FrictionModel` (`Simplified` / `Coulomb`). [#680](https://github.com/dimforge/bevy_rapier/pull/680)
+- New `voxels2_no_collider` 2D example demonstrating `Voxels` shapes without a collider.
+  [#680](https://github.com/dimforge/bevy_rapier/pull/680)
+
+### Modified
+
+- Update Bevy to `0.17.3`. [#680](https://github.com/dimforge/bevy_rapier/pull/680)
+  - Migrated from Bevy's `Event`/`Events`/`EventReader`/`EventWriter` to the new
+    `Message`/`Messages`/`MessageReader`/`MessageWriter` API. `CollisionEvent`, `ContactForceEvent`,
+    and `MassModifiedEvent` now derive `Message` instead of `Event`.
+  - Renamed `TransformSystem::TransformPropagate` usages to `TransformSystems::Propagate`.
+  - `PickSet` → `PickingSystems` for the picking backend.
+- Update from rapier `0.27` to rapier `0.31`. [#680](https://github.com/dimforge/bevy_rapier/pull/680)
+  See [rapier's changelog](https://github.com/dimforge/rapier/blob/master/CHANGELOG.md) for details.
+  - `IntegrationParametersWrapper` reflection now exposes `contact_softness` (a `SpringCoefficients`),
+    `warmstart_coefficient`, and `length_unit`, replacing the previous `contact_damping_ratio` and
+    `contact_natural_frequency` fields.
+
+## v0.31.0 (04 August 2025)
+
+### Added
+
+- Expose `RapierBevyComponentApply`, to help with creating your own schedules when you set `default_system_setup` to `false`.
+- Add `set_local_axis1` and `set_local_axis2` to `RevoluteJoint` and `RevoluteJointBuilder`. [#666](https://github.com/dimforge/bevy_rapier/pull/666)
+
+### Modified
+
+- Update from rapier `0.25` to rapier `0.27`,
+  see [rapier's changelog](https://github.com/dimforge/rapier/blob/master/CHANGELOG.md).
+  - `RapierQueryPipeline` is no longer a component.
+    - Migration: Use `RapierContext` or retrieve the needed components to pass to `RapierQueryPipeline::new_scoped` and make your logic in a scoped function. This function allows capturing and returning information.
+  - a new `QueryPipelineMut`  to provide the same API as rapier. It's currently used for the character controller.
+
+### Fix
+
+- Fix scale being applied with a frame delay. [#659](https://github.com/dimforge/bevy_rapier/pull/659)
+
+## v0.30.0 (15 May 2025)
+
+### Added
+
+- Added a serialization `serialization2` example for `bevy_rapier2d`.
+- Added reflection for `Default` in addition to `Component`. [#649](https://github.com/dimforge/bevy_rapier/pull/649)
+
+### Modified
+
+- Update Bevy to `0.16`.
+- Update from rapier `0.23` to rapier `0.25`,
+  see [rapier's changelog](https://github.com/dimforge/rapier/blob/master/CHANGELOG.md).
+  - Notably, support and examples for parry's new `Voxels` shape have been added.
+- `RapierContextInitialization::InitializeDefaultRapierContext` now has more fields for better control over default physics context.
+- `ContactPairView::collider1` and `ContactPairView::collider2` now return an `Option`.
+
+### Fix
+
+- Fix position being incorrect when a rigidbody bevy entity has a scaled parent. [#646](https://github.com/dimforge/bevy_rapier/pull/646)
+
+## v0.29.0 (18 February 2025)
+
+### Added
+
+- Added optional feature `picking-backend` to support bevy_picking.
+  - See `picking_backend` module documentation for more details.
+- Added `geometry::to_bevy_mesh` module behind the feature `to-bevy-mesh` to help with converting parry shapes into bevy meshes (#628).
+  - Lines, round and custom shapes are not implemented.
+
+### Modified
+
+- Update from rapier `0.22` to rapier `0.23`,
+  see [rapier's changelog](https://github.com/dimforge/rapier/blob/master/CHANGELOG.md).
+- `Collider::trimesh` and `Collider::trimesh_with_flags` now return a `Result`.
+- Under the feature `async-collider`, The `RapierPhysicsPlugin` now adds
+  `AssetPlugin`, `MeshPlugin` and `ScenePlugin` if these were not added, to circumvent a runtime crash
+  over missing required resources.
+- `RapierPhysicsPlugin` can be customized through `with_physics_sets_systems` to opt out of default systems from `PhysicsSet`.
+- `RapierContext` has been split in multiple `Component`s:
+  - `RapierContextColliders`
+  - `RapierContextJoints`
+  - `RapierContextSimulation`
+  - `RapierRigidBodySet`
+- Renamed `DefaultReadRapierContext` to `ReadRapierContext` and `DefaultWriteRapierContext` to `WriteRapierContext`.
+  They have a new `bevy::QueryFilter` type parameter, defaulting to `With<DefaultRapierContext>`.
+
+## v0.28.0 (09 December 2024)
+
+### Modified
+
+- Update from rapier `0.21` to rapier `0.22`,
+  see [rapier's changelog](https://github.com/dimforge/rapier/blob/master/CHANGELOG.md).
+- Update bevy to 0.15.
+- `RapierContext`, `RapierConfiguration` and `SimulationToRenderTime` are now a `Component` instead of resources.
+  - Rapier now supports multiple independent physics worlds, see example `multi_world3` for usage details.
+  - Migration guide:
+    - `ResMut<mut RapierContext>` -> `WriteDefaultRapierContext`
+    - `Res<RapierContext>` -> `ReadDefaultRapierContext`
+    - Access to `RapierConfiguration` and `SimulationToRenderTime` should query for it
+on the responsible entity owning the `RenderContext`.
+  - If you are building a library on top of `bevy_rapier` and would want to support multiple independent physics worlds too,
+you can check out the details of [#545](https://github.com/dimforge/bevy_rapier/pull/545)
+to get more context and information.
+- `colliders_with_aabb_intersecting_aabb` now takes `bevy::math::bounding::Aabb3d` (or `[..]::Aabb2d` in 2D) as parameter.
+  - it is now accessible with `headless` feature enabled.
+
+### Fix
+
+- Fix a crash when using `TimestepMode::Interpolated` and removing colliders
+during a frame which would not run a simulation step.
+
+### Added
+
+- Added a `TriMeshFlags` parameter for `ComputedColliderShape`,
+its default value is `TriMeshFlags::MERGE_DUPLICATE_VERTICES`,
+which was its hardcoded behaviour.
+- Added a way to configure which colliders should be debug rendered: `global` parameter for both 
+  `RapierDebugColliderPlugin` and `DebugRenderContext`, as well as individual collider setup via
+  a `ColliderDebug` component.
+
+## v0.27.0 (07 July 2024)
+
+**This is an update from rapier 0.19 to Rapier 0.21 which includes several stability improvements
+and new features. Please have a look at the
+[0.20 and 0.21 changelogs](https://github.com/dimforge/rapier/blob/master/CHANGELOG.md) of Rapier.**
+
+### Modified
+
+- Update from rapier `0.19` to rapier `0.21`.
+- Update to nalgebra `0.33`.
+- Update to bevy `0.14`.
+- Renamed `has_any_active_contacts` to `has_any_active_contact` for better consistency with rapier.
+- `ColliderDebugColor`'s property is now a `bevy::color::Hsla`.
+- `ImpulseJoint::data` and `MultibodyJoint::data` are now a more detailed enum `TypedJoint` instead of a `GenericJoint`.
+You can still access its inner `GenericJoint` with `.as_ref()` or `as_mut()`.
+- `data` fields from all joints (`FixedJoint`, …) are now public, and their getters removed.
+
+### Added
+
+- Derive `Debug` for `LockedAxes`.
+- Expose `is_sliding_down_slope` to both `MoveShapeOutput` and `KinematicCharacterControllerOutput`.
+- Added a First Person Shooter `character_controller` example for `bevy_rapier3d`.
+- Added serialization support for `CollisionGroups`, `SolverGroups`, `ContactForceEventThreshold`, `ContactSkin`.
+- Added `RapierContext::context.impulse_revolute_joint_angle` to compute the angle along a revolute joint’s principal axis.
+
+### Fix
+
+- Fix rigidbodies never going to sleep when a scale was applied to their `Transform`.
+- Fix losing information about hit details when converting from `ShapeCastHit` in parry to `ShapeCastHit` in bevy_rapier
+
+## v0.26.0 (05 May 2024)
+
+**This is an update to Rapier 0.19 which includes several stability improvements
+and character-controller fix. Please have a look at the
+[0.19 changelog](https://github.com/dimforge/rapier/blob/master/CHANGELOG.md) of Rapier.**
+
+### Modified
+
+- Renamed `Toi/ToiDetails` to `ShapeCastHit/ShapeCastHitDetails`.
+- Switch to rapier’s built-in `length_unit` instead of explicitly scaling shapes with `physics_scale`.
+- Linear shape-casting functions now take a `ShapeCastOptions` parameter that describes how the shape-cast should
+  behave on special-cases (like toi == 0).
+- Internal edge correction is now opt-in with the `TriMeshFlags::FIX_INTERNAL_EDGES` and
+  `HeightFieldFlags::FIX_INTERNAL_EDGES` flags.
+- Rename `RayIntersection::toi` to `RayIntersection::time_of_impact`.
+
+### Fix
+
+- Fix character controller occasionally getting stuck against vertical walls.
+
+### Added
+
+- Add the `SoftCcd` (for rigid-bodies) and `ContactSkin` (for colliders) components. See
+  [rapier#625](https://github.com/dimforge/rapier/pull/625) for details on the features they enable.
+
+## v0.25.0 (19 Feb. 2024)
+
+### Modified
+
+- Update to bevy `0.13`.
+
+## v0.24.0 (27 Jan. 2024)
+
+The main highlight of this release is the implementation of a new non-linear constraints solver for better stability
+and increased convergence rates. See [#579](https://github.com/dimforge/rapier/pull/579) for additional information.
+
+In order to adjust the number of iterations of the new solver, simply
+adjust `IntegrationParameters::num_solver_iterations`.
+If recovering the old solver behavior is useful to you, call `IntegrationParameters::switch_to_standard_pgs_solver()`.
+
+It is now possible to specify some additional solver iteration for specific rigid-bodies (and everything interacting
+with it directly or indirectly through contacts and joints) by adding the `AdditionalSolverIterations` component to the
+same entity as the rigid-body. This allows for higher-accuracy on subsets of the physics scene without affecting
+performance of the other parts of the simulation.
+
+### Fix
+
+- Fix bug causing angular joint limits and motor to sometimes only take into account half of the angles specified by the
+  user.
+- Fix bug where collisions would not be re-computed after a collider was re-enabled.
+
+### Added
+
+- Add a `SpringJoint` and `SpringJointBuilder` for simulating springs with customizable stiffness and damping
+  coefficients.
+- Fix incorrect update of angular degrees-of-freedoms on spherical multibody joints.
+- Fix debug-renderer showing moved kinematic rigid-bodies only at their initial position.
+
+### Modified
+
+- Rename `RapierContext::contacts_with` to `RapierContext::contact_pairs_with`.
+- Rename `RapierContext::intersections_with` to `RapierContext::intersection_pairs_with`.
+- Collisions between the character controller and sensors are now disabled by default.
+
+## 0.23.0
+
+### Modified
+
+- Update to Bevy 0.12
+
+### Added
+
+- `ColliderView::as_typed_shape` and `::to_shared_shape` to convert a `ColliderView` to a parry’s
+  `TypedShape` or `SharedShape`. The `From` trait has also been implemented accordingly.
+- Implement `Copy` for `ColliderView` and all the other non-mut shape views.
+- Add `RapierContext::rigid_body_colliders` to retrieve all collider entities attached to this rigid-body.
+- Add `RapierPhysicsPlugin::in_fixed_schedule`/`::in_schedude` to add rapier’s systems to a fixed/custom
+  schedule.
+- Re-export `JointAxesMask`, `JointAxis`, `MotorModel`.
+- Implement `Deref` for `ReadMassProperties`.
+- Expose the `stop_at_penetration` parameter of shape-casting, to enable or ignore overlaps at the initial position
+  of the shape.
+
+### Fix
+
+- Fix `RapierContext::integration_parameters::dt` not being updated on non-fixed timestep modes.
+- Fix debug-renderer lagging one frame behind.
+- Fix Collider `Transform` rotation change not being taken into account by the physics engine.
+- Fix automatic update of `ReadMassProperties`.
+
+## 0.22.0 (10 July 2023)
+
+### Modified
+
+- Update to Bevy 0.11.
+- Disabled rigid-bodies are no longer synchronized with the rapier backend.
+- Switch to bevy’s gizmo system for the debug-renderer. This removes the vendored debug lines plugin.
+
+### Added
+
+- Add a joint for simulating ropes: the `RopeJoint`.
+- Add `Velocity::linear_velocity_at_point` to calculate the linear velocity at the given world-space point.
+- Add the `ComputedColliderShape::ConvexHull` variant to automatically calculate the convex-hull of an imported mesh.
+- Implement `Reflect` for the debug-renderer.
+
+### Fix
+
+- Fix broken interpolation for rigid-bodies with the `TransformInterpolation` component.
+- Fix compilation when `bevy_rapier` is being used with headless bevy.
+- Improved performance of the writeback system by not iterating on non-rigid-body entities.
+- Fix typo by renaming `CuboidViewMut::sed_half_extents` to `set_half_extents`.
+- Properly scale parented collider’s offset based on changes on its `ColliderScale`.
+
+## 0.21.0  (07 March 2023)
+
+### Modified
+
+- Update to Bevy 0.10.
+- The `PhysicsHooksWithQuery` trait has been renamed to by the `BevyPhysicsHooks`.
+- Bevy resources and queries accessed by the physics hook are now specified by the implementer of `BevyPhysicsHooks`
+  which must derive Bevy’s `SystemParam` trait. This implies that the physics hook’s `filter_contact_pair` (and
+  all its other methods) no longer take the Bevy `Query` as argument. Queries and resources are accessed through
+  `self`.
+- Rename `PhysicsStages` to `PhysicsSet`.
+
+## 0.20.0 (15 Jan. 2023)
+
+### Added
+
+- Add the `RigidBodyDisabled` and `ColliderDisabled` component that can be inserted to disable a rigid-body
+  or collider without removing it from the scene.
+
+### Fix
+
+- Fix spawn position of colliders without rigid bodies.
+- Fix overriding enabled flag in debug render.
+
+### Modified
+
+- Make debug-rendering enabled by default when inserting the `RapierDebugRenderPlugin` plugin with its default
+  configuration.
+- The `debug-render` feature has been replaced by two features: `debug-render-2d` and `debug-render-3d`. For example,
+  using `debug-render-2d` with `bevy_rapier3d`, the debug-render will work with 2D cameras (useful, e.g., for top-down
+  games
+  with 3D graphics).
+- In order to facilitate the use of `bevy_rapier` in headless mode, the `AsyncCollider` and `AsyncSceneCollider`
+  components were moved behind the `async-collider` feature (enabled by default). Disabling that feature will
+  make `bevy_rapier` work even with the `MinimalPlugins` inserted instead of the `DefaultPlugins`.
+- Corrected an API inconsistency where `bevy_rapier` components would sometimes require an `InteracitonGroup` type
+  defined in
+  `rapier`. It has been replaced by the `CollisionGroup` type (defined in `bevy_rapier`).
+- `Velocity::zero,linear,angular` are now const-fn.
+
+## 0.19.0 (18 Nov. 2022)
+
+### Modified
+
+- Update to Bevy 0.9
+
+## 0.18.0 (30 Oct. 2022)
+
+### Added
+
+- Add the accessor `RapierContext::physics_scale()` to read the physics scale
+  that was set when initializing the plugin.
+- Add `RapierConfiguration::force_update_from_transform_changes` to force the transform
+  updates even if it is equal to the transform that was previously set. Useful for
+  rollback in networked applications described in [#261](https://github.com/dimforge/bevy_rapier/pull/261).
+- Add `Collider::trimesh_with_flags` to create a triangle mesh collider with custom pre-processing
+  flags.
+
+### Fix
+
+- Reset the `ExternalImpulse` component after each step automatically.
+- Fix `transform_to_iso` to preserve identical rotations instead of
+  converting to an intermediate axis-angle representation.
+- Fix **internal edges** of 3D triangle meshes or 3D heightfields generating invalid contacts
+  preventing balls from moving straight. Be sure to set the triangle mesh flag
+  `TriMeshFlags::MERGE_DUPLICATE_VERTICES` when creating the collider if your mesh have duplicated
+  vertices.
+
+### Modified
+
+- Rename `AABB` to `Aabb` to comply with Rust’s style guide.
+
+## 0.17.0 (02 Oct. 2022)
+
+### Added
+
+- Add a **kinematic character controller** implementation. This feature is accessible in two different ways:
+    1. The first approach is to insert the `KinematicCharacterController` component to an entity. If the
+       `KinematicCharacterController::custom_shape` field is set, then this shape is used for the character control.
+       If this field is `None` then the `Collider` attached to the same entity as the character controller is used.
+       The character controller will be automatically updated when the `KinematicCharacterController::movement` is set.
+       The result position is written to the `Transform` of the character controller’s entity.
+    2. The second, lower level, approach, is to call `RapierContext::move_shape` to compute the possible movement
+       of a shape, taking obstacle and sliding into account.
+- Add implementations of `Add`, `AddAssign`, `Sub`, `SubAssign` to `ExternalForce` and `ExternalImpulse`.
+- Add `ExternalForce::at_point` and `ExternalImpulse::at_point` to apply a force/impulse at a specific point
+  of a rigid-body.
+
+### Fix
+
+- Fix shapes quickly switching between scaled and non-scaled versions due to rounding errors in the scaling extraction
+  from bevy’s global affine transform.
+
+## 0.16.2 (23 August 2022)
+
+### Added
+
+- Implement `Debug` for `Collider` and `ColliderView`.
+- Add the missing `ActiveEvent::CONTACT_FORCE_EVENTS` to enable contact force events on a collider.
+
+## 0.16.1 (19 August 2022)
+
+### Fixed
+
+- Fix crash of the 2D debug-render on certain platforms (including Metal/MacOS).
+- Fix bug where collision events and contact force events were not cleared automatically.
+- Implement `Reflect` for `AsyncCollider`.
+
+## 0.16.0 (31 July 2022)
+
+### Modified
+
+- Switch to Bevy 0.8.
+
+## 0.15.0 (10 July 2022)
+
+### Fixed
+
+- Fix unpredictable broad-phase panic when using small colliders in the simulation.
+- Fix collision events being incorrectly generated for any shape that produces multiple
+  contact manifolds (like triangle meshes).
+- Fix transform hierarchies not being properly taken into account for colliders with a
+  parent rigid-body.
+- Fix force and impulse application when the `ExternalImpulse` or `ExternalForce` components were added
+  at the same time as the rigid-body creation.
+- Fix sleeping threshold application when these thresholds are set at the same time as the rigid-body
+  creation.
+
+### Added
+
+- Add the `ColliderMassProperties::Mass` variant to let the user specify a collider’s mass directly (instead of its
+  density).
+  As a result the collider’s angular inertia tensor will be automatically be computed based on this mass and its shape.
+- Add the `ContactForceEvent` event. It can be read by a bevy system with the `EventReader<ContactForceEvent>`. This
+  event is useful to read contact forces. A `ContactForceEvent` is generated whenever the sum of the magnitudes of the
+  forces applied by contacts between two colliders exceeds the value specified by the `ContactForceEventThreshold`
+  component.
+- Add the `QueryFilter` struct that is now used by all the scene queries instead of the `CollisionGroups` and
+  `Fn(Entity) -> bool` closure. This `QueryFilter` provides easy access to most common filtering strategies
+  (e.g. dynamic bodies only, excluding one particular entity, etc.) for scene queries.
+- Added some missing serialization of joints.
+- Implement `Default` for `Collider`. It defaults to a `Ball` with radius 0.5.
+- Added a `contacts_enabled` flag to all the joints. If this flag is set to `false` for a joint, no contact will be
+  computed between two colliders attached to rigid-bodies liked by that joint.
+
+### Modified
+
+- The `MassProperties` struct is no longer a `Component`. A common mistake was to assume that `MassProperties` could
+  be used to initialize the mass/angular inertia tensor of a rigid-body. It is not the case. Instead, the user should
+  use the `AdditionalMassProperties` component. The `ReadMassProperties` component has been added to read the mass
+  properties of a rigid-body.
+- The `Sensor` component is now a marker component: if it exists the related collider is a sensor, otherwise it is
+  a solid collider.
+
+## 0.14.1 (01 June 2022)
+
+### Fixed
+
+- Add the missing `init_async_scene_colliders` to the list of the plugin systems.
+
+## 0.14.0 (31 May 2022)
+
+### Added
+
+- Add the `AsyncSceneCollider` component to generate collision for scene meshes similar to `AsyncCollider`.
+- Add calls to `App::register_type` for the types implementing `Reflect`.
+
+### Modified
+
+- `Collider::bevy_mesh`, `Collider::bevy_mesh_convex_decomposition`
+  and `Collider::bevy_mesh_convex_decomposition_with_params` was replaced with single `Collider::from_bevy_mesh`
+  function which accepts `ComputedColliderShape`.
+- `AsyncCollider` is now a struct which contains a mesh handle and `ComputedColliderShape`.
+- The physics systems are now running after `CoreStage::Update` but before `CoreStage::PostUpdate`.
+- The collider and rigid-body positions are read from the `GlobalTransform` instead of `Transform` (the
+  transforms modified by Rapier are written back to the `Transform` component). It is therefore important
+  to insert both a `Transform` and `GlobalTransform` component (or the `TransformBundle` bundle).
+- It is now possible to prevent the plugin from registering its system thanks
+  to `RapierPhysicsPlugin::with_default_system_setup(false)`.
+  If that’s the case, the `RapierPhysicsPlugin::get_systems` method can be called to retrieve the relevant `SystemSet`
+  that can be added to your own stages in order to apply your own scheduling.
+
+### Fixed
+
+- Fixed issues where contact regularization (using compliance) would result in tunnelling despite tunnelling
+  being enabled.
+- Don’t overwrite the user’s `RapierConfiguration` if one already exists before initializing the plugin.
+
+## 0.13.2 (5 May 2022)
+
+### Modified
+
+- The `TimestepMode` and `SimulationToRenderTime` structures are now public.
+
+### Fixed
+
+- Fixed colors rendered by the debug-renderer.
+- Fix issue where the debug-renderer would sometimes render lines behind the user’s meshes/sprites.
+
+## 0.13.1 (1 May 2022)
+
+### Added
+
+- Add the `CollidingEntities` components which tracks the set of entities colliding
+  with a given entity.
+- Add constructors `Velocity::linear`, `Velocity::angular`, `Ccd::enabled()`, `Ccd::disabled()`,
+  `Dominance::group`, `Friction::coefficient`, `Restitution::coefficient`, `CollisionGroups::new`,
+  `SolverGroups::new`.
+- Add `RapierContext::collider_parent` that returns the entity containing the parent `RigidBody`
+  of a collider.
+
+### Modified
+
+- Switched to linear ordering to order our systems.
+- Make the `plugin::systems` module public.
+
+## 0.13.0 (30 Apr. 2022)
+
+This is a **complete rewrite of the plugin** (mostly likely the last large redesign this plugin
+will be subject to). It switches to `rapier` 0.12 and `bevy` 0.7. The focus of this rewrite was
+to significantly improve ergonomics while simplifying the codebase and adding new features.
+
+Refer to [#138](https://github.com/dimforge/bevy_rapier/pull/138) for extensive details
+on this change. See the folders `bevy_rapier2d/examples` and `bevy_rapier3d/examples`
+for some examples.
+
+## 0.12.0
+
+### Modified
+
+- Switch to `rapier` 0.12.0-alpha.0 and `nalgebra` 0.30.
+- Switch to `bevy` 0.6.
+- All the Rapier components have been wrapped into wrapper types (for example `ColliderPosition`
+  has been wrapped into `ColliderPositionComponent`). These wrapper types are the ones that need
+  to be used as bevy components. To convert a Rapier component to it’s corresponding Bevy component,
+  simply use `.into()`. See the examples in `bevy_rapier2d/examples` and `bevy_rapier3d/examples`
+  for details.
+
+## 0.11.0
+
+### Modified
+
+- Switch to `Rapier` 0.11 and `nalgebra` 0.29.
+- Add labels to each system from `bevy-rapier`.
+
+### Fixed
+
+- Fix panics when despawning joints or colliders.
+- Fix a panic where adding a collider.
+- Don’t let the plugin overwrite the user’s `PhysicsHooksWithQueryObject` if it was already
+  present before inserting the plugin.
+
+## 0.10.2
+
+### Fixed
+
+- Fix build when targeting WASM.
+
+## 0.10.1
+
+### Fixed
+
+- Fix joint removal when despawning its entity.
+
+## 0.10.0
+
+A new, exhaustive, user-guide for bevy_rapier has been uploaded to rapier.rs.
+
+This version is a complete rewrite of the plugin. Rigid-bodies and
+colliders are now split into components that can be queried like any other
+components. They are created by inserting a `RigidBodyBundle` and/or a `ColliderBundle`.
+
+In addition, the `Entity` type and `ColliderHandle/RigidBodyHandle` type can now be
+converted directly using `entity.handle()` or `handle.entity()`.
+
+Finally, there is now a prelude: `use bevy_rapier2d::prelude::*`.
+
+## 0.9.0
+
+### Added
+
+- The `ColliderDebugRender` component must be added to an entity
+  containing a collider shape in order to render it.
+
+## 0.8.0
+
+### Changed
+
+- Use the version 0.5.0 of Rapier.
+
+### Added
+
+- The debug rendering of 3D trimesh now work.
+- The debug rendering won't crash any more if a not-yet-supported shape
+  is used. It will silently ignore the shape instead.
+- The crate has now a `render` feature that allows building it without any
+  rendering support (avoiding some dependencies that may not compile when
+  targeting WASM).
+
+## 0.7.0
+
+### Changed
+
+- Use the version 0.4.0 of Bevy.
+
+## 0.6.2
+
+### Changed
+
+- Fix the rendering of colliders attached to an entity children of another
+  entity containing the rigid-body it is attached to.
+
+## 0.6.1
+
+### Changed
+
+- The adaptive change of number of timesteps executed during each render loop
+  (introduced in the version 0.4.0 with position interpolation) is
+  now disabled by default. It needs to be enabled explicitly by setting
+  `RapierConfiguration.time_dependent_number_of_timesteps` to `true`.
+
+## 0.6.0
+
+### Added
+
+- It is now possible to attach multiple colliders to a single
+  rigid-body by using Bevy hierarchy: an entity contains
+  the `RigidBodyBuilder` whereas its children contain the `ColliderBuilder`.
+
+### Changed
+
+- We now use the latest version of Rapier: 0.4.0. See the
+  [Rapier changelog](https://github.com/dimforge/rapier/blob/master/CHANGELOG.md#v040)
+  for details. In particular, this includes the ability to lock the rotations of a rigid-body.
+
+## 0.5.0
+
+### Changed
+
+- We now use the latest version of Bevy: 0.3.0
+
+### Added
+
+- Rigid-bodies, colliders, and joints, will automatically removed from the Rapier
+  sets when their corresponding Bevy components are removed.
+
+## 0.4.0
+
+This release update the plugin to the latest version of Rapier, which itself
+includes lots of new features. Refer to the Rapier changelogs for details.
+
+### Added
+
+- A `InteractionPairFilters` resource where you can your own filters for contact pair
+  and proximity pair filtering. Before considering the use of a custom filter, consider
+  using collision groups instead (as it is faster, but less versatile).
+
+### Changed
+
+- The stepping system now applies interpolation between two physics state at render time.
+  Refer to [that issue](https://github.com/dimforge/bevy_rapier/pull/19) and the following
+  blog post article for details: https://www.gafferongames.com/post/fix_your_timestep/
+
+## 0.3.1
+
+### Changed
+
+- Rapier configuration
+    - Replaced `Gravity` and `RapierPhysicsScale` resources with a unique `RapierConfiguration` resource.
+    - Added an `physics_pipeline_active` attribute to `RapierConfiguration` allowing to pause the physic simulation.
+    - Added a `query_pipeline_active` attribute to `RapierConfiguration` allowing to pause the query pipeline update.
+
diff --git a/bindings/bevy_rapier/Cargo.toml b/bindings/bevy_rapier/Cargo.toml
new file mode 100644
index 000000000..c18673319
--- /dev/null
+++ b/bindings/bevy_rapier/Cargo.toml
@@ -0,0 +1,26 @@
+[workspace]
+members = ["bevy_rapier2d", "bevy_rapier3d", "bevy_rapier_benches3d", "ci"]
+resolver = "2"
+
+[workspace.dependencies]
+# Build against the rapier crates of this repository so bevy_rapier always tracks the in-tree engine.
+rapier2d = { version = "0.35.3", path = "../../crates/rapier2d" }
+rapier3d = { version = "0.35.3", path = "../../crates/rapier3d" }
+rapier3d-urdf = { version = "0.35.3", path = "../../crates/rapier3d-urdf" }
+rapier3d-mjcf = { version = "0.35.3", path = "../../crates/rapier3d-mjcf" }
+rapier3d-meshloader = { version = "0.35.3", path = "../../crates/rapier3d-meshloader", default-features = false }
+
+[profile.dev]
+# Use slightly better optimization by default, as examples otherwise seem laggy.
+opt-level = 1
+
+[profile.release]
+codegen-units = 1
+
+[patch.crates-io]
+#nalgebra = { path = "../../../nalgebra" }
+#parry2d = { path = "../../../parry/crates/parry2d" }
+#parry3d = { path = "../../../parry/crates/parry3d" }
+#nalgebra = { git = "https://github.com/dimforge/nalgebra", branch = "dev" }
+#parry2d = { git = "https://github.com/dimforge/parry", branch = "master" }
+#parry3d = { git = "https://github.com/dimforge/parry", branch = "master" }
diff --git a/bindings/bevy_rapier/LICENSE b/bindings/bevy_rapier/LICENSE
new file mode 100644
index 000000000..97f4383a3
--- /dev/null
+++ b/bindings/bevy_rapier/LICENSE
@@ -0,0 +1,201 @@
+                                 Apache License
+                           Version 2.0, January 2004
+                        http://www.apache.org/licenses/
+
+   TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION
+
+   1. Definitions.
+
+      "License" shall mean the terms and conditions for use, reproduction,
+      and distribution as defined by Sections 1 through 9 of this document.
+
+      "Licensor" shall mean the copyright owner or entity authorized by
+      the copyright owner that is granting the License.
+
+      "Legal Entity" shall mean the union of the acting entity and all
+      other entities that control, are controlled by, or are under common
+      control with that entity. For the purposes of this definition,
+      "control" means (i) the power, direct or indirect, to cause the
+      direction or management of such entity, whether by contract or
+      otherwise, or (ii) ownership of fifty percent (50%) or more of the
+      outstanding shares, or (iii) beneficial ownership of such entity.
+
+      "You" (or "Your") shall mean an individual or Legal Entity
+      exercising permissions granted by this License.
+
+      "Source" form shall mean the preferred form for making modifications,
+      including but not limited to software source code, documentation
+      source, and configuration files.
+
+      "Object" form shall mean any form resulting from mechanical
+      transformation or translation of a Source form, including but
+      not limited to compiled object code, generated documentation,
+      and conversions to other media types.
+
+      "Work" shall mean the work of authorship, whether in Source or
+      Object form, made available under the License, as indicated by a
+      copyright notice that is included in or attached to the work
+      (an example is provided in the Appendix below).
+
+      "Derivative Works" shall mean any work, whether in Source or Object
+      form, that is based on (or derived from) the Work and for which the
+      editorial revisions, annotations, elaborations, or other modifications
+      represent, as a whole, an original work of authorship. For the purposes
+      of this License, Derivative Works shall not include works that remain
+      separable from, or merely link (or bind by name) to the interfaces of,
+      the Work and Derivative Works thereof.
+
+      "Contribution" shall mean any work of authorship, including
+      the original version of the Work and any modifications or additions
+      to that Work or Derivative Works thereof, that is intentionally
+      submitted to Licensor for inclusion in the Work by the copyright owner
+      or by an individual or Legal Entity authorized to submit on behalf of
+      the copyright owner. For the purposes of this definition, "submitted"
+      means any form of electronic, verbal, or written communication sent
+      to the Licensor or its representatives, including but not limited to
+      communication on electronic mailing lists, source code control systems,
+      and issue tracking systems that are managed by, or on behalf of, the
+      Licensor for the purpose of discussing and improving the Work, but
+      excluding communication that is conspicuously marked or otherwise
+      designated in writing by the copyright owner as "Not a Contribution."
+
+      "Contributor" shall mean Licensor and any individual or Legal Entity
+      on behalf of whom a Contribution has been received by Licensor and
+      subsequently incorporated within the Work.
+
+   2. Grant of Copyright License. Subject to the terms and conditions of
+      this License, each Contributor hereby grants to You a perpetual,
+      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+      copyright license to reproduce, prepare Derivative Works of,
+      publicly display, publicly perform, sublicense, and distribute the
+      Work and such Derivative Works in Source or Object form.
+
+   3. Grant of Patent License. Subject to the terms and conditions of
+      this License, each Contributor hereby grants to You a perpetual,
+      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+      (except as stated in this section) patent license to make, have made,
+      use, offer to sell, sell, import, and otherwise transfer the Work,
+      where such license applies only to those patent claims licensable
+      by such Contributor that are necessarily infringed by their
+      Contribution(s) alone or by combination of their Contribution(s)
+      with the Work to which such Contribution(s) was submitted. If You
+      institute patent litigation against any entity (including a
+      cross-claim or counterclaim in a lawsuit) alleging that the Work
+      or a Contribution incorporated within the Work constitutes direct
+      or contributory patent infringement, then any patent licenses
+      granted to You under this License for that Work shall terminate
+      as of the date such litigation is filed.
+
+   4. Redistribution. You may reproduce and distribute copies of the
+      Work or Derivative Works thereof in any medium, with or without
+      modifications, and in Source or Object form, provided that You
+      meet the following conditions:
+
+      (a) You must give any other recipients of the Work or
+          Derivative Works a copy of this License; and
+
+      (b) You must cause any modified files to carry prominent notices
+          stating that You changed the files; and
+
+      (c) You must retain, in the Source form of any Derivative Works
+          that You distribute, all copyright, patent, trademark, and
+          attribution notices from the Source form of the Work,
+          excluding those notices that do not pertain to any part of
+          the Derivative Works; and
+
+      (d) If the Work includes a "NOTICE" text file as part of its
+          distribution, then any Derivative Works that You distribute must
+          include a readable copy of the attribution notices contained
+          within such NOTICE file, excluding those notices that do not
+          pertain to any part of the Derivative Works, in at least one
+          of the following places: within a NOTICE text file distributed
+          as part of the Derivative Works; within the Source form or
+          documentation, if provided along with the Derivative Works; or,
+          within a display generated by the Derivative Works, if and
+          wherever such third-party notices normally appear. The contents
+          of the NOTICE file are for informational purposes only and
+          do not modify the License. You may add Your own attribution
+          notices within Derivative Works that You distribute, alongside
+          or as an addendum to the NOTICE text from the Work, provided
+          that such additional attribution notices cannot be construed
+          as modifying the License.
+
+      You may add Your own copyright statement to Your modifications and
+      may provide additional or different license terms and conditions
+      for use, reproduction, or distribution of Your modifications, or
+      for any such Derivative Works as a whole, provided Your use,
+      reproduction, and distribution of the Work otherwise complies with
+      the conditions stated in this License.
+
+   5. Submission of Contributions. Unless You explicitly state otherwise,
+      any Contribution intentionally submitted for inclusion in the Work
+      by You to the Licensor shall be under the terms and conditions of
+      this License, without any additional terms or conditions.
+      Notwithstanding the above, nothing herein shall supersede or modify
+      the terms of any separate license agreement you may have executed
+      with Licensor regarding such Contributions.
+
+   6. Trademarks. This License does not grant permission to use the trade
+      names, trademarks, service marks, or product names of the Licensor,
+      except as required for reasonable and customary use in describing the
+      origin of the Work and reproducing the content of the NOTICE file.
+
+   7. Disclaimer of Warranty. Unless required by applicable law or
+      agreed to in writing, Licensor provides the Work (and each
+      Contributor provides its Contributions) on an "AS IS" BASIS,
+      WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
+      implied, including, without limitation, any warranties or conditions
+      of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A
+      PARTICULAR PURPOSE. You are solely responsible for determining the
+      appropriateness of using or redistributing the Work and assume any
+      risks associated with Your exercise of permissions under this License.
+
+   8. Limitation of Liability. In no event and under no legal theory,
+      whether in tort (including negligence), contract, or otherwise,
+      unless required by applicable law (such as deliberate and grossly
+      negligent acts) or agreed to in writing, shall any Contributor be
+      liable to You for damages, including any direct, indirect, special,
+      incidental, or consequential damages of any character arising as a
+      result of this License or out of the use or inability to use the
+      Work (including but not limited to damages for loss of goodwill,
+      work stoppage, computer failure or malfunction, or any and all
+      other commercial damages or losses), even if such Contributor
+      has been advised of the possibility of such damages.
+
+   9. Accepting Warranty or Additional Liability. While redistributing
+      the Work or Derivative Works thereof, You may choose to offer,
+      and charge a fee for, acceptance of support, warranty, indemnity,
+      or other liability obligations and/or rights consistent with this
+      License. However, in accepting such obligations, You may act only
+      on Your own behalf and on Your sole responsibility, not on behalf
+      of any other Contributor, and only if You agree to indemnify,
+      defend, and hold each Contributor harmless for any liability
+      incurred by, or claims asserted against, such Contributor by reason
+      of your accepting any such warranty or additional liability.
+
+   END OF TERMS AND CONDITIONS
+
+   APPENDIX: How to apply the Apache License to your work.
+
+      To apply the Apache License to your work, attach the following
+      boilerplate notice, with the fields enclosed by brackets "[]"
+      replaced with your own identifying information. (Don't include
+      the brackets!)  The text should be enclosed in the appropriate
+      comment syntax for the file format. We also recommend that a
+      file or class name and description of purpose be included on the
+      same "printed page" as the copyright notice for easier
+      identification within third-party archives.
+
+   Copyright 2020 Sébastien Crozet
+
+   Licensed under the Apache License, Version 2.0 (the "License");
+   you may not use this file except in compliance with the License.
+   You may obtain a copy of the License at
+
+       http://www.apache.org/licenses/LICENSE-2.0
+
+   Unless required by applicable law or agreed to in writing, software
+   distributed under the License is distributed on an "AS IS" BASIS,
+   WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+   See the License for the specific language governing permissions and
+   limitations under the License.
diff --git a/bindings/bevy_rapier/README.md b/bindings/bevy_rapier/README.md
new file mode 100644
index 000000000..206d13e7f
--- /dev/null
+++ b/bindings/bevy_rapier/README.md
@@ -0,0 +1,33 @@
+<p align="center">
+  <img src="https://www.rapier.rs/img/rapier_logo_color_textpath_dark.svg" alt="crates.io">
+</p>
+<p align="center">
+    <a href="https://discord.gg/vt9DJSW">
+        <img src="https://img.shields.io/discord/507548572338880513.svg?logo=discord&colorB=7289DA">
+    </a>
+    <a href="https://github.com/dimforge/rapier/actions/workflows/bevy-rapier.yml">
+        <img src="https://github.com/dimforge/rapier/actions/workflows/bevy-rapier.yml/badge.svg" alt="Build status">
+    </a>
+    <a href="https://crates.io/crates/bevy_rapier2d">
+         <img src="https://img.shields.io/crates/v/bevy_rapier2d.svg?style=flat-square" alt="crates.io">
+    </a>
+    <a href="https://crates.io/crates/bevy_rapier3d">
+         <img src="https://img.shields.io/crates/v/bevy_rapier3d.svg?style=flat-square" alt="crates.io">
+    </a>
+    <a href="https://opensource.org/licenses/Apache-2.0">
+        <img src="https://img.shields.io/badge/License-Apache%202.0-blue.svg">
+    </a>
+</p>
+<p align = "center">
+    <strong>
+        <a href="https://rapier.rs">Website</a> | <a href="https://rapier.rs/docs/">Documentation</a>
+</p>
+
+-----
+
+<p align = "center">
+<b>2D and 3D physics engines</b>
+<i>for the Bevy game engine.</i>
+</p>
+
+-----
diff --git a/bindings/bevy_rapier/assets/FiraSans-Bold.ttf b/bindings/bevy_rapier/assets/FiraSans-Bold.ttf
new file mode 100644
index 000000000..95e166024
Binary files /dev/null and b/bindings/bevy_rapier/assets/FiraSans-Bold.ttf differ
diff --git a/bindings/bevy_rapier/bevy_rapier2d/Cargo.toml b/bindings/bevy_rapier/bevy_rapier2d/Cargo.toml
new file mode 100644
index 000000000..e8f01dd0c
--- /dev/null
+++ b/bindings/bevy_rapier/bevy_rapier2d/Cargo.toml
@@ -0,0 +1,133 @@
+[package]
+name = "bevy_rapier2d"
+version = "0.36.0"
+authors = ["Sébastien Crozet <developer@crozet.re>"]
+description = "2-dimensional physics engine in Rust, official Bevy plugin."
+documentation = "http://docs.rs/bevy_rapier2d"
+homepage = "http://rapier.rs"
+repository = "https://github.com/dimforge/rapier"
+readme = "../README.md"
+keywords = ["physics", "dynamics", "rigid", "real-time", "joints"]
+license = "Apache-2.0"
+edition = "2021"
+
+
+# See more keys and their definitions at https://doc.rust-lang.org/cargo/reference/manifest.html
+[lib]
+path = "../src/lib.rs"
+required-features = ["dim2"]
+
+[lints]
+rust.unexpected_cfgs = { level = "warn", check-cfg = [
+    'cfg(feature, values("dim3", "urdf", "mjcf", "meshloader"))',
+] }
+clippy = { needless_lifetimes = "allow" }
+
+[features]
+default = [
+    "dim2",
+    "async-collider",
+    "debug-render-2d",
+    "picking-backend",
+    "to-bevy-mesh",
+]
+dim2 = []
+# Alias of the debug-render feature matching this crate's dimension.
+debug-render = ["debug-render-2d"]
+debug-render-2d = [
+    "bevy/bevy_core_pipeline",
+    "bevy/bevy_sprite",
+    "bevy/bevy_gizmos",
+    "rapier2d/debug-render",
+    "bevy/bevy_asset",
+]
+debug-render-3d = [
+    "bevy/bevy_core_pipeline",
+    "bevy/bevy_pbr",
+    "bevy/bevy_gizmos",
+    "rapier2d/debug-render",
+    "bevy/bevy_asset",
+]
+rapier-debug-render = ["rapier2d/debug-render"]
+
+parallel = ["rapier2d/parallel"]
+simd8 = ["rapier2d/simd8"]
+serde-serialize = ["rapier2d/serde-serialize", "bevy/serialize", "serde"]
+enhanced-determinism = ["rapier2d/enhanced-determinism"]
+# Couples the two normal constraints of a contact pair into a single 2x2 block solve.
+block-solver = ["rapier2d/block-solver"]
+# Enables Rapier's internal profiler, needed for the timings reported by `RapierDiagnosticsPlugin`.
+profiler = ["rapier2d/profiler"]
+# Drops the `Sync` requirement of Rapier's callbacks (this also removes the dedicated thread-pool
+# support enabled by `parallel`).
+unsync-callbacks = ["rapier2d/unsync-callbacks"]
+# Opt-in bounds checks on the solver's unchecked SIMD gathers (for debugging).
+solver-bounds-checks = ["rapier2d/solver-bounds-checks"]
+# Enables the experimental FEM soft-body solver.
+fem = ["rapier2d/fem"]
+picking-backend = ["bevy/bevy_picking", "bevy/bevy_render"]
+async-collider = [
+    "bevy/bevy_asset",
+    "bevy/bevy_world_serialization",
+    "bevy/bevy_render",
+    "bevy/bevy_image",
+]
+to-bevy-mesh = ["bevy/bevy_render", "bevy/bevy_asset"]
+
+[dependencies]
+bevy = { git = "https://github.com/bevyengine/bevy", branch = "main", default-features = false, features = ["std"] }
+nalgebra = { version = "0.35", features = ["convert-glam033"] }
+rapier2d = { workspace = true }
+bitflags = "2.10.0"
+log = "0.4"
+serde = { version = "1", features = ["derive"], optional = true }
+
+[dev-dependencies]
+bevy = { git = "https://github.com/bevyengine/bevy", branch = "main", default-features = false, features = [
+    "x11",
+    "bevy_state",
+    "bevy_window",
+    "bevy_debug_stepping",
+    "bevy_log",
+    "bevy_text",
+    "bevy_ui",
+    "bevy_ui_render",
+    "default_font",
+    "bevy_winit",
+    "bevy_render",
+    "bevy_core_pipeline",
+    "bevy_sprite",
+    "bevy_sprite_render",
+    "bevy_gizmos",
+    "bevy_gizmos_render",
+    "bevy_color",
+    "bevy_camera",
+] }
+oorandom = "11"
+approx = "0.5.1"
+glam = { version = "0.33", features = ["approx"] }
+serde_json = "1.0"
+
+[package.metadata.docs.rs]
+# Enable all the features when building the docs on docs.rs
+features = ["debug-render-2d", "serde-serialize"]
+
+[package.metadata.cargo-all-features]
+
+# `enhanced-determinism` enables `glam/scalar-math` (through parry), which removes the serde
+# impls of `glam::BVec3A`/`BVec4A` that `bevy_reflect` requires unconditionally.
+denylist = ["enhanced-determinism"]
+
+# Features "dim2" and "dim3" are incompatible, so skip permutations including them
+skip_feature_sets = [["enhanced-determinism", "simd8"]]
+
+always_include_features = ["dim2"]
+
+# The maximum number of features to try at once. Does not count features from `always_include_features`.
+# This is useful for reducing the number of combinations run for a crate with a large amount of features,
+# since in most cases a bug just needs a small set of 2-3 features to reproduce.
+max_combination_size = 1
+
+[[example]]
+name = "soft_fem2"
+required-features = ["fem"]
diff --git a/bindings/bevy_rapier/bevy_rapier2d/examples/boxes2.rs b/bindings/bevy_rapier/bevy_rapier2d/examples/boxes2.rs
new file mode 100644
index 000000000..aa986331c
--- /dev/null
+++ b/bindings/bevy_rapier/bevy_rapier2d/examples/boxes2.rs
@@ -0,0 +1,62 @@
+use bevy::prelude::*;
+use bevy_rapier2d::prelude::*;
+
+fn main() {
+    App::new()
+        .insert_resource(ClearColor(Color::srgb(
+            0xF9 as f32 / 255.0,
+            0xF9 as f32 / 255.0,
+            0xFF as f32 / 255.0,
+        )))
+        .add_plugins((
+            DefaultPlugins,
+            RapierPhysicsPlugin::<NoUserData>::pixels_per_meter(100.0),
+            RapierDebugRenderPlugin::default(),
+        ))
+        .add_systems(Startup, (setup_graphics, setup_physics))
+        .run();
+}
+
+pub fn setup_graphics(mut commands: Commands) {
+    commands.spawn((Camera2d, Transform::from_xyz(0.0, 20.0, 0.0)));
+}
+
+pub fn setup_physics(mut commands: Commands) {
+    /*
+     * Ground
+     */
+    let ground_size = 500.0;
+    let ground_height = 10.0;
+
+    commands.spawn((
+        Transform::from_xyz(0.0, 0.0 * -ground_height, 0.0),
+        Collider::cuboid(ground_size, ground_height),
+    ));
+
+    /*
+     * Create the cubes
+     */
+    let num = 8;
+    let rad = 10.0;
+
+    let shift = rad * 2.0 + rad;
+    let centerx = shift * (num / 2) as f32;
+    let centery = shift / 2.0;
+
+    let mut offset = -(num as f32) * (rad * 2.0 + rad) * 0.5;
+
+    for j in 0usize..20 {
+        for i in 0..num {
+            let x = i as f32 * shift - centerx + offset;
+            let y = j as f32 * shift + centery + 30.0;
+
+            commands.spawn((
+                Transform::from_xyz(x, y, 0.0),
+                RigidBody::Dynamic,
+                Collider::cuboid(rad, rad),
+            ));
+        }
+
+        offset -= 0.05 * rad * (num as f32 - 1.0);
+    }
+}
diff --git a/bindings/bevy_rapier/bevy_rapier2d/examples/breakable_joints2.rs b/bindings/bevy_rapier/bevy_rapier2d/examples/breakable_joints2.rs
new file mode 100644
index 000000000..f54a56e90
--- /dev/null
+++ b/bindings/bevy_rapier/bevy_rapier2d/examples/breakable_joints2.rs
@@ -0,0 +1,225 @@
+//! Breakable joints: a rope bridge made of planks linked by revolute impulse joints. Balls keep
+//! falling on the bridge, and each joint is removed once the impulse it applies (read from the
+//! `ImpulseJointImpulses` component) exceeds a threshold.
+//!
+//! Press R to rebuild the bridge.
+
+use bevy::prelude::*;
+use bevy_rapier2d::prelude::*;
+
+/// The number of planks of the bridge.
+const NUM_PLANKS: usize = 20;
+/// Half the width of a plank.
+const PLANK_HALF_WIDTH: f32 = 0.3;
+/// Half the thickness of a plank.
+const PLANK_HALF_HEIGHT: f32 = 0.08;
+/// A joint breaks when the norm of the linear impulse it applied during the last step exceeds this
+/// value. The bridge alone needs about 0.3, so it breaks under heavy impacts or a pile of balls.
+const BREAK_IMPULSE: f32 = 1.5;
+/// The time between two ball drops, in seconds.
+const DROP_PERIOD: f32 = 0.4;
+
+fn main() {
+    App::new()
+        .insert_resource(ClearColor(Color::srgb(
+            0xF9 as f32 / 255.0,
+            0xF9 as f32 / 255.0,
+            0xFF as f32 / 255.0,
+        )))
+        .insert_resource(BallDropper {
+            rng: oorandom::Rand32::new(42),
+            timer: Timer::from_seconds(DROP_PERIOD, TimerMode::Repeating),
+        })
+        .add_plugins((
+            DefaultPlugins,
+            RapierPhysicsPlugin::<NoUserData>::default(),
+            RapierDebugRenderPlugin::default(),
+        ))
+        .add_systems(Startup, (setup_graphics, setup_physics))
+        .add_systems(
+            Update,
+            (
+                drop_balls,
+                break_joints,
+                despawn_fallen_bodies,
+                rebuild_bridge,
+            ),
+        )
+        .run();
+}
+
+/// Marker for the joints that break under a large impulse.
+#[derive(Component)]
+struct Breakable;
+
+/// Marker for the planks of the bridge, despawned when it is rebuilt.
+#[derive(Component)]
+struct Plank;
+
+/// The state of the ball spawner.
+#[derive(Resource)]
+struct BallDropper {
+    rng: oorandom::Rand32,
+    timer: Timer,
+}
+
+/// The fixed pillars at both ends of the bridge.
+#[derive(Resource)]
+struct Pillars {
+    left: Entity,
+    right: Entity,
+}
+
+pub fn setup_graphics(mut commands: Commands) {
+    // The scene is expressed in meters: zoom in so that one meter spans 50 pixels.
+    commands.spawn((
+        Camera2d,
+        Projection::from(OrthographicProjection {
+            scale: 0.02,
+            ..OrthographicProjection::default_2d()
+        }),
+        Transform::from_xyz(0.0, 2.0, 0.0),
+    ));
+    commands.spawn((
+        Text::new("R: rebuild the bridge"),
+        Node {
+            position_type: PositionType::Absolute,
+            top: Val::Px(12.0),
+            left: Val::Px(12.0),
+            ..default()
+        },
+        TextColor(Color::BLACK),
+    ));
+}
+
+pub fn setup_physics(mut commands: Commands) {
+    /*
+     * Two pillars holding both ends of the bridge.
+     */
+    let half_span = NUM_PLANKS as f32 * PLANK_HALF_WIDTH;
+    let pillar_half_extents = Vec2::new(0.5, 3.0);
+    let left = commands
+        .spawn((
+            Transform::from_xyz(
+                -half_span - pillar_half_extents.x,
+                -pillar_half_extents.y,
+                0.0,
+            ),
+            RigidBody::Fixed,
+            Collider::cuboid(pillar_half_extents.x, pillar_half_extents.y),
+        ))
+        .id();
+    let right = commands
+        .spawn((
+            Transform::from_xyz(
+                half_span + pillar_half_extents.x,
+                -pillar_half_extents.y,
+                0.0,
+            ),
+            RigidBody::Fixed,
+            Collider::cuboid(pillar_half_extents.x, pillar_half_extents.y),
+        ))
+        .id();
+
+    let pillars = Pillars { left, right };
+    spawn_bridge(&mut commands, &pillars);
+    commands.insert_resource(pillars);
+}
+
+/// Spawns the planks of the bridge, linked to each other and to the pillars with breakable joints.
+fn spawn_bridge(commands: &mut Commands, pillars: &Pillars) {
+    let half_span = NUM_PLANKS as f32 * PLANK_HALF_WIDTH;
+    // The joint anchors on the top inner corners of the pillars.
+    let pillar_corner = Vec2::new(0.5, 3.0);
+
+    let mut prev = pillars.left;
+    let mut prev_anchor = pillar_corner;
+
+    for i in 0..NUM_PLANKS {
+        let x = -half_span + (2.0 * i as f32 + 1.0) * PLANK_HALF_WIDTH;
+        let plank = commands
+            .spawn((
+                Transform::from_xyz(x, 0.0, 0.0),
+                RigidBody::Dynamic,
+                Collider::cuboid(PLANK_HALF_WIDTH, PLANK_HALF_HEIGHT),
+                Plank,
+            ))
+            .id();
+
+        // Each joint lives on its own child entity, so that despawning it breaks only that link.
+        let joint = RevoluteJointBuilder::new()
+            .local_anchor1(prev_anchor)
+            .local_anchor2(Vec2::new(-PLANK_HALF_WIDTH, 0.0));
+        commands
+            .entity(plank)
+            .with_child((ImpulseJoint::new(prev, joint), Breakable));
+
+        if i == NUM_PLANKS - 1 {
+            let joint = RevoluteJointBuilder::new()
+                .local_anchor1(Vec2::new(-pillar_corner.x, pillar_corner.y))
+                .local_anchor2(Vec2::new(PLANK_HALF_WIDTH, 0.0));
+            commands
+                .entity(plank)
+                .with_child((ImpulseJoint::new(pillars.right, joint), Breakable));
+        }
+
+        prev = plank;
+        prev_anchor = Vec2::new(PLANK_HALF_WIDTH, 0.0);
+    }
+}
+
+/// Drops a ball of random size and position above the bridge at regular intervals.
+fn drop_balls(mut commands: Commands, time: Res<Time>, mut dropper: ResMut<BallDropper>) {
+    if !dropper.timer.tick(time.delta()).just_finished() {
+        return;
+    }
+
+    let half_span = NUM_PLANKS as f32 * PLANK_HALF_WIDTH;
+    let x = (dropper.rng.rand_float() * 2.0 - 1.0) * half_span;
+    let radius = 0.15 + 0.35 * dropper.rng.rand_float();
+    commands.spawn((
+        Transform::from_xyz(x, 8.0, 0.0),
+        RigidBody::Dynamic,
+        Collider::ball(radius),
+        ColliderMassProperties::Density(3.0),
+    ));
+}
+
+/// Removes the joints applying an impulse larger than the breaking threshold.
+fn break_joints(
+    mut commands: Commands,
+    joints: Query<(Entity, &ImpulseJointImpulses), With<Breakable>>,
+) {
+    for (entity, impulses) in &joints {
+        if impulses.linear.length() > BREAK_IMPULSE {
+            commands.entity(entity).despawn();
+        }
+    }
+}
+
+/// Despawns the balls and planks that fell far below the bridge.
+fn despawn_fallen_bodies(
+    mut commands: Commands,
+    bodies: Query<(Entity, &Transform), With<RigidBody>>,
+) {
+    for (entity, transform) in &bodies {
+        if transform.translation.y < -20.0 {
+            commands.entity(entity).despawn();
+        }
+    }
+}
+
+/// Replaces the bridge with a new one when R is pressed.
+fn rebuild_bridge(
+    mut commands: Commands,
+    keys: Res<ButtonInput<KeyCode>>,
+    pillars: Res<Pillars>,
+    planks: Query<Entity, With<Plank>>,
+) {
+    if keys.just_pressed(KeyCode::KeyR) {
+        for plank in &planks {
+            commands.entity(plank).despawn();
+        }
+        spawn_bridge(&mut commands, &pillars);
+    }
+}
diff --git a/bindings/bevy_rapier/bevy_rapier2d/examples/character_controller2.rs b/bindings/bevy_rapier/bevy_rapier2d/examples/character_controller2.rs
new file mode 100644
index 000000000..18d9c84a0
--- /dev/null
+++ b/bindings/bevy_rapier/bevy_rapier2d/examples/character_controller2.rs
@@ -0,0 +1,283 @@
+//! A kinematic character controlled with `KinematicCharacterController`, walking on slopes,
+//! stairs, a heightfield, and a moving platform, and pushing dynamic boxes.
+//!
+//! It also showcases the controller's filters: the purple wall is ignored through
+//! `exclude_colliders` (while still blocking the boxes), and holding Down lets the character drop
+//! through the orange stairs thanks to a `filter_predicate`.
+//!
+//! Controls: Left/Right to move, Space to fly up, Down to move down, Shift to slow down.
+
+use bevy::{ecs::entity::EntityHashSet, prelude::*};
+use bevy_rapier2d::prelude::*;
+use std::f32::consts::PI;
+use std::sync::{
+    atomic::{AtomicBool, Ordering},
+    Arc,
+};
+
+const CHARACTER_SPEED: f32 = 6.0;
+const GROUNDED_COLOR: Hsla = Hsla::hsl(120.0, 1.0, 0.35);
+const AIRBORNE_COLOR: Hsla = Hsla::hsl(0.0, 1.0, 0.45);
+
+/// Shared with the character controller's filter predicate: while set, the stairs are ignored.
+#[derive(Resource, Clone, Default)]
+struct DropThrough(Arc<AtomicBool>);
+
+#[derive(Component)]
+struct MovingPlatform;
+
+fn main() {
+    App::new()
+        .insert_resource(ClearColor(Color::srgb(
+            0xF9 as f32 / 255.0,
+            0xF9 as f32 / 255.0,
+            0xFF as f32 / 255.0,
+        )))
+        .init_resource::<DropThrough>()
+        .add_plugins((
+            DefaultPlugins,
+            RapierPhysicsPlugin::<NoUserData>::default(),
+            RapierDebugRenderPlugin::default(),
+        ))
+        .add_systems(Startup, (setup_graphics, setup_physics))
+        .add_systems(
+            Update,
+            (move_platform, move_character, update_character_color),
+        )
+        .run();
+}
+
+fn setup_graphics(mut commands: Commands) {
+    commands.spawn((
+        Camera2d,
+        Projection::from(OrthographicProjection {
+            scale: 1.0 / 50.0,
+            ..OrthographicProjection::default_2d()
+        }),
+        Transform::from_xyz(1.0, 2.0, 0.0),
+    ));
+}
+
+fn setup_physics(mut commands: Commands, drop_through: Res<DropThrough>) {
+    /*
+     * Ground
+     */
+    let ground_size = 5.0;
+    let ground_height = 0.1;
+
+    commands.spawn((
+        Transform::from_xyz(0.0, -ground_height, 0.0),
+        Collider::cuboid(ground_size, ground_height),
+    ));
+
+    /*
+     * Create the cubes
+     */
+    let num = 8;
+    let rad = 0.1;
+
+    let shift = rad * 2.0;
+    let centerx = shift * (num / 2) as f32;
+    let centery = rad;
+
+    for j in 0usize..4 {
+        for i in 0..num {
+            let x = i as f32 * shift - centerx;
+            let y = j as f32 * shift + centery;
+            commands.spawn((
+                Transform::from_xyz(x, y, 0.0),
+                RigidBody::Dynamic,
+                Collider::cuboid(rad, rad),
+            ));
+        }
+    }
+
+    /*
+     * A wall ignored by the character (but not by the cubes).
+     */
+    let ghost_wall = commands
+        .spawn((
+            Transform::from_xyz(-1.5, 0.5, 0.0),
+            Collider::cuboid(0.05, 0.5),
+            ColliderDebugColor(Hsla::hsl(280.0, 0.8, 0.6)),
+        ))
+        .id();
+
+    /*
+     * Create some stairs, which the character can drop through.
+     */
+    let stair_width = 1.0;
+    let stair_height = 0.1;
+    let mut stairs = EntityHashSet::default();
+    for i in 0..10 {
+        let x = i as f32 * stair_width / 2.0;
+        let y = i as f32 * stair_height * 1.5 + 3.0;
+
+        let stair = commands
+            .spawn((
+                Transform::from_xyz(x, y, 0.0),
+                Collider::cuboid(stair_width / 2.0, stair_height / 2.0),
+                ColliderDebugColor(Hsla::hsl(30.0, 1.0, 0.5)),
+            ))
+            .id();
+        stairs.insert(stair);
+    }
+
+    /*
+     * Create a slope we can climb.
+     */
+    let slope_angle = 0.2;
+    let slope_size = 2.0;
+    commands.spawn((
+        Transform::from_xyz(ground_size + slope_size, -ground_height + 0.4, 0.0)
+            .with_rotation(Quat::from_rotation_z(slope_angle)),
+        Collider::cuboid(slope_size, ground_height),
+    ));
+
+    /*
+     * Create a slope we can't climb.
+     */
+    let impossible_slope_angle = 0.9;
+    let impossible_slope_size = 2.0;
+    commands.spawn((
+        Transform::from_xyz(
+            ground_size + slope_size * 2.0 + impossible_slope_size - 0.9,
+            -ground_height + 2.3,
+            0.0,
+        )
+        .with_rotation(Quat::from_rotation_z(impossible_slope_angle)),
+        Collider::cuboid(slope_size, ground_height),
+    ));
+
+    /*
+     * Create a wall we can't climb.
+     */
+    let wall_size = 2.0;
+    let wall_pos = Vec3::new(
+        ground_size + slope_size * 2.0 + impossible_slope_size + 0.35,
+        -ground_height + 2.5 * 2.3,
+        0.0,
+    );
+    commands.spawn((
+        Transform::from_translation(wall_pos).with_rotation(Quat::from_rotation_z(PI / 2.0)),
+        Collider::cuboid(wall_size, ground_height),
+    ));
+    commands.spawn((
+        Transform::from_translation(wall_pos),
+        Collider::cuboid(wall_size, ground_height),
+    ));
+
+    /*
+     * Create a moving platform.
+     */
+    commands.spawn((
+        Transform::from_xyz(-8.0, 0.0, 0.0),
+        RigidBody::KinematicVelocityBased,
+        Collider::cuboid(2.0, ground_height),
+        Velocity::zero(),
+        MovingPlatform,
+    ));
+
+    /*
+     * More complex ground.
+     */
+    let heightfield_size = Vec2::new(10.0, 1.0);
+    let nsubdivs = 20;
+    let heights = (0..=nsubdivs)
+        .map(|i| (i as f32 * heightfield_size.x / nsubdivs as f32 / 2.0).cos() * 1.5)
+        .collect();
+    commands.spawn((
+        Transform::from_xyz(-8.0, 5.0, 0.0),
+        Collider::heightfield(heights, heightfield_size),
+    ));
+
+    /*
+     * A tilting dynamic body with a limited joint.
+     */
+    let anchor = commands
+        .spawn((Transform::from_xyz(0.0, 5.0, 0.0), RigidBody::Fixed))
+        .id();
+    commands.spawn((
+        Transform::from_xyz(0.0, 5.0, 0.0),
+        RigidBody::Dynamic,
+        Collider::cuboid(1.0, 0.1),
+        ImpulseJoint::new(anchor, RevoluteJointBuilder::new().limits([-0.3, 0.3])),
+    ));
+
+    /*
+     * Character we will control manually.
+     */
+    let drop_through = drop_through.0.clone();
+    commands.spawn((
+        Transform::from_xyz(-3.0, 5.0, 0.0),
+        RigidBody::KinematicPositionBased,
+        Collider::capsule_y(0.3, 0.15),
+        KinematicCharacterController {
+            max_slope_climb_angle: impossible_slope_angle - 0.02,
+            min_slope_slide_angle: impossible_slope_angle - 0.02,
+            slide: true,
+            exclude_colliders: EntityHashSet::from_iter([ghost_wall]),
+            filter_predicate: Some(ControllerFilterPredicate::new(move |entity, _| {
+                !(drop_through.load(Ordering::Relaxed) && stairs.contains(&entity))
+            })),
+            ..default()
+        },
+        ColliderDebugColor(AIRBORNE_COLOR),
+    ));
+}
+
+fn move_platform(time: Res<Time>, mut platforms: Query<&mut Velocity, With<MovingPlatform>>) {
+    let t = time.elapsed_secs();
+    for mut velocity in &mut platforms {
+        velocity.linear = Vec2::new((t * 2.0).sin() * 2.0, (t * 5.0).sin() * 1.5);
+    }
+}
+
+fn move_character(
+    keyboard: Res<ButtonInput<KeyCode>>,
+    time: Res<Time>,
+    drop_through: Res<DropThrough>,
+    mut controllers: Query<&mut KinematicCharacterController>,
+) {
+    let mut speed = CHARACTER_SPEED;
+    let mut desired_movement = Vec2::ZERO;
+
+    if keyboard.pressed(KeyCode::ArrowRight) {
+        desired_movement += Vec2::X;
+    }
+    if keyboard.pressed(KeyCode::ArrowLeft) {
+        desired_movement -= Vec2::X;
+    }
+    if keyboard.pressed(KeyCode::Space) {
+        desired_movement += Vec2::Y * 2.0;
+    }
+    if keyboard.pressed(KeyCode::ArrowDown) {
+        desired_movement -= Vec2::Y;
+    }
+    if keyboard.any_pressed([KeyCode::ShiftLeft, KeyCode::ShiftRight]) {
+        speed /= 10.0;
+    }
+
+    // Artificial gravity.
+    desired_movement -= Vec2::Y;
+
+    drop_through
+        .0
+        .store(keyboard.pressed(KeyCode::ArrowDown), Ordering::Relaxed);
+
+    for mut controller in &mut controllers {
+        controller.translation = Some(desired_movement * speed * time.delta_secs());
+    }
+}
+
+fn update_character_color(
+    mut characters: Query<(&KinematicCharacterControllerOutput, &mut ColliderDebugColor)>,
+) {
+    for (output, mut color) in &mut characters {
+        color.0 = if output.grounded {
+            GROUNDED_COLOR
+        } else {
+            AIRBORNE_COLOR
+        };
+    }
+}
diff --git a/bindings/bevy_rapier/bevy_rapier2d/examples/collision_groups2.rs b/bindings/bevy_rapier/bevy_rapier2d/examples/collision_groups2.rs
new file mode 100644
index 000000000..0d087cd62
--- /dev/null
+++ b/bindings/bevy_rapier/bevy_rapier2d/examples/collision_groups2.rs
@@ -0,0 +1,106 @@
+//! Collision filtering with `CollisionGroups`, including a group relying on
+//! `InteractionTestMode::Or`.
+//!
+//! Green cubes only collide with the green floor and blue cubes only with the blue floor. Orange
+//! cubes fall through both and land on the orange floor: their memberships match the floor's
+//! filter but not the other way around, which is enough since both use `InteractionTestMode::Or`.
+
+use bevy::prelude::*;
+use bevy_rapier2d::prelude::*;
+
+const GREEN_GROUP: CollisionGroups = CollisionGroups::new(Group::GROUP_1, Group::GROUP_1);
+const BLUE_GROUP: CollisionGroups = CollisionGroups::new(Group::GROUP_2, Group::GROUP_2);
+// The orange floor's memberships are not in the orange cubes' filter: with the default
+// `InteractionTestMode::And`, they would never interact.
+const ORANGE_GROUP: CollisionGroups =
+    CollisionGroups::new(Group::GROUP_3, Group::GROUP_1.union(Group::GROUP_3))
+        .with_test_mode(InteractionTestMode::Or);
+const ORANGE_FLOOR_GROUP: CollisionGroups =
+    CollisionGroups::new(Group::GROUP_4, Group::GROUP_3).with_test_mode(InteractionTestMode::Or);
+
+fn main() {
+    App::new()
+        .insert_resource(ClearColor(Color::srgb(
+            0xF9 as f32 / 255.0,
+            0xF9 as f32 / 255.0,
+            0xFF as f32 / 255.0,
+        )))
+        .add_plugins((
+            DefaultPlugins,
+            RapierPhysicsPlugin::<NoUserData>::pixels_per_meter(100.0),
+            RapierDebugRenderPlugin::default(),
+        ))
+        .add_systems(Startup, (setup_graphics, setup_physics))
+        .run();
+}
+
+fn setup_graphics(mut commands: Commands) {
+    commands.spawn((Camera2d, Transform::from_xyz(0.0, 150.0, 0.0)));
+}
+
+fn setup_physics(mut commands: Commands) {
+    let green = Hsla::hsl(120.0, 1.0, 0.35);
+    let blue = Hsla::hsl(220.0, 1.0, 0.4);
+    let orange = Hsla::hsl(30.0, 1.0, 0.5);
+
+    /*
+     * Ground
+     */
+    let ground_size = 500.0;
+    let ground_height = 10.0;
+
+    commands.spawn((
+        Transform::from_xyz(0.0, -ground_height, 0.0),
+        Collider::cuboid(ground_size, ground_height),
+    ));
+
+    /*
+     * Floors colliding only with the cubes of their color.
+     */
+    let floors = [
+        (50.0, ORANGE_FLOOR_GROUP, orange),
+        (100.0, GREEN_GROUP, green),
+        (200.0, BLUE_GROUP, blue),
+    ];
+
+    for (y, groups, color) in floors {
+        commands.spawn((
+            Transform::from_xyz(0.0, y, 0.0),
+            Collider::cuboid(100.0, 10.0),
+            groups,
+            ColliderDebugColor(color),
+        ));
+    }
+
+    /*
+     * Create the cubes
+     */
+    let num = 9;
+    let rad = 10.0;
+
+    let shift = rad * 2.0;
+    let centerx = shift * (num / 2) as f32;
+    let centery = 250.0;
+
+    for j in 0usize..4 {
+        for i in 0..num {
+            let x = i as f32 * shift - centerx;
+            let y = j as f32 * shift + centery;
+
+            // Cycle through the green, blue, and orange groups.
+            let (groups, color) = match i % 3 {
+                0 => (GREEN_GROUP, green),
+                1 => (BLUE_GROUP, blue),
+                _ => (ORANGE_GROUP, orange),
+            };
+
+            commands.spawn((
+                Transform::from_xyz(x, y, 0.0),
+                RigidBody::Dynamic,
+                Collider::cuboid(rad, rad),
+                groups,
+                ColliderDebugColor(color),
+            ));
+        }
+    }
+}
diff --git a/bindings/bevy_rapier/bevy_rapier2d/examples/contact_filter2.rs b/bindings/bevy_rapier/bevy_rapier2d/examples/contact_filter2.rs
new file mode 100644
index 000000000..f11896b8e
--- /dev/null
+++ b/bindings/bevy_rapier/bevy_rapier2d/examples/contact_filter2.rs
@@ -0,0 +1,98 @@
+use bevy::{ecs::system::SystemParam, prelude::*};
+use bevy_rapier2d::prelude::*;
+
+#[derive(PartialEq, Eq, Clone, Copy, Component)]
+enum CustomFilterTag {
+    GroupA,
+    GroupB,
+}
+
+// A custom filter that allows contacts only between rigid-bodies with the
+// same user_data value.
+// Note that using collision groups would be a more efficient way of doing
+// this, but we use custom filters instead for demonstration purpose.
+#[derive(SystemParam)]
+struct SameUserDataFilter<'w, 's> {
+    tags: Query<'w, 's, &'static CustomFilterTag>,
+}
+
+impl BevyPhysicsHooks for SameUserDataFilter<'_, '_> {
+    fn filter_contact_pair(&self, context: PairFilterContextView) -> Option<SolverFlags> {
+        if self.tags.get(context.collider1()).ok().copied()
+            == self.tags.get(context.collider2()).ok().copied()
+        {
+            Some(SolverFlags::COMPUTE_RIGID_IMPULSES)
+        } else {
+            None
+        }
+    }
+}
+
+fn main() {
+    App::new()
+        .insert_resource(ClearColor(Color::srgb(
+            0xF9 as f32 / 255.0,
+            0xF9 as f32 / 255.0,
+            0xFF as f32 / 255.0,
+        )))
+        .add_plugins((
+            DefaultPlugins,
+            RapierPhysicsPlugin::<SameUserDataFilter>::pixels_per_meter(100.0),
+            RapierDebugRenderPlugin::default(),
+        ))
+        .add_systems(Startup, (setup_graphics, setup_physics))
+        .run();
+}
+
+fn setup_graphics(mut commands: Commands) {
+    commands.spawn((Camera2d, Transform::from_xyz(0.0, 20.0, 0.0)));
+}
+
+pub fn setup_physics(mut commands: Commands) {
+    /*
+     * Ground
+     */
+    let ground_size = 100.0;
+
+    commands.spawn((
+        Transform::from_xyz(0.0, -100.0, 0.0),
+        Collider::cuboid(ground_size, 12.0),
+        CustomFilterTag::GroupA,
+    ));
+
+    commands.spawn((
+        Transform::from_xyz(0.0, 0.0, 0.0),
+        Collider::cuboid(ground_size, 12.0),
+        CustomFilterTag::GroupB,
+    ));
+
+    /*
+     * Create the cubes
+     */
+    let num = 4;
+    let rad = 5.0;
+
+    let shift = rad * 2.0;
+    let centerx = shift * (num as f32) / 2.0;
+    let centery = shift / 2.0;
+    let mut group_id = 0;
+    let tags = [CustomFilterTag::GroupA, CustomFilterTag::GroupB];
+    let colors = [Hsla::hsl(220.0, 1.0, 0.3), Hsla::hsl(260.0, 1.0, 0.7)];
+
+    for i in 0..num {
+        for j in 0usize..num * 5 {
+            let x = (i as f32 + j as f32 * 0.2) * shift - centerx;
+            let y = j as f32 * shift + centery + 20.0;
+            group_id += 1;
+
+            commands.spawn((
+                Transform::from_xyz(x, y, 0.0),
+                RigidBody::Dynamic,
+                Collider::cuboid(rad, rad),
+                ActiveHooks::FILTER_CONTACT_PAIRS,
+                tags[group_id % 2],
+                ColliderDebugColor(colors[group_id % 2]),
+            ));
+        }
+    }
+}
diff --git a/bindings/bevy_rapier/bevy_rapier2d/examples/custom_system_setup2.rs b/bindings/bevy_rapier/bevy_rapier2d/examples/custom_system_setup2.rs
new file mode 100644
index 000000000..26a8e0abf
--- /dev/null
+++ b/bindings/bevy_rapier/bevy_rapier2d/examples/custom_system_setup2.rs
@@ -0,0 +1,105 @@
+use bevy::{diagnostic::FrameCount, prelude::*};
+use bevy_rapier2d::prelude::*;
+
+fn main() {
+    let mut app = App::new();
+
+    app.insert_resource(ClearColor(Color::srgb(
+        0xF9 as f32 / 255.0,
+        0xF9 as f32 / 255.0,
+        0xFF as f32 / 255.0,
+    )))
+    .add_plugins((
+        DefaultPlugins,
+        RapierPhysicsPlugin::<NoUserData>::pixels_per_meter(100.0).with_default_system_setup(false),
+        RapierDebugRenderPlugin::default(),
+    ))
+    .add_systems(Startup, (setup_graphics, setup_physics));
+
+    app.configure_sets(
+        PostUpdate,
+        (
+            PhysicsSet::SyncBackend,
+            PhysicsSet::StepSimulation,
+            PhysicsSet::Writeback,
+        )
+            .chain()
+            .before(TransformSystems::Propagate),
+    );
+
+    app.add_systems(
+        PostUpdate,
+        (
+            RapierPhysicsPlugin::<NoUserData>::get_systems(PhysicsSet::SyncBackend)
+                .in_set(PhysicsSet::SyncBackend),
+            (
+                RapierPhysicsPlugin::<NoUserData>::get_systems(PhysicsSet::StepSimulation),
+                despawn_one_box,
+            )
+                .in_set(PhysicsSet::StepSimulation),
+            RapierPhysicsPlugin::<NoUserData>::get_systems(PhysicsSet::Writeback)
+                .in_set(PhysicsSet::Writeback),
+        ),
+    );
+
+    app.run();
+}
+
+fn despawn_one_box(
+    mut commands: Commands,
+    frame_count: ResMut<FrameCount>,
+    query: Query<Entity, (With<Collider>, With<RigidBody>)>,
+) {
+    // Delete a box every 10 frames
+    if frame_count.0.is_multiple_of(10) && !query.is_empty() {
+        let len = query.iter().len();
+        // Get a "random" box to make sim interesting
+        if let Some(entity) = query.iter().nth(frame_count.0 as usize % len) {
+            commands.entity(entity).despawn();
+        }
+    }
+}
+
+fn setup_graphics(mut commands: Commands) {
+    commands.spawn((Camera2d, Transform::from_xyz(0.0, 20.0, 0.0)));
+}
+
+pub fn setup_physics(mut commands: Commands) {
+    /*
+     * Ground
+     */
+    let ground_size = 500.0;
+    let ground_height = 10.0;
+
+    commands.spawn((
+        Transform::from_xyz(0.0, 0.0 * -ground_height, 0.0),
+        Collider::cuboid(ground_size, ground_height),
+    ));
+
+    /*
+     * Create the cubes
+     */
+    let num = 8;
+    let rad = 10.0;
+
+    let shift = rad * 2.0 + rad;
+    let centerx = shift * (num / 2) as f32;
+    let centery = shift / 2.0;
+
+    let mut offset = -(num as f32) * (rad * 2.0 + rad) * 0.5;
+
+    for j in 0usize..20 {
+        for i in 0..num {
+            let x = i as f32 * shift - centerx + offset;
+            let y = j as f32 * shift + centery + 30.0;
+
+            commands.spawn((
+                Transform::from_xyz(x, y, 0.0),
+                RigidBody::Dynamic,
+                Collider::cuboid(rad, rad),
+            ));
+        }
+
+        offset -= 0.05 * rad * (num as f32 - 1.0);
+    }
+}
diff --git a/bindings/bevy_rapier/bevy_rapier2d/examples/debug_despawn2.rs b/bindings/bevy_rapier/bevy_rapier2d/examples/debug_despawn2.rs
new file mode 100644
index 000000000..a26cd25fc
--- /dev/null
+++ b/bindings/bevy_rapier/bevy_rapier2d/examples/debug_despawn2.rs
@@ -0,0 +1,266 @@
+// NOTE: this demo is great for debugging despawning.
+//       It was extracted for one of the debug branch from @audunhalland
+//       in https://github.com/dimforge/bevy_rapier/issues/75
+
+use bevy::prelude::*;
+use bevy_rapier2d::prelude::*;
+
+fn main() {
+    App::new()
+        .init_resource::<Game>()
+        .insert_resource(ClearColor(Color::srgb(0.0, 0.0, 0.0)))
+        .add_plugins((
+            DefaultPlugins,
+            RapierPhysicsPlugin::<NoUserData>::pixels_per_meter(100.0),
+            RapierDebugRenderPlugin::default(),
+        ))
+        .add_systems(Startup, setup_game)
+        .add_systems(Update, cube_sleep_detection)
+        .run();
+}
+
+#[derive(Default)]
+struct Stats {
+    generated_blocks: i32,
+    cleared_blocks: i32,
+    lost_blocks: i32,
+    lost_cube: bool,
+}
+
+impl Stats {
+    fn health(&self) -> f32 {
+        if self.lost_cube {
+            0.0
+        } else if self.cleared_blocks == 0 {
+            if self.lost_blocks > 0 {
+                0.0
+            } else {
+                1.0
+            }
+        } else {
+            let lost_ratio = self.lost_blocks as f32 / self.cleared_blocks as f32;
+
+            1.0 - lost_ratio
+        }
+    }
+}
+
+#[derive(Resource)]
+pub struct Game {
+    n_lanes: usize,
+    n_rows: usize,
+    stats: Stats,
+    cube_colors: Vec<Color>,
+    current_cube_joints: Vec<Entity>,
+}
+
+impl Game {
+    fn floor_y(&self) -> f32 {
+        -(self.n_rows as f32) * 0.5
+    }
+    fn left_wall_x(&self) -> f32 {
+        -(self.n_lanes as f32) * 0.5
+    }
+}
+
+impl Default for Game {
+    fn default() -> Self {
+        Self {
+            n_lanes: 10,
+            n_rows: 20,
+            stats: Stats::default(),
+            cube_colors: vec![],
+            current_cube_joints: vec![],
+        }
+    }
+}
+
+fn byte_rgb(r: u8, g: u8, b: u8) -> Color {
+    Color::srgb(r as f32 / 255.0, g as f32 / 255.0, b as f32 / 255.0)
+}
+
+pub fn setup_game(mut commands: Commands, mut game: ResMut<Game>) {
+    game.current_cube_joints = vec![];
+
+    game.cube_colors = vec![
+        byte_rgb(0, 244, 243),
+        byte_rgb(238, 243, 0),
+        byte_rgb(177, 0, 254),
+        byte_rgb(27, 0, 250),
+        byte_rgb(252, 157, 0),
+        byte_rgb(0, 247, 0),
+        byte_rgb(255, 0, 0),
+    ];
+
+    commands.spawn(Camera2d);
+
+    setup_board(&mut commands, &game);
+
+    // initial cube
+    spawn_cube(&mut commands, &mut game);
+}
+
+#[derive(Clone, Copy, Debug)]
+enum CubeKind {
+    I,
+}
+
+impl CubeKind {
+    fn random() -> Self {
+        Self::I
+    }
+
+    fn layout(&self) -> CubeLayout {
+        CubeLayout {
+            coords: [(1, 1), (1, 0), (1, -1), (1, -2)],
+            joints: vec![(0, 1), (1, 2), (2, 3)],
+        }
+    }
+}
+
+struct CubeLayout {
+    coords: [(i32, i32); 4],
+    joints: Vec<(usize, usize)>,
+}
+
+#[derive(Component)]
+struct Block;
+
+fn setup_board(commands: &mut Commands, game: &Game) {
+    let floor_y = game.floor_y();
+
+    // Add floor
+    commands.spawn((
+        Sprite {
+            color: Color::srgb(0.5, 0.5, 0.5),
+            custom_size: Some(Vec2::new(game.n_lanes as f32 * 30.0, 60.0)),
+            ..Default::default()
+        },
+        Transform::from_xyz(0.0, floor_y - 30.0 * 0.5, 0.0),
+        RigidBody::Fixed,
+        Collider::cuboid(game.n_lanes as f32 * 30.0 / 2.0, 60.0 / 2.0),
+    ));
+}
+
+fn spawn_cube(commands: &mut Commands, game: &mut Game) {
+    let kind = CubeKind::random();
+    let CubeLayout { coords, joints } = kind.layout();
+
+    let block_entities: Vec<Entity> = coords
+        .iter()
+        .map(|(x, y)| {
+            let lane = (game.n_lanes as i32 / 2) - 1 + x;
+            let row = game.n_rows as i32 - 1 + y;
+            spawn_block(commands, game, kind, lane, row)
+        })
+        .collect();
+
+    game.current_cube_joints.clear();
+    for (i, j) in &joints {
+        let x_dir = coords[*j].0 as f32 - coords[*i].0 as f32;
+        let y_dir = coords[*j].1 as f32 - coords[*i].1 as f32;
+
+        let anchor_1 = Vec2::new(x_dir * 0.5, y_dir * 0.5);
+        let anchor_2 = Vec2::new(x_dir * -0.5, y_dir * -0.5);
+
+        commands
+            .entity(block_entities[*j])
+            .with_children(|children| {
+                let id = children
+                    .spawn(ImpulseJoint::new(
+                        block_entities[*i],
+                        RevoluteJointBuilder::new()
+                            .local_anchor1(anchor_1)
+                            .local_anchor2(anchor_2),
+                    ))
+                    .id();
+                game.current_cube_joints.push(id);
+            });
+    }
+
+    game.stats.generated_blocks += block_entities.len() as i32;
+}
+
+fn spawn_block(
+    commands: &mut Commands,
+    game: &Game,
+    kind: CubeKind,
+    lane: i32,
+    row: i32,
+) -> Entity {
+    // x, y is the center of the block
+    let x = game.left_wall_x() + lane as f32 + 0.5;
+    let y = game.floor_y() + row as f32 + 0.5;
+
+    // Game gets more difficult when this is lower:
+    let linear_damping = 3.0;
+
+    commands
+        .spawn((
+            Sprite {
+                color: game.cube_colors[kind as usize],
+                custom_size: Some(Vec2::new(30.0, 30.0)),
+                ..Default::default()
+            },
+            Transform::from_xyz(x, y, 0.0),
+            RigidBody::Dynamic,
+            Damping {
+                linear_damping,
+                angular_damping: 0.0,
+            },
+            Collider::cuboid(30.0 / 2.0, 30.0 / 2.0),
+            Block,
+        ))
+        .id()
+}
+
+pub fn cube_sleep_detection(
+    mut commands: Commands,
+    mut game: ResMut<Game>,
+    block_query: Query<(Entity, &GlobalTransform)>,
+) {
+    let all_blocks_sleeping = true;
+
+    if all_blocks_sleeping {
+        for joint in &game.current_cube_joints {
+            commands.entity(*joint).despawn();
+        }
+
+        clear_filled_rows(&mut commands, &mut game, block_query);
+
+        if game.stats.health() > 0.0 {
+            spawn_cube(&mut commands, &mut game);
+        }
+    }
+}
+
+fn clear_filled_rows(
+    commands: &mut Commands,
+    game: &mut Game,
+    block_query: Query<(Entity, &GlobalTransform)>,
+) {
+    let mut blocks_per_row: Vec<Vec<Entity>> = (0..game.n_rows).map(|_| vec![]).collect();
+
+    let floor_y = game.floor_y();
+
+    for (block_entity, position) in block_query.iter() {
+        let floor_distance = position.translation().y - floor_y;
+
+        // The center of a block on the floor is 0.5 above the floor, so .floor() the number ;)
+        let row = floor_distance.floor() as i32;
+
+        if row >= 0 && row < game.n_rows as i32 {
+            blocks_per_row[row as usize].push(block_entity);
+        }
+    }
+
+    for row_blocks in blocks_per_row {
+        if row_blocks.len() == game.n_lanes {
+            game.stats.cleared_blocks += game.n_lanes as i32;
+
+            for block_entity in row_blocks {
+                commands.entity(block_entity).despawn();
+            }
+        }
+    }
+}
diff --git a/bindings/bevy_rapier/bevy_rapier2d/examples/debug_toggle2.rs b/bindings/bevy_rapier/bevy_rapier2d/examples/debug_toggle2.rs
new file mode 100644
index 000000000..a5b1e1e05
--- /dev/null
+++ b/bindings/bevy_rapier/bevy_rapier2d/examples/debug_toggle2.rs
@@ -0,0 +1,114 @@
+use std::time::Duration;
+
+pub use bevy::input::common_conditions::input_just_pressed;
+use bevy::prelude::*;
+use bevy_rapier2d::prelude::*;
+
+fn main() {
+    App::new()
+        .insert_resource(ClearColor(Color::srgb(
+            0xF9 as f32 / 255.0,
+            0xF9 as f32 / 255.0,
+            0xFF as f32 / 255.0,
+        )))
+        .add_plugins((
+            DefaultPlugins,
+            RapierPhysicsPlugin::<NoUserData>::default(),
+            RapierDebugRenderPlugin::default(),
+        ))
+        .add_systems(Startup, (setup_graphics, setup_physics))
+        .add_systems(
+            Update,
+            (
+                toggle_debug,
+                (|mut debug_render_context: ResMut<DebugRenderContext>| {
+                    debug_render_context.enabled = !debug_render_context.enabled;
+                })
+                .run_if(input_just_pressed(KeyCode::KeyV)),
+            ),
+        )
+        .run();
+}
+
+pub fn setup_graphics(mut commands: Commands) {
+    commands.spawn((
+        Camera3d::default(),
+        Transform::from_xyz(-30.0, 30.0, 100.0).looking_at(Vec3::new(0.0, 10.0, 0.0), Vec3::Y),
+    ));
+}
+
+#[derive(Component)]
+pub struct DebugCooldown(pub Timer);
+
+pub fn setup_physics(mut commands: Commands) {
+    /*
+     * Ground
+     */
+    let ground_size = 200.1;
+    let ground_height = 0.1;
+
+    commands.spawn((
+        Transform::from_xyz(0.0, -ground_height, 0.0),
+        Collider::cuboid(ground_size, ground_height),
+    ));
+
+    /*
+     * Create the cubes
+     */
+    let num = 8;
+    let rad = 1.0;
+
+    let shift = rad * 2.0 + rad;
+    let centerx = shift * (num / 2) as f32;
+    let centery = shift / 2.0;
+    let centerz = shift * (num / 2) as f32;
+
+    let mut offset = -(num as f32) * (rad * 2.0 + rad) * 0.5;
+    let mut color = 0;
+    let colors = [
+        Hsla::hsl(220.0, 1.0, 0.3),
+        Hsla::hsl(180.0, 1.0, 0.3),
+        Hsla::hsl(260.0, 1.0, 0.7),
+    ];
+
+    for j in 0usize..20 {
+        for i in 0..num {
+            for k in 0usize..num {
+                let x = i as f32 * shift - centerx + offset;
+                let y = j as f32 * shift + centery + 3.0;
+                let z = k as f32 * shift - centerz + offset;
+                color += 1;
+
+                commands
+                    .spawn(Transform::from_rotation(Quat::from_rotation_x(0.2)))
+                    .with_children(|child| {
+                        child.spawn((
+                            Transform::from_xyz(x, y, z),
+                            RigidBody::Dynamic,
+                            Collider::cuboid(rad, rad),
+                            ColliderDebugColor(colors[color % 3]),
+                            ColliderDebug::AlwaysRender,
+                            DebugCooldown(Timer::new(
+                                Duration::from_secs_f32(0.4f32 + (i % 3 + (j + 1) % 3) as f32),
+                                TimerMode::Repeating,
+                            )),
+                        ));
+                    });
+            }
+        }
+
+        offset -= 0.05 * rad * (num as f32 - 1.0);
+    }
+}
+
+pub fn toggle_debug(time: Res<Time>, mut query: Query<(&mut ColliderDebug, &mut DebugCooldown)>) {
+    for (mut debug, mut cooldown) in query.iter_mut() {
+        cooldown.0.tick(time.delta());
+        if cooldown.0.just_finished() {
+            *debug = match *debug {
+                ColliderDebug::AlwaysRender => ColliderDebug::NeverRender,
+                ColliderDebug::NeverRender => ColliderDebug::AlwaysRender,
+            }
+        }
+    }
+}
diff --git a/bindings/bevy_rapier/bevy_rapier2d/examples/despawn2.rs b/bindings/bevy_rapier/bevy_rapier2d/examples/despawn2.rs
new file mode 100644
index 000000000..af3eef230
--- /dev/null
+++ b/bindings/bevy_rapier/bevy_rapier2d/examples/despawn2.rs
@@ -0,0 +1,119 @@
+use bevy::prelude::*;
+use bevy_rapier2d::prelude::*;
+
+#[derive(Component, Default)]
+pub struct Despawn;
+#[derive(Component, Default)]
+pub struct Resize;
+
+#[derive(Resource, Default)]
+pub struct DespawnResource {
+    timer: Timer,
+}
+
+#[derive(Resource, Default)]
+pub struct ResizeResource {
+    timer: Timer,
+}
+
+fn main() {
+    App::new()
+        .insert_resource(ClearColor(Color::srgb(
+            0xF9 as f32 / 255.0,
+            0xF9 as f32 / 255.0,
+            0xFF as f32 / 255.0,
+        )))
+        .insert_resource(DespawnResource::default())
+        .insert_resource(ResizeResource::default())
+        .add_plugins((
+            DefaultPlugins,
+            RapierPhysicsPlugin::<NoUserData>::pixels_per_meter(100.0),
+            RapierDebugRenderPlugin::default(),
+        ))
+        .add_systems(Startup, (setup_graphics, setup_physics))
+        .add_systems(Update, (despawn, resize))
+        .run();
+}
+
+pub fn setup_graphics(
+    mut commands: Commands,
+    mut despawn: ResMut<DespawnResource>,
+    mut resize: ResMut<ResizeResource>,
+) {
+    resize.timer = Timer::from_seconds(6.0, TimerMode::Once);
+    despawn.timer = Timer::from_seconds(5.0, TimerMode::Once);
+
+    commands.spawn((Camera2d, Transform::from_xyz(0.0, 20.0, 0.0)));
+}
+
+pub fn setup_physics(mut commands: Commands) {
+    /*
+     * Ground
+     */
+    let ground_size = 250.0;
+
+    commands.spawn((Collider::cuboid(ground_size, 12.0), Despawn));
+
+    commands.spawn((
+        Transform::from_xyz(ground_size, ground_size * 2.0, 0.0),
+        Collider::cuboid(12.0, ground_size * 2.0),
+    ));
+
+    commands.spawn((
+        Transform::from_xyz(-ground_size, ground_size * 2.0, 0.0),
+        Collider::cuboid(12.0, ground_size * 2.0),
+    ));
+
+    /*
+     * Create the cubes
+     */
+    let num = 20;
+    let rad = 5.0;
+
+    let shift = rad * 2.0;
+    let centerx = shift * (num as f32) / 2.0;
+    let centery = shift / 2.0;
+
+    for i in 0..num {
+        for j in 0usize..num * 5 {
+            let x = i as f32 * shift - centerx;
+            let y = j as f32 * shift + centery + 2.0;
+
+            let mut entity = commands.spawn((
+                Transform::from_xyz(x, y, 0.0),
+                RigidBody::Dynamic,
+                Collider::cuboid(rad, rad),
+            ));
+
+            if (i + j * num).is_multiple_of(100) {
+                entity.insert(Resize);
+            }
+        }
+    }
+}
+
+pub fn despawn(
+    mut commands: Commands,
+    time: Res<Time>,
+    mut despawn: ResMut<DespawnResource>,
+    query: Query<Entity, With<Despawn>>,
+) {
+    if despawn.timer.tick(time.delta()).just_finished() {
+        for e in &query {
+            commands.entity(e).despawn();
+        }
+    }
+}
+
+pub fn resize(
+    mut commands: Commands,
+    time: Res<Time>,
+    mut resize: ResMut<ResizeResource>,
+    query: Query<Entity, With<Resize>>,
+) {
+    if resize.timer.tick(time.delta()).just_finished() {
+        for e in &query {
+            commands.entity(e).insert(Collider::cuboid(20.0, 20.0));
+        }
+    }
+}
diff --git a/bindings/bevy_rapier/bevy_rapier2d/examples/events2.rs b/bindings/bevy_rapier/bevy_rapier2d/examples/events2.rs
new file mode 100644
index 000000000..195e06bfd
--- /dev/null
+++ b/bindings/bevy_rapier/bevy_rapier2d/examples/events2.rs
@@ -0,0 +1,60 @@
+use bevy::prelude::*;
+use bevy_rapier2d::prelude::*;
+
+fn main() {
+    App::new()
+        .insert_resource(ClearColor(Color::srgb(
+            0xF9 as f32 / 255.0,
+            0xF9 as f32 / 255.0,
+            0xFF as f32 / 255.0,
+        )))
+        .add_plugins((
+            DefaultPlugins,
+            RapierPhysicsPlugin::<NoUserData>::pixels_per_meter(100.0),
+            RapierDebugRenderPlugin::default(),
+        ))
+        .add_systems(Startup, (setup_graphics, setup_physics))
+        .add_systems(PostUpdate, display_events)
+        .run();
+}
+
+pub fn setup_graphics(mut commands: Commands) {
+    commands.spawn(Camera2d);
+}
+
+pub fn display_events(
+    mut collision_events: MessageReader<CollisionEvent>,
+    mut contact_force_events: MessageReader<ContactForceEvent>,
+) {
+    for collision_event in collision_events.read() {
+        println!("Received collision event: {collision_event:?}");
+    }
+
+    for contact_force_event in contact_force_events.read() {
+        println!("Received contact force event: {contact_force_event:?}");
+    }
+}
+
+pub fn setup_physics(mut commands: Commands) {
+    /*
+     * Ground
+     */
+    commands.spawn((
+        Transform::from_xyz(0.0, -24.0, 0.0),
+        Collider::cuboid(80.0, 20.0),
+    ));
+
+    commands.spawn((
+        Transform::from_xyz(0.0, 100.0, 0.0),
+        Collider::cuboid(80.0, 30.0),
+        Sensor,
+    ));
+
+    commands.spawn((
+        Transform::from_xyz(0.0, 260.0, 0.0),
+        RigidBody::Dynamic,
+        Collider::cuboid(10.0, 10.0),
+        ActiveEvents::COLLISION_EVENTS,
+        ContactForceEventThreshold(10.0),
+    ));
+}
diff --git a/bindings/bevy_rapier/bevy_rapier2d/examples/inverse_kinematics2.rs b/bindings/bevy_rapier/bevy_rapier2d/examples/inverse_kinematics2.rs
new file mode 100644
index 000000000..2915085cd
--- /dev/null
+++ b/bindings/bevy_rapier/bevy_rapier2d/examples/inverse_kinematics2.rs
@@ -0,0 +1,133 @@
+//! Multibody inverse kinematics: the end of a chain of ten revolute multibody joints follows the
+//! mouse cursor (or a circle while the cursor is outside of the window).
+
+use bevy::prelude::*;
+use bevy::window::PrimaryWindow;
+use bevy_rapier2d::prelude::*;
+
+fn main() {
+    App::new()
+        .insert_resource(ClearColor(Color::srgb(
+            0xF9 as f32 / 255.0,
+            0xF9 as f32 / 255.0,
+            0xFF as f32 / 255.0,
+        )))
+        .add_plugins((
+            DefaultPlugins,
+            RapierPhysicsPlugin::<NoUserData>::default(),
+            RapierDebugRenderPlugin::default(),
+        ))
+        .add_systems(Startup, (setup_graphics, setup_physics))
+        .add_systems(Update, (update_target, track_target).chain())
+        .run();
+}
+
+/// The last link of the chain, driven by the inverse kinematics solver.
+#[derive(Resource)]
+struct EndEffector(Entity);
+
+/// The world-space point the end effector tries to reach.
+#[derive(Resource, Default)]
+struct IkTarget(Vec2);
+
+pub fn setup_graphics(mut commands: Commands) {
+    // The scene is expressed in meters: zoom in so that one meter spans 300 pixels.
+    commands.spawn((
+        Camera2d,
+        Projection::from(OrthographicProjection {
+            scale: 1.0 / 300.0,
+            ..OrthographicProjection::default_2d()
+        }),
+        Transform::from_xyz(0.0, 0.5, 0.0),
+    ));
+}
+
+pub fn setup_physics(mut commands: Commands) {
+    /*
+     * Ground.
+     */
+    let ground_size = 1.0;
+    let ground_height = 0.01;
+    commands.spawn((
+        Transform::from_xyz(0.0, -ground_height, 0.0),
+        Collider::cuboid(ground_size, ground_height),
+    ));
+
+    /*
+     * The chain, attached to a fixed root with revolute multibody joints.
+     */
+    let num_segments = 10;
+    let size = 1.0 / num_segments as f32;
+    let mut last_body = commands
+        .spawn((Transform::default(), RigidBody::Fixed))
+        .id();
+
+    for i in 0..num_segments {
+        let joint = RevoluteJointBuilder::new()
+            .local_anchor1(Vec2::new(0.0, if i == 0 { 0.0 } else { size / 2.0 }))
+            .local_anchor2(Vec2::new(0.0, -size / 2.0));
+
+        // The sensor collider is only here to let the debug-renderer draw the links.
+        last_body = commands
+            .spawn((
+                Transform::from_xyz(0.0, (i as f32 + 0.5) * size, 0.0),
+                RigidBody::Dynamic,
+                Sleeping::disabled(),
+                Collider::cuboid(size / 8.0, size / 2.0),
+                ColliderMassProperties::Density(0.0),
+                Sensor,
+                MultibodyJoint::new(last_body, joint),
+            ))
+            .id();
+    }
+
+    commands.insert_resource(EndEffector(last_body));
+    commands.insert_resource(IkTarget::default());
+}
+
+/// Moves the target to the mouse cursor, or along a circle if the cursor isn’t in the window.
+fn update_target(
+    time: Res<Time>,
+    window: Single<&Window, With<PrimaryWindow>>,
+    camera: Single<(&Camera, &GlobalTransform)>,
+    mut target: ResMut<IkTarget>,
+    mut gizmos: Gizmos,
+) {
+    let (camera, camera_transform) = *camera;
+    let cursor = window
+        .cursor_position()
+        .and_then(|cursor| camera.viewport_to_world_2d(camera_transform, cursor).ok());
+
+    target.0 = cursor.unwrap_or_else(|| {
+        let t = time.elapsed_secs();
+        Vec2::new(0.0, 0.5) + 0.4 * Vec2::new(t.cos(), t.sin())
+    });
+    gizmos.circle_2d(target.0, 0.02, Color::srgb(0.9, 0.2, 0.2));
+}
+
+/// Runs the inverse kinematics solver on the chain and applies the resulting displacements.
+fn track_target(
+    mut context: WriteRapierContext,
+    end_effector: Res<EndEffector>,
+    target: Res<IkTarget>,
+    mut displacements: Local<Vec<f32>>,
+) -> Result<()> {
+    let options = InverseKinematicsOption {
+        constrained_axes: JointAxesMask::LIN_AXES,
+        ..Default::default()
+    };
+
+    // The displacements buffer is reset by the solver, so it can be reused across frames.
+    let mut context = context.single_mut()?;
+    if context.multibody_inverse_kinematics(
+        end_effector.0,
+        Transform::from_translation(target.0.extend(0.0)),
+        &options,
+        |_| true,
+        &mut displacements,
+    ) {
+        context.multibody_apply_displacements(end_effector.0, &displacements);
+    }
+
+    Ok(())
+}
diff --git a/bindings/bevy_rapier/bevy_rapier2d/examples/joint_motor_position2.rs b/bindings/bevy_rapier/bevy_rapier2d/examples/joint_motor_position2.rs
new file mode 100644
index 000000000..c26c01a34
--- /dev/null
+++ b/bindings/bevy_rapier/bevy_rapier2d/examples/joint_motor_position2.rs
@@ -0,0 +1,90 @@
+//! Revolute joint motors without gravity: the bottom row uses position motors reaching increasing
+//! target angles, and the top row uses velocity motors stopped by increasing angular limits.
+
+use std::f32::consts::PI;
+
+use bevy::prelude::*;
+use bevy_rapier2d::prelude::*;
+
+fn main() {
+    App::new()
+        .insert_resource(ClearColor(Color::srgb(
+            0xF9 as f32 / 255.0,
+            0xF9 as f32 / 255.0,
+            0xFF as f32 / 255.0,
+        )))
+        .add_plugins((
+            DefaultPlugins,
+            RapierPhysicsPlugin::<NoUserData>::default(),
+            RapierDebugRenderPlugin::default(),
+        ))
+        .add_systems(Startup, (setup_graphics, setup_physics))
+        .run();
+}
+
+pub fn setup_graphics(mut commands: Commands) {
+    // The scene is expressed in meters: zoom in so that one meter spans 40 pixels.
+    commands.spawn((
+        Camera2d,
+        Projection::from(OrthographicProjection {
+            scale: 1.0 / 40.0,
+            ..OrthographicProjection::default_2d()
+        }),
+    ));
+}
+
+pub fn setup_physics(
+    mut commands: Commands,
+    mut rapier_config: Query<&mut RapierConfiguration>,
+) -> Result<()> {
+    rapier_config.single_mut()?.gravity = Vec2::ZERO;
+
+    /*
+     * Fixed ground to attach one end of the joints.
+     */
+    let ground = commands
+        .spawn((Transform::default(), RigidBody::Fixed))
+        .id();
+
+    /*
+     * Rectangles on motors with a target position.
+     */
+    for num in 0..9 {
+        let x_pos = -6.0 + 1.5 * num as f32;
+        let joint = RevoluteJointBuilder::new()
+            .local_anchor1(Vec2::new(x_pos, 1.5))
+            .local_anchor2(Vec2::new(0.0, -0.5))
+            .motor_position(-PI + PI / 4.0 * num as f32, 1000.0, 150.0);
+
+        commands.spawn((
+            Transform::from_xyz(x_pos, 2.0, 0.0),
+            RigidBody::Dynamic,
+            Sleeping::disabled(),
+            Collider::cuboid(0.1, 0.5),
+            ImpulseJoint::new(ground, joint),
+        ));
+    }
+
+    /*
+     * Rectangles on velocity motors, stopped by their limits.
+     */
+    for num in 0..8 {
+        let x_pos = -6.0 + 1.5 * num as f32;
+        let joint = RevoluteJointBuilder::new()
+            .local_anchor1(Vec2::new(x_pos, 5.0))
+            .local_anchor2(Vec2::new(0.0, -0.5))
+            .motor_velocity(1.5, 30.0)
+            .motor_max_force(100.0)
+            .limits([-PI, -PI + PI / 4.0 * num as f32]);
+
+        commands.spawn((
+            Transform::from_xyz(x_pos, 4.5, 0.0).with_rotation(Quat::from_rotation_z(PI)),
+            RigidBody::Dynamic,
+            Sleeping::disabled(),
+            Collider::cuboid(0.1, 0.5),
+            ImpulseJoint::new(ground, joint),
+        ));
+    }
+
+    Ok(())
+}
diff --git a/bindings/bevy_rapier/bevy_rapier2d/examples/joints2.rs b/bindings/bevy_rapier/bevy_rapier2d/examples/joints2.rs
new file mode 100644
index 000000000..f5c594bae
--- /dev/null
+++ b/bindings/bevy_rapier/bevy_rapier2d/examples/joints2.rs
@@ -0,0 +1,81 @@
+use bevy::prelude::*;
+use bevy_rapier2d::prelude::*;
+
+#[allow(unused)]
+fn main() {
+    App::new()
+        .insert_resource(ClearColor(Color::srgb(
+            0xF9 as f32 / 255.0,
+            0xF9 as f32 / 255.0,
+            0xFF as f32 / 255.0,
+        )))
+        .add_plugins((
+            DefaultPlugins,
+            RapierPhysicsPlugin::<NoUserData>::pixels_per_meter(100.0),
+            RapierDebugRenderPlugin::default(),
+        ))
+        .add_systems(Startup, (setup_graphics, setup_physics))
+        .run();
+}
+
+pub fn setup_graphics(mut commands: Commands) {
+    commands.spawn((Camera2d, Transform::from_xyz(0.0, -200.0, 0.0)));
+}
+
+pub fn setup_physics(mut commands: Commands) {
+    // Build the rigid body.
+    let rad = 4.0;
+    let numi = 40; // Num vertical nodes.
+    let numk = 40; // Num horizontal nodes.
+    let shift = 10.0;
+
+    let mut body_entities = Vec::new();
+
+    for k in 0..numk {
+        for i in 0..numi {
+            let fk = k as f32;
+            let fi = i as f32;
+
+            let rigid_body = if i == 0 && (k % 4 == 0 || k == numk - 1) {
+                RigidBody::Fixed
+            } else {
+                RigidBody::Dynamic
+            };
+
+            let child_entity = commands
+                .spawn((
+                    Transform::from_xyz(fk * shift, -fi * shift, 0.0),
+                    rigid_body,
+                    Collider::cuboid(rad, rad),
+                ))
+                .id();
+
+            // Vertical joint.
+            if i > 0 {
+                let parent_entity = *body_entities.last().unwrap();
+                let joint = RevoluteJointBuilder::new().local_anchor2(Vec2::new(0.0, shift));
+                commands.entity(child_entity).with_children(|cmd| {
+                    // NOTE: we want to attach multiple impulse joints to this entity, so
+                    //       we need to add the components to children of the entity. Otherwise
+                    //       the second joint component would just overwrite the first one.
+                    cmd.spawn(ImpulseJoint::new(parent_entity, joint));
+                });
+            }
+
+            // Horizontal joint.
+            if k > 0 {
+                let parent_index = body_entities.len() - numi;
+                let parent_entity = body_entities[parent_index];
+                let joint = RevoluteJointBuilder::new().local_anchor2(Vec2::new(-shift, 0.0));
+                commands.entity(child_entity).with_children(|cmd| {
+                    // NOTE: we want to attach multiple impulse joints to this entity, so
+                    //       we need to add the components to children of the entity. Otherwise
+                    //       the second joint component would just overwrite the first one.
+                    cmd.spawn(ImpulseJoint::new(parent_entity, joint));
+                });
+            }
+
+            body_entities.push(child_entity);
+        }
+    }
+}
diff --git a/bindings/bevy_rapier/bevy_rapier2d/examples/joints_despawn2.rs b/bindings/bevy_rapier/bevy_rapier2d/examples/joints_despawn2.rs
new file mode 100644
index 000000000..94dc29830
--- /dev/null
+++ b/bindings/bevy_rapier/bevy_rapier2d/examples/joints_despawn2.rs
@@ -0,0 +1,112 @@
+use bevy::prelude::*;
+use bevy_rapier2d::prelude::*;
+
+#[derive(Component, Default)]
+pub struct Despawn;
+
+#[derive(Resource, Default)]
+pub struct DespawnResource {
+    timer: Timer,
+}
+
+fn main() {
+    App::new()
+        .insert_resource(ClearColor(Color::srgb(
+            0xF9 as f32 / 255.0,
+            0xF9 as f32 / 255.0,
+            0xFF as f32 / 255.0,
+        )))
+        .insert_resource(DespawnResource::default())
+        .add_plugins((
+            DefaultPlugins,
+            RapierPhysicsPlugin::<NoUserData>::pixels_per_meter(100.0),
+            RapierDebugRenderPlugin::default(),
+        ))
+        .add_systems(Startup, (setup_graphics, setup_physics))
+        .add_systems(Update, despawn)
+        .run();
+}
+
+pub fn setup_graphics(mut commands: Commands) {
+    commands.spawn((Camera2d, Transform::from_xyz(0.0, -200.0, 0.0)));
+}
+
+pub fn setup_physics(mut commands: Commands, mut despawn: ResMut<DespawnResource>) {
+    despawn.timer = Timer::from_seconds(4.0, TimerMode::Once);
+
+    // Build the rigid body.
+    let rad = 4.0;
+    let numi = 40; // Num vertical nodes.
+    let numk = 40; // Num horizontal nodes.
+    let shift = 10.0;
+
+    let mut body_entities = Vec::new();
+
+    for k in 0..numk {
+        for i in 0..numi {
+            let fk = k as f32;
+            let fi = i as f32;
+
+            let rigid_body = if i == 0 && (k % 4 == 0 || k == numk - 1) {
+                RigidBody::Fixed
+            } else {
+                RigidBody::Dynamic
+            };
+
+            let child_entity = commands
+                .spawn((
+                    Transform::from_xyz(fk * shift, -fi * shift, 0.0),
+                    rigid_body,
+                    Collider::cuboid(rad, rad),
+                ))
+                .id();
+
+            // Vertical joint.
+            if i > 0 {
+                let parent_entity = *body_entities.last().unwrap();
+                let joint = RevoluteJointBuilder::new().local_anchor2(Vec2::new(0.0, shift));
+                commands.entity(child_entity).with_children(|cmd| {
+                    // NOTE: we want to attach multiple impulse joints to this entity, so
+                    //       we need to add the components to children of the entity. Otherwise
+                    //       the second joint component would just overwrite the first one.
+                    let mut entity = cmd.spawn(ImpulseJoint::new(parent_entity, joint));
+                    if i == (numi / 2) || (k % 4 == 0 || k == numk - 1) {
+                        entity.insert(Despawn);
+                    }
+                });
+            }
+
+            // Horizontal joint.
+            if k > 0 {
+                let parent_index = body_entities.len() - numi;
+                let parent_entity = body_entities[parent_index];
+                let joint = RevoluteJointBuilder::new().local_anchor2(Vec2::new(-shift, 0.0));
+                commands.entity(child_entity).with_children(|cmd| {
+                    // NOTE: we want to attach multiple impulse joints to this entity, so
+                    //       we need to add the components to children of the entity. Otherwise
+                    //       the second joint component would just overwrite the first one.
+                    let mut entity = cmd.spawn(ImpulseJoint::new(parent_entity, joint));
+                    if i == (numi / 2) || (k % 4 == 0 || k == numk - 1) {
+                        entity.insert(Despawn);
+                    }
+                });
+            }
+
+            body_entities.push(child_entity);
+        }
+    }
+}
+
+pub fn despawn(
+    mut commands: Commands,
+    time: Res<Time>,
+    mut despawn: ResMut<DespawnResource>,
+    query: Query<Entity, With<Despawn>>,
+) {
+    if despawn.timer.tick(time.delta()).just_finished() {
+        for e in &query {
+            println!("Despawning joint entity");
+            commands.entity(e).despawn();
+        }
+    }
+}
diff --git a/bindings/bevy_rapier/bevy_rapier2d/examples/locked_rotations2.rs b/bindings/bevy_rapier/bevy_rapier2d/examples/locked_rotations2.rs
new file mode 100644
index 000000000..c4f202843
--- /dev/null
+++ b/bindings/bevy_rapier/bevy_rapier2d/examples/locked_rotations2.rs
@@ -0,0 +1,55 @@
+use bevy::prelude::*;
+use bevy_rapier2d::prelude::*;
+
+fn main() {
+    App::new()
+        .insert_resource(ClearColor(Color::srgb(
+            0xF9 as f32 / 255.0,
+            0xF9 as f32 / 255.0,
+            0xFF as f32 / 255.0,
+        )))
+        .add_plugins((
+            DefaultPlugins,
+            RapierPhysicsPlugin::<NoUserData>::pixels_per_meter(100.0),
+            RapierDebugRenderPlugin::default(),
+        ))
+        .add_systems(Startup, (setup_graphics, setup_physics))
+        .run();
+}
+
+pub fn setup_graphics(mut commands: Commands) {
+    commands.spawn((Camera2d, Transform::from_xyz(0.0, 200.0, 0.0)));
+}
+
+pub fn setup_physics(mut commands: Commands) {
+    /*
+     * The ground
+     */
+    let ground_size = 500.0;
+    let ground_height = 10.0;
+
+    commands.spawn((
+        Transform::from_xyz(0.0, -ground_height, 0.0),
+        Collider::cuboid(ground_size, ground_height),
+    ));
+
+    /*
+     * A rectangle that only rotate.
+     */
+    commands.spawn((
+        Transform::from_xyz(0.0, 300.0, 0.0),
+        RigidBody::Dynamic,
+        LockedAxes::TRANSLATION_LOCKED,
+        Collider::cuboid(200.0, 60.0),
+    ));
+
+    /*
+     * A tilted cuboid that cannot rotate.
+     */
+    commands.spawn((
+        Transform::from_xyz(50.0, 500.0, 0.0).with_rotation(Quat::from_rotation_z(1.0)),
+        RigidBody::Dynamic,
+        LockedAxes::ROTATION_LOCKED,
+        Collider::cuboid(60.0, 40.0),
+    ));
+}
diff --git a/bindings/bevy_rapier/bevy_rapier2d/examples/multibody_joints2.rs b/bindings/bevy_rapier/bevy_rapier2d/examples/multibody_joints2.rs
new file mode 100644
index 000000000..5bcaf58fa
--- /dev/null
+++ b/bindings/bevy_rapier/bevy_rapier2d/examples/multibody_joints2.rs
@@ -0,0 +1,175 @@
+//! Multibody pendulums, each configured with a different per-joint multibody option: default
+//! joints, `MultibodyJointDamping`, `MultibodyJointFriction`, `MultibodyJointSprings`,
+//! `MultibodyJointArmature`, and a `KinematicMultibodyJoint` spinning the first link at a constant
+//! velocity.
+
+use bevy::prelude::*;
+use bevy_rapier2d::prelude::*;
+
+/// Half the length of each pendulum segment.
+const HALF_LENGTH: f32 = 1.0;
+/// The number of segments of each pendulum.
+const SEGMENTS: usize = 4;
+/// The angular velocity of the kinematic joints, in radians per second.
+const KINEMATIC_SPEED: f32 = 1.0;
+
+fn main() {
+    App::new()
+        .insert_resource(ClearColor(Color::srgb(
+            0xF9 as f32 / 255.0,
+            0xF9 as f32 / 255.0,
+            0xFF as f32 / 255.0,
+        )))
+        .add_plugins((
+            DefaultPlugins,
+            RapierPhysicsPlugin::<NoUserData>::default(),
+            RapierDebugRenderPlugin::default(),
+        ))
+        .add_systems(Startup, (setup_graphics, setup_physics))
+        .add_systems(Update, drive_kinematic_joints)
+        .run();
+}
+
+/// The multibody joint option showcased by a pendulum.
+#[derive(Copy, Clone)]
+enum PendulumKind {
+    Default,
+    Damping,
+    Friction,
+    Springs,
+    Armature,
+    Kinematic,
+}
+
+pub fn setup_graphics(mut commands: Commands) {
+    // The scene is expressed in meters: zoom in so that one meter spans 25 pixels.
+    commands.spawn((
+        Camera2d,
+        Projection::from(OrthographicProjection {
+            scale: 0.04,
+            ..OrthographicProjection::default_2d()
+        }),
+    ));
+    commands.spawn((
+        Text::new(
+            "Top row: default joints, damping, friction\n\
+             Bottom row: springs, armature, kinematic first joint",
+        ),
+        Node {
+            position_type: PositionType::Absolute,
+            top: Val::Px(12.0),
+            left: Val::Px(12.0),
+            ..default()
+        },
+        TextColor(Color::BLACK),
+    ));
+}
+
+pub fn setup_physics(mut commands: Commands) {
+    let kinds = [
+        PendulumKind::Default,
+        PendulumKind::Damping,
+        PendulumKind::Friction,
+        PendulumKind::Springs,
+        PendulumKind::Armature,
+        PendulumKind::Kinematic,
+    ];
+
+    /*
+     * Grid layout. A chain is built towards +x and swings down, so each cell must be a full chain
+     * long in both directions to keep neighbors from touching.
+     */
+    let chain_length = 2.0 * SEGMENTS as f32 * HALF_LENGTH;
+    let spacing = chain_length + 4.0 * HALF_LENGTH;
+    let cols = 3;
+    let rows = kinds.len().div_ceil(cols);
+
+    for (i, kind) in kinds.into_iter().enumerate() {
+        let (col, row) = (i % cols, i / cols);
+        let base_pos = Vec2::new(
+            (col as f32 - (cols - 1) as f32 * 0.5) * spacing - chain_length * 0.5,
+            ((rows - 1) as f32 * 0.5 - row as f32) * spacing + chain_length * 0.5,
+        );
+        create_pendulum(&mut commands, base_pos, kind);
+    }
+}
+
+fn create_pendulum(commands: &mut Commands, base_pos: Vec2, kind: PendulumKind) {
+    /*
+     * A fixed base, with a small collider so the debug-renderer shows it.
+     */
+    let mut prev = commands
+        .spawn((
+            Transform::from_translation(base_pos.extend(0.0)),
+            RigidBody::Fixed,
+            Collider::ball(0.2 * HALF_LENGTH),
+            ColliderDebugColor(Hsla::hsl(0.0, 0.0, 0.2)),
+        ))
+        .id();
+
+    for i in 0..SEGMENTS {
+        let center = base_pos + Vec2::X * (2.0 * i as f32 + 1.0) * HALF_LENGTH;
+        let anchor1 = if i == 0 {
+            Vec2::ZERO
+        } else {
+            Vec2::X * HALF_LENGTH
+        };
+        let joint = RevoluteJointBuilder::new()
+            .local_anchor1(anchor1)
+            .local_anchor2(-Vec2::X * HALF_LENGTH)
+            .contacts_enabled(false);
+
+        let mut segment = commands.spawn((
+            Transform::from_translation(center.extend(0.0)),
+            RigidBody::Dynamic,
+            Sleeping::disabled(),
+            Collider::capsule_x(HALF_LENGTH, 0.2 * HALF_LENGTH),
+            MultibodyJoint::new(prev, joint),
+        ));
+
+        // In 2D, the only rotational degree of freedom of a joint is `JointAxis::AngX`.
+        match kind {
+            PendulumKind::Default => {}
+            PendulumKind::Damping => {
+                segment.insert(MultibodyJointDamping::default().with(JointAxis::AngX, 5.0));
+            }
+            PendulumKind::Friction => {
+                // The largest torque the friction can apply to stop each joint.
+                segment.insert(MultibodyJointFriction::default().with(JointAxis::AngX, 20.0));
+            }
+            PendulumKind::Springs => {
+                // Pull each joint back towards its initial (straight) configuration.
+                segment.insert(MultibodyJointSprings::default().with(JointAxis::AngX, 200.0, 0.0));
+            }
+            PendulumKind::Armature => {
+                // Extra rotor inertia makes each joint react more slowly.
+                segment.insert(MultibodyJointArmature::default().with(JointAxis::AngX, 20.0));
+            }
+            PendulumKind::Kinematic => {
+                // Only the first joint is kinematic: it is driven by `drive_kinematic_joints`.
+                if i == 0 {
+                    segment.insert(KinematicMultibodyJoint);
+                }
+            }
+        }
+
+        prev = segment.id();
+    }
+}
+
+/// Sets the velocity of the kinematic joints, which the physics engine never modifies.
+fn drive_kinematic_joints(
+    mut context: WriteRapierContext,
+    joints: Query<Entity, With<KinematicMultibodyJoint>>,
+) -> Result<()> {
+    let mut context = context.single_mut()?;
+
+    for entity in &joints {
+        // This is `None` until the joint is inserted into the physics scene.
+        if let Some(velocity) = context.multibody_joint_velocity_mut(entity) {
+            velocity[0] = KINEMATIC_SPEED;
+        }
+    }
+
+    Ok(())
+}
diff --git a/bindings/bevy_rapier/bevy_rapier2d/examples/multiple_colliders2.rs b/bindings/bevy_rapier/bevy_rapier2d/examples/multiple_colliders2.rs
new file mode 100644
index 000000000..9bae20e10
--- /dev/null
+++ b/bindings/bevy_rapier/bevy_rapier2d/examples/multiple_colliders2.rs
@@ -0,0 +1,70 @@
+use bevy::prelude::*;
+use bevy_rapier2d::prelude::*;
+
+fn main() {
+    App::new()
+        .insert_resource(ClearColor(Color::srgb(
+            0xF9 as f32 / 255.0,
+            0xF9 as f32 / 255.0,
+            0xFF as f32 / 255.0,
+        )))
+        .add_plugins((
+            DefaultPlugins,
+            RapierPhysicsPlugin::<NoUserData>::pixels_per_meter(100.0),
+            RapierDebugRenderPlugin::default(),
+        ))
+        .add_systems(Startup, (setup_graphics, setup_physics))
+        .run();
+}
+
+pub fn setup_graphics(mut commands: Commands) {
+    commands.spawn(Camera2d);
+}
+
+pub fn setup_physics(mut commands: Commands) {
+    /*
+     * Ground
+     */
+    let ground_size = 500.0;
+    let ground_height = 1.0;
+
+    commands.spawn((
+        Transform::from_xyz(0.0, -ground_height, 0.0),
+        Collider::cuboid(ground_size, ground_height),
+    ));
+
+    /*
+     * Create the cubes
+     */
+    let num = 4;
+    let rad = 2.0;
+
+    let shift = rad * 4.0 + rad;
+    let centerx = shift * (num / 2) as f32;
+    let centery = shift / 2.0;
+
+    let mut offset = -(num as f32) * (rad * 2.0 + rad) * 0.5;
+
+    for j in 0usize..20 {
+        for i in 0..num {
+            let x = i as f32 * shift * 5.0 - centerx + offset;
+            let y = j as f32 * (shift * 5.0) + centery + 3.0;
+
+            commands
+                .spawn((Transform::from_xyz(x, y, 0.0), RigidBody::Dynamic))
+                .with_children(|children| {
+                    children.spawn(Collider::cuboid(rad * 10.0, rad));
+                    children.spawn((
+                        Transform::from_xyz(rad * 10.0, rad * 10.0, 0.0),
+                        Collider::cuboid(rad, rad * 10.0),
+                    ));
+                    children.spawn((
+                        Transform::from_xyz(-rad * 10.0, rad * 10.0, 0.0),
+                        Collider::cuboid(rad, rad * 10.0),
+                    ));
+                });
+        }
+
+        offset -= 0.05 * rad * (num as f32 - 1.0);
+    }
+}
diff --git a/bindings/bevy_rapier/bevy_rapier2d/examples/one_way_platforms2.rs b/bindings/bevy_rapier/bevy_rapier2d/examples/one_way_platforms2.rs
new file mode 100644
index 000000000..2cdeb1c68
--- /dev/null
+++ b/bindings/bevy_rapier/bevy_rapier2d/examples/one_way_platforms2.rs
@@ -0,0 +1,121 @@
+//! One-way platforms and conveyor belts implemented with `BevyPhysicsHooks` and
+//! `ContactModificationContextView::update_as_oneway_platform`.
+
+use bevy::{ecs::system::SystemParam, prelude::*};
+use bevy_rapier2d::prelude::*;
+
+const PIXELS_PER_METER: f32 = 10.0;
+const MAX_CUBES: usize = 7;
+
+/// A platform only solid for contacts whose normal (in the platform's local-space) is close to
+/// `allowed_normal`, and moving what lies on it at `surface_speed`.
+#[derive(Component, Copy, Clone)]
+struct OneWayPlatform {
+    allowed_normal: Vec2,
+    surface_speed: f32,
+}
+
+#[derive(Component)]
+struct Cube;
+
+#[derive(SystemParam)]
+struct OneWayPlatformHook<'w, 's> {
+    platforms: Query<'w, 's, &'static OneWayPlatform>,
+}
+
+impl BevyPhysicsHooks for OneWayPlatformHook<'_, '_> {
+    fn modify_solver_contacts(&self, mut context: ContactModificationContextView) {
+        // The manifold normal points outward from the first collider, so the allowed direction
+        // and the surface velocity are flipped if the platform is the second collider.
+        let (platform, sign) = if let Ok(platform) = self.platforms.get(context.collider1()) {
+            (platform, 1.0)
+        } else if let Ok(platform) = self.platforms.get(context.collider2()) {
+            (platform, -1.0)
+        } else {
+            return;
+        };
+
+        context.update_as_oneway_platform(platform.allowed_normal * sign, 0.1);
+
+        if let Some(contacts) = context.solver_contacts_mut() {
+            for contact in contacts.iter_mut() {
+                contact.tangent_velocity.x = platform.surface_speed * sign;
+            }
+        }
+    }
+}
+
+fn main() {
+    App::new()
+        .insert_resource(ClearColor(Color::srgb(
+            0xF9 as f32 / 255.0,
+            0xF9 as f32 / 255.0,
+            0xFF as f32 / 255.0,
+        )))
+        .add_plugins((
+            DefaultPlugins,
+            RapierPhysicsPlugin::<OneWayPlatformHook>::pixels_per_meter(PIXELS_PER_METER),
+            RapierDebugRenderPlugin::default(),
+        ))
+        .add_systems(Startup, (setup_graphics, setup_physics))
+        .add_systems(Update, (spawn_cubes, flip_gravity))
+        .run();
+}
+
+fn setup_graphics(mut commands: Commands) {
+    commands.spawn(Camera2d);
+}
+
+fn setup_physics(mut commands: Commands) {
+    // The top platform can be landed on from above, the bottom one from below.
+    commands.spawn((
+        Transform::from_xyz(300.0, 20.0, 0.0),
+        Collider::cuboid(250.0, 5.0),
+        ActiveHooks::MODIFY_SOLVER_CONTACTS,
+        OneWayPlatform {
+            allowed_normal: Vec2::Y,
+            surface_speed: -12.0 * PIXELS_PER_METER,
+        },
+    ));
+    commands.spawn((
+        Transform::from_xyz(-300.0, -20.0, 0.0),
+        Collider::cuboid(250.0, 5.0),
+        ActiveHooks::MODIFY_SOLVER_CONTACTS,
+        OneWayPlatform {
+            allowed_normal: -Vec2::Y,
+            surface_speed: 12.0 * PIXELS_PER_METER,
+        },
+    ));
+}
+
+fn spawn_cubes(
+    mut commands: Commands,
+    time: Res<Time>,
+    mut timer: Local<Option<Timer>>,
+    cubes: Query<(), With<Cube>>,
+) {
+    let timer = timer.get_or_insert_with(|| Timer::from_seconds(3.0, TimerMode::Repeating));
+    timer.tick(time.delta());
+
+    if timer.just_finished() && cubes.iter().count() < MAX_CUBES {
+        commands.spawn((
+            Transform::from_xyz(200.0, 100.0, 0.0),
+            RigidBody::Dynamic,
+            Collider::cuboid(15.0, 20.0),
+            GravityScale(1.0),
+            Cube,
+        ));
+    }
+}
+
+/// Bodies above the platforms fall down, and bodies below them fall up.
+fn flip_gravity(mut cubes: Query<(&Transform, &mut GravityScale), With<Cube>>) {
+    for (transform, mut gravity_scale) in &mut cubes {
+        let y = transform.translation.y;
+        if y > 10.0 && gravity_scale.0 != 1.0 {
+            gravity_scale.0 = 1.0;
+        } else if y < -10.0 && gravity_scale.0 != -1.0 {
+            gravity_scale.0 = -1.0;
+        }
+    }
+}
diff --git a/bindings/bevy_rapier/bevy_rapier2d/examples/pin_slot_joint2.rs b/bindings/bevy_rapier/bevy_rapier2d/examples/pin_slot_joint2.rs
new file mode 100644
index 000000000..ef99bb9b2
--- /dev/null
+++ b/bindings/bevy_rapier/bevy_rapier2d/examples/pin_slot_joint2.rs
@@ -0,0 +1,150 @@
+//! A pin-slot (groove) joint: a cube tethered to a character slides along a slanted slot attached
+//! to that character, while staying free to rotate around its pin.
+//!
+//! Move the character with the arrow keys (or A/D) and jump with Space.
+
+use bevy::prelude::*;
+use bevy_rapier2d::prelude::*;
+
+const CHARACTER_SPEED: f32 = 2.0;
+const JUMP_SPEED: f32 = 4.0;
+const GRAVITY: f32 = 9.81;
+
+fn main() {
+    App::new()
+        .insert_resource(ClearColor(Color::srgb(
+            0xF9 as f32 / 255.0,
+            0xF9 as f32 / 255.0,
+            0xFF as f32 / 255.0,
+        )))
+        .add_plugins((
+            DefaultPlugins,
+            RapierPhysicsPlugin::<NoUserData>::default(),
+            RapierDebugRenderPlugin::default(),
+        ))
+        .add_systems(Startup, (setup_graphics, setup_physics))
+        .add_systems(Update, move_character)
+        .run();
+}
+
+/// The vertical velocity of the manually-controlled character.
+#[derive(Component, Default)]
+struct Character {
+    vertical_velocity: f32,
+}
+
+pub fn setup_graphics(mut commands: Commands) {
+    // The scene is expressed in meters: zoom in so that one meter spans 100 pixels.
+    commands.spawn((
+        Camera2d,
+        Projection::from(OrthographicProjection {
+            scale: 0.01,
+            ..OrthographicProjection::default_2d()
+        }),
+        Transform::from_xyz(0.0, 1.0, 0.0),
+    ));
+    commands.spawn((
+        Text::new("Arrows/A/D: move the character\nSpace: jump"),
+        Node {
+            position_type: PositionType::Absolute,
+            top: Val::Px(12.0),
+            left: Val::Px(12.0),
+            ..default()
+        },
+        TextColor(Color::BLACK),
+    ));
+}
+
+pub fn setup_physics(mut commands: Commands) {
+    /*
+     * Ground.
+     */
+    let ground_size = 3.0;
+    let ground_height = 0.1;
+    commands.spawn((
+        Transform::from_xyz(0.0, -ground_height, 0.0),
+        Collider::cuboid(ground_size, ground_height),
+    ));
+
+    /*
+     * Character we will control manually.
+     */
+    let character_pos = Vec2::new(0.0, 0.3);
+    let character = commands
+        .spawn((
+            Transform::from_translation(character_pos.extend(0.0)),
+            RigidBody::KinematicPositionBased,
+            Collider::cuboid(0.15, 0.3),
+            KinematicCharacterController::default(),
+            Character::default(),
+        ))
+        .id();
+
+    /*
+     * Tethered cube, attached to the character with a pin-slot joint. The slot follows the
+     * diagonal axis attached to the character, and the cube can't go below one meter along it.
+     */
+    let rad = 0.4;
+    let axis = Vec2::new(1.0, 1.0).normalize();
+    let slot_anchor = Vec2::new(2.0, 2.0);
+    let pin_slot = PinSlotJointBuilder::new(axis)
+        .local_anchor1(slot_anchor)
+        .local_anchor2(Vec2::new(0.0, rad))
+        .limits([-1.0, f32::INFINITY]);
+    // Start with the pin resting on the lower limit of the slot: a joint starting outside of its
+    // limits is corrected almost instantly, which would launch the cube along the slot.
+    let pin = character_pos + slot_anchor - axis;
+    let cube = commands
+        .spawn((
+            Transform::from_xyz(pin.x, pin.y - rad, 0.0),
+            RigidBody::Dynamic,
+            Collider::cuboid(rad, rad),
+            ImpulseJoint::new(character, pin_slot),
+        ))
+        .id();
+
+    /*
+     * Small ball welded on top of the cube, to visualize its rotation.
+     */
+    let fixed = FixedJointBuilder::new().local_anchor2(Vec2::new(0.0, -rad));
+    commands.spawn((
+        Transform::from_xyz(pin.x, pin.y, 0.0),
+        RigidBody::Dynamic,
+        Collider::ball(0.1),
+        ImpulseJoint::new(cube, fixed),
+    ));
+}
+
+fn move_character(
+    keys: Res<ButtonInput<KeyCode>>,
+    time: Res<Time>,
+    mut characters: Query<(
+        &mut KinematicCharacterController,
+        Option<&KinematicCharacterControllerOutput>,
+        &mut Character,
+    )>,
+) {
+    let dt = time.delta_secs();
+
+    for (mut controller, output, mut character) in &mut characters {
+        let mut horizontal = 0.0;
+        if keys.any_pressed([KeyCode::ArrowLeft, KeyCode::KeyA]) {
+            horizontal -= 1.0;
+        }
+        if keys.any_pressed([KeyCode::ArrowRight, KeyCode::KeyD]) {
+            horizontal += 1.0;
+        }
+
+        // Keep a small downward motion while grounded so the controller keeps detecting the ground.
+        if output.is_some_and(|output| output.grounded) {
+            character.vertical_velocity = 0.0;
+            if keys.just_pressed(KeyCode::Space) {
+                character.vertical_velocity = JUMP_SPEED;
+            }
+        }
+        character.vertical_velocity -= GRAVITY * dt;
+
+        controller.translation =
+            Some(Vec2::new(horizontal * CHARACTER_SPEED, character.vertical_velocity) * dt);
+    }
+}
diff --git a/bindings/bevy_rapier/bevy_rapier2d/examples/player_movement2.rs b/bindings/bevy_rapier/bevy_rapier2d/examples/player_movement2.rs
new file mode 100644
index 000000000..a46ba38ea
--- /dev/null
+++ b/bindings/bevy_rapier/bevy_rapier2d/examples/player_movement2.rs
@@ -0,0 +1,76 @@
+use bevy::{prelude::*, window::WindowResolution};
+use bevy_rapier2d::prelude::*;
+
+fn main() {
+    App::new()
+        .add_plugins((
+            DefaultPlugins.set(WindowPlugin {
+                primary_window: Some(Window {
+                    resolution: WindowResolution::new(1000, 1000),
+                    title: "Player Movement Example".to_string(),
+                    ..default()
+                }),
+                ..default()
+            }),
+            RapierPhysicsPlugin::<NoUserData>::pixels_per_meter(100.0),
+            RapierDebugRenderPlugin::default(),
+        ))
+        .add_systems(Startup, spawn_player)
+        .add_systems(Update, player_movement)
+        .run();
+}
+
+// The float value is the player movement speed in 'pixels/second'.
+#[derive(Component)]
+pub struct Player(f32);
+
+pub fn spawn_player(
+    mut commands: Commands,
+    mut rapier_config: Query<&mut RapierConfiguration>,
+) -> Result<()> {
+    let mut rapier_config = rapier_config.single_mut()?;
+    // Set gravity to 0.0 and spawn camera.
+    rapier_config.gravity = Vec2::ZERO;
+    commands.spawn(Camera2d);
+
+    let sprite_size = 100.0;
+
+    // Spawn entity with `Player` struct as a component for access in movement query.
+    commands.spawn((
+        Sprite {
+            color: Color::srgb(0.0, 0.0, 0.0),
+            custom_size: Some(Vec2::new(sprite_size, sprite_size)),
+            ..Default::default()
+        },
+        RigidBody::Dynamic,
+        Velocity::zero(),
+        Collider::ball(sprite_size / 2.0),
+        Player(100.0),
+    ));
+
+    Ok(())
+}
+
+pub fn player_movement(
+    keyboard_input: Res<ButtonInput<KeyCode>>,
+    mut player_info: Query<(&Player, &mut Velocity)>,
+) {
+    for (player, mut rb_vels) in &mut player_info {
+        let up = keyboard_input.any_pressed([KeyCode::KeyW, KeyCode::ArrowUp]);
+        let down = keyboard_input.any_pressed([KeyCode::KeyS, KeyCode::ArrowDown]);
+        let left = keyboard_input.any_pressed([KeyCode::KeyA, KeyCode::ArrowLeft]);
+        let right = keyboard_input.any_pressed([KeyCode::KeyD, KeyCode::ArrowRight]);
+
+        let x_axis = -(left as i8) + right as i8;
+        let y_axis = -(down as i8) + up as i8;
+
+        let mut move_delta = Vec2::new(x_axis as f32, y_axis as f32);
+        if move_delta != Vec2::ZERO {
+            move_delta /= move_delta.length();
+        }
+
+        // Update the velocity on the rigid_body_component,
+        // the bevy_rapier plugin will update the Sprite transform.
+        rb_vels.linear = move_delta * player.0;
+    }
+}
diff --git a/bindings/bevy_rapier/bevy_rapier2d/examples/rope_joint2.rs b/bindings/bevy_rapier/bevy_rapier2d/examples/rope_joint2.rs
new file mode 100644
index 000000000..d276b98d0
--- /dev/null
+++ b/bindings/bevy_rapier/bevy_rapier2d/examples/rope_joint2.rs
@@ -0,0 +1,45 @@
+use bevy::prelude::*;
+use bevy_rapier2d::prelude::*;
+
+fn main() {
+    App::new()
+        .insert_resource(ClearColor(Color::srgb(
+            0xF9 as f32 / 255.0,
+            0xF9 as f32 / 255.0,
+            0xFF as f32 / 255.0,
+        )))
+        .add_plugins((
+            DefaultPlugins,
+            RapierPhysicsPlugin::<NoUserData>::pixels_per_meter(100.0),
+            RapierDebugRenderPlugin::default(),
+        ))
+        .add_systems(Startup, (setup_graphics, setup_physics))
+        .run();
+}
+
+pub fn setup_graphics(mut commands: Commands) {
+    commands.spawn((Camera2d, Transform::from_xyz(0.0, -200.0, 0.0)));
+}
+
+pub fn setup_physics(mut commands: Commands) {
+    let rad = 10.0;
+    let rope_length = rad * 10.0;
+
+    let parent = commands
+        .spawn((
+            Transform::from_xyz(0.0, 0.0, 0.0),
+            RigidBody::Fixed,
+            Collider::cuboid(rad, rad),
+        ))
+        .id();
+
+    let joint = RopeJointBuilder::new(rope_length).local_anchor2(Vec2::new(rope_length, 0.0));
+
+    commands
+        .spawn((
+            Transform::from_xyz(-rad * 2.0, 0.0, 0.0),
+            RigidBody::Dynamic,
+            Collider::cuboid(rad, rad),
+        ))
+        .insert(ImpulseJoint::new(parent, joint));
+}
diff --git a/bindings/bevy_rapier/bevy_rapier2d/examples/serialization2.rs b/bindings/bevy_rapier/bevy_rapier2d/examples/serialization2.rs
new file mode 100644
index 000000000..8e10652af
--- /dev/null
+++ b/bindings/bevy_rapier/bevy_rapier2d/examples/serialization2.rs
@@ -0,0 +1,40 @@
+//! Example for RapierContext serialization, run with `--features serde-serialize`.
+
+use bevy::prelude::*;
+use bevy::MinimalPlugins;
+use bevy_rapier2d::prelude::*;
+
+/// Note: This will end up in duplication for testbed, but that's more simple.
+mod joints2;
+
+fn main() {
+    App::new()
+        .insert_resource(ClearColor(Color::srgb(
+            0xF9 as f32 / 255.0,
+            0xF9 as f32 / 255.0,
+            0xFF as f32 / 255.0,
+        )))
+        .add_plugins((
+            MinimalPlugins,
+            RapierPhysicsPlugin::<NoUserData>::pixels_per_meter(100.0),
+        ))
+        .add_systems(Startup, joints2::setup_physics)
+        .add_systems(PostUpdate, print_physics)
+        .add_systems(Last, quit)
+        .run();
+}
+
+pub fn print_physics(_context: ReadRapierContext) {
+    #[cfg(feature = "serde-serialize")]
+    println!(
+        "{}",
+        serde_json::to_string_pretty(&_context.single().expect("No rapier context"))
+            .expect("Unable to serialize `RapierContext`")
+    );
+    #[cfg(not(feature = "serde-serialize"))]
+    panic!("Example 'serialization' should be run with '--features serde-serialize'.");
+}
+
+fn quit(mut exit_event: MessageWriter<AppExit>) {
+    exit_event.write(AppExit::Success);
+}
diff --git a/bindings/bevy_rapier/bevy_rapier2d/examples/soft_bodies2.rs b/bindings/bevy_rapier/bevy_rapier2d/examples/soft_bodies2.rs
new file mode 100644
index 000000000..2717e02e8
--- /dev/null
+++ b/bindings/bevy_rapier/bevy_rapier2d/examples/soft_bodies2.rs
@@ -0,0 +1,99 @@
+//! Soft bodies: soft disks and a soft square falling on the ground, and a rope hanging from a
+//! fixed point and holding a rigid ball.
+//!
+//! The square is rendered with a mesh kept in sync with its particles; the other soft bodies
+//! are shown by the debug-renderer.
+
+use bevy::prelude::*;
+use bevy_rapier2d::prelude::*;
+
+fn main() {
+    App::new()
+        .insert_resource(ClearColor(Color::srgb(
+            0xF9 as f32 / 255.0,
+            0xF9 as f32 / 255.0,
+            0xFF as f32 / 255.0,
+        )))
+        .add_plugins((
+            DefaultPlugins,
+            RapierPhysicsPlugin::<NoUserData>::pixels_per_meter(100.0),
+            RapierDebugRenderPlugin::default(),
+        ))
+        .add_systems(Startup, (setup_graphics, setup_physics))
+        .run();
+}
+
+pub fn setup_graphics(mut commands: Commands, mut debug_render: ResMut<DebugRenderContext>) {
+    commands.spawn((Camera2d, Transform::from_xyz(0.0, 150.0, 0.0)));
+    // Draw the elements of the soft bodies.
+    debug_render.mode.soft_bodies = true;
+}
+
+pub fn setup_physics(
+    mut commands: Commands,
+    mut meshes: ResMut<Assets<Mesh>>,
+    mut materials: ResMut<Assets<ColorMaterial>>,
+) {
+    /*
+     * Ground.
+     */
+    commands.spawn((
+        Transform::from_xyz(0.0, -20.0, 0.0),
+        Collider::cuboid(500.0, 20.0),
+    ));
+
+    /*
+     * Soft disks with an inflated area, colliding with their own boundary.
+     */
+    for i in 0..3 {
+        let radius = 30.0 + 10.0 * i as f32;
+        commands.spawn((
+            Transform::from_xyz(-250.0 + 90.0 * i as f32, 150.0 + 80.0 * i as f32, 0.0),
+            SoftBody::disk(radius, 24).map(|b| b.particle_mass(0.05).self_contacts(true)),
+            SoftBodyMaterial::uniform(20.0, 1.0),
+            SoftBodyVolumeFactor(1.1),
+        ));
+    }
+
+    /*
+     * A jelly square, rendered with a synchronized mesh.
+     */
+    commands.spawn((
+        Transform::from_xyz(50.0, 200.0, 0.0).with_rotation(Quat::from_rotation_z(0.3)),
+        SoftBody::grid(Vec2::splat(50.0), 6, 6).map(|b| {
+            b.cell_model(SoftBodyCellModel::Corotational)
+                .particle_mass(0.2)
+        }),
+        SoftBodyMaterial(RapierSoftBodyMaterial {
+            young_modulus: 3.0e3,
+            poisson_ratio: 0.35,
+            elastic_damping_ratio: 0.5,
+            ..Default::default()
+        }),
+        SoftBodyMeshSync::default(),
+        MeshMaterial2d(materials.add(Color::srgb(0.2, 0.6, 0.3))),
+    ));
+
+    /*
+     * A rope pinned at its first particle, its last particle attached to a rigid ball.
+     */
+    let ball = commands
+        .spawn((
+            Transform::from_xyz(400.0, 300.0, 0.0),
+            RigidBody::Dynamic,
+            Collider::ball(20.0),
+            ColliderMassProperties::Density(0.002),
+            Mesh2d(meshes.add(Circle::new(20.0))),
+            MeshMaterial2d(materials.add(Color::srgb(0.2, 0.4, 0.8))),
+        ))
+        .id();
+    commands.spawn((
+        Transform::from_xyz(200.0, 300.0, 0.0),
+        SoftBody::rope(Vec2::ZERO, Vec2::new(180.0, 0.0), 20)
+            .map(|b| b.pinned_particles([0]).particle_mass(0.05)),
+        SoftBodyAttachments(vec![SoftBodyAttachment {
+            particle: 19,
+            body: ball,
+        }]),
+    ));
+}
diff --git a/bindings/bevy_rapier/bevy_rapier2d/examples/soft_cutting2.rs b/bindings/bevy_rapier/bevy_rapier2d/examples/soft_cutting2.rs
new file mode 100644
index 000000000..083dfb012
--- /dev/null
+++ b/bindings/bevy_rapier/bevy_rapier2d/examples/soft_cutting2.rs
@@ -0,0 +1,207 @@
+//! Cutting soft bodies with `RapierContextMut::cut_soft_body`: drag the mouse with its left
+//! button (or hold `C` while moving it) to cut every soft body along the line from the press to
+//! the release; a saw blade also rises through the suspended slab. Cuts remove no material and
+//! the separated pieces become soft body entities of their own.
+
+use bevy::prelude::*;
+use bevy_rapier2d::prelude::*;
+
+/// The start of the cut being drawn, if any.
+#[derive(Resource, Default)]
+struct BladeStart(Option<Vec2>);
+
+/// Marks the saw blade.
+#[derive(Component)]
+struct Saw;
+
+/// The position of the saw before it starts rising.
+const SAW_START: Vec2 = Vec2::new(10.0, 1.5);
+
+fn main() {
+    App::new()
+        .insert_resource(ClearColor(Color::srgb(
+            0xF9 as f32 / 255.0,
+            0xF9 as f32 / 255.0,
+            0xFF as f32 / 255.0,
+        )))
+        .init_resource::<BladeStart>()
+        .add_plugins((
+            DefaultPlugins,
+            RapierPhysicsPlugin::<NoUserData>::default(),
+            RapierDebugRenderPlugin::default(),
+        ))
+        .add_systems(Startup, (setup_graphics, setup_physics))
+        .add_systems(Update, (cut_with_mouse, move_saw))
+        .run();
+}
+
+fn setup_graphics(mut commands: Commands, mut debug_render: ResMut<DebugRenderContext>) {
+    commands.spawn((
+        Camera2d,
+        Projection::from(OrthographicProjection {
+            scale: 1.0 / 40.0,
+            ..OrthographicProjection::default_2d()
+        }),
+        Transform::from_xyz(1.0, 3.5, 0.0),
+    ));
+    // Draw the elements of the soft bodies.
+    debug_render.mode.soft_bodies = true;
+}
+
+/// A jelly material of the given Young modulus.
+fn jelly(young_modulus: f32) -> SoftBodyMaterial {
+    SoftBodyMaterial(RapierSoftBodyMaterial {
+        young_modulus,
+        poisson_ratio: 0.35,
+        elastic_damping_ratio: 1.0,
+        ..default()
+    })
+}
+
+fn setup_physics(
+    mut commands: Commands,
+    mut meshes: ResMut<Assets<Mesh>>,
+    mut materials: ResMut<Assets<ColorMaterial>>,
+) {
+    let jelly_color = materials.add(Color::srgb(0.95, 0.65, 0.3));
+
+    /*
+     * Ground.
+     */
+    commands.spawn((
+        Transform::from_xyz(0.0, -0.5, 0.0),
+        Collider::cuboid(30.0, 0.5),
+    ));
+
+    /*
+     * A jelly block to slice by hand.
+     */
+    commands.spawn((
+        Transform::from_xyz(-8.0, 2.0, 0.0),
+        SoftBody::grid(Vec2::splat(2.0), 13, 13).map(|b| {
+            b.cell_model(SoftBodyCellModel::Corotational)
+                .particle_mass(0.05)
+                .particle_radius(0.15)
+        }),
+        jelly(2.0e4),
+        Friction::coefficient(0.8),
+        SoftBodyMeshSync::default(),
+        MeshMaterial2d(jelly_color.clone()),
+    ));
+
+    /*
+     * A blob: a ring of particles holding its area. Cut open, it falls limp.
+     */
+    commands.spawn((
+        Transform::from_xyz(-2.0, 2.0, 0.0),
+        SoftBody::disk(1.6, 40).map(|b| {
+            b.softness(SpringCoefficients::new(30.0, 1.0))
+                .particle_mass(0.05)
+        }),
+        Friction::coefficient(0.8),
+    ));
+
+    /*
+     * A curtain pinned along its top edge. Particle `(i, j)` of a grid has the index
+     * `i * ny + j`.
+     */
+    let (nx, ny) = (9, 31);
+    let idx = move |i: usize, j: usize| (i * ny + j) as u32;
+    commands.spawn((
+        Transform::from_xyz(3.0, 4.5, 0.0),
+        SoftBody::grid(Vec2::new(0.6, 3.0), nx, ny).map(|b| {
+            b.cell_model(SoftBodyCellModel::Corotational)
+                .pinned_particles((0..nx).map(|i| idx(i, ny - 1)))
+                .particle_mass(0.05)
+                .particle_radius(0.1)
+        }),
+        jelly(3.0e4),
+        Friction::coefficient(0.8),
+        SoftBodyMeshSync::default(),
+        MeshMaterial2d(jelly_color.clone()),
+    ));
+
+    /*
+     * A slab suspended between two posts, with a saw rising through it.
+     */
+    let (nx, ny) = (25, 5);
+    let idx = move |i: usize, j: usize| (i * ny + j) as u32;
+    commands.spawn((
+        Transform::from_xyz(10.0, 4.0, 0.0),
+        SoftBody::grid(Vec2::new(3.0, 0.5), nx, ny).map(|b| {
+            b.cell_model(SoftBodyCellModel::Corotational)
+                .pinned_particles((0..ny).flat_map(|j| [idx(0, j), idx(nx - 1, j)]))
+                .particle_mass(0.05)
+                .particle_radius(0.1)
+        }),
+        jelly(5.0e4),
+        Friction::coefficient(0.8),
+        SoftBodyMeshSync::default(),
+        MeshMaterial2d(jelly_color),
+    ));
+    // The saw: a kinematic sensor, so it pushes nothing (the cut does the work).
+    commands.spawn((
+        Saw,
+        Transform::from_translation(SAW_START.extend(1.0)),
+        RigidBody::KinematicPositionBased,
+        Collider::cuboid(0.05, 1.0),
+        Sensor,
+        Mesh2d(meshes.add(Rectangle::new(0.1, 2.0))),
+        MeshMaterial2d(materials.add(Color::srgb(0.3, 0.3, 0.35))),
+    ));
+}
+
+/// Cuts every soft body along the line drawn with the mouse.
+fn cut_with_mouse(
+    (buttons, keys): (Res<ButtonInput<MouseButton>>, Res<ButtonInput<KeyCode>>),
+    window: Single<&Window>,
+    camera: Single<(&Camera, &GlobalTransform)>,
+    mut blade_start: ResMut<BladeStart>,
+    (mut context, mut commands): (WriteRapierContext, Commands),
+    soft_bodies: Query<Entity, With<SoftBody>>,
+    mut gizmos: Gizmos,
+) {
+    let (camera, camera_transform) = *camera;
+    let cursor = window
+        .cursor_position()
+        .and_then(|cursor| camera.viewport_to_world_2d(camera_transform, cursor).ok());
+
+    if buttons.pressed(MouseButton::Left) || keys.pressed(KeyCode::KeyC) {
+        if blade_start.0.is_none() {
+            blade_start.0 = cursor;
+        }
+        if let (Some(a), Some(b)) = (blade_start.0, cursor) {
+            gizmos.line_2d(a, b, Color::srgb(1.0, 0.35, 0.25));
+        }
+    } else if let (Some(a), Some(b)) = (blade_start.0.take(), cursor) {
+        let Ok(mut context) = context.single_mut() else {
+            return;
+        };
+        for soft_body in &soft_bodies {
+            context.cut_soft_body(&mut commands, soft_body, &[a, b]);
+        }
+    }
+}
+
+/// Raises the saw, cutting every soft body along its blade.
+fn move_saw(
+    time: Res<Time>,
+    mut context: WriteRapierContext,
+    mut commands: Commands,
+    mut saws: Query<&mut Transform, With<Saw>>,
+    soft_bodies: Query<Entity, With<SoftBody>>,
+) {
+    let Ok(mut context) = context.single_mut() else {
+        return;
+    };
+    // The saw rises at a fifth of a meter per second, from a second in.
+    let rise = ((time.elapsed_secs() - 1.0).max(0.0) * 0.2).min(4.5);
+    let position = SAW_START + Vec2::new(0.0, rise);
+    for mut transform in &mut saws {
+        transform.translation = position.extend(transform.translation.z);
+    }
+    let blade = [position - Vec2::Y, position + Vec2::Y];
+    for soft_body in &soft_bodies {
+        context.cut_soft_body(&mut commands, soft_body, &blade);
+    }
+}
diff --git a/bindings/bevy_rapier/bevy_rapier2d/examples/soft_fem2.rs b/bindings/bevy_rapier/bevy_rapier2d/examples/soft_fem2.rs
new file mode 100644
index 000000000..f4c8ac1d9
--- /dev/null
+++ b/bindings/bevy_rapier/bevy_rapier2d/examples/soft_fem2.rs
@@ -0,0 +1,141 @@
+//! The FEM soft-body solver next to the constraint solver: the same bodies twice, simulated by
+//! `SoftBodySolver::Fem` on the lower row (blue) and by the constraint solver on the upper one
+//! (orange). The FEM cantilever and plank hold their static deflection; the others sag.
+//!
+//! Run with `--features fem`.
+
+use bevy::prelude::*;
+use bevy_rapier2d::prelude::*;
+
+/// Vertical distance between the FEM row and the constraint-solver row.
+const ROW: f32 = 6.0;
+
+fn main() {
+    App::new()
+        .insert_resource(ClearColor(Color::srgb(
+            0xF9 as f32 / 255.0,
+            0xF9 as f32 / 255.0,
+            0xFF as f32 / 255.0,
+        )))
+        .add_plugins((
+            DefaultPlugins,
+            RapierPhysicsPlugin::<NoUserData>::default(),
+            RapierDebugRenderPlugin::default(),
+        ))
+        .add_systems(Startup, (setup_graphics, setup_physics))
+        .run();
+}
+
+fn setup_graphics(mut commands: Commands) {
+    commands.spawn((
+        Camera2d,
+        Projection::from(OrthographicProjection {
+            scale: 1.0 / 45.0,
+            ..OrthographicProjection::default_2d()
+        }),
+        Transform::from_xyz(1.0, 5.0, 0.0),
+    ));
+    commands.spawn((
+        Text::new("Lower row: FEM solver. Upper row: constraint solver."),
+        TextColor(Color::BLACK),
+        Node {
+            position_type: PositionType::Absolute,
+            top: Val::Px(10.0),
+            left: Val::Px(10.0),
+            ..default()
+        },
+    ));
+}
+
+/// A stiff, damped, corotational material.
+fn stiff(young_modulus: f32) -> SoftBodyMaterial {
+    SoftBodyMaterial(RapierSoftBodyMaterial {
+        young_modulus,
+        poisson_ratio: 0.3,
+        elastic_damping_ratio: 1.0,
+        ..default()
+    })
+}
+
+/// The indices of the particles of `body` whose local position satisfies `pinned`.
+fn pinned_particles(body: &SoftBody, pinned: impl Fn(Vec2) -> bool) -> Vec<u32> {
+    (0..)
+        .zip(body.builder.particle_positions())
+        .filter(|(_, p)| pinned(**p))
+        .map(|(i, _)| i)
+        .collect()
+}
+
+fn setup_physics(mut commands: Commands, mut materials: ResMut<Assets<ColorMaterial>>) {
+    commands.spawn((
+        Transform::from_xyz(0.0, -0.5, 0.0),
+        Collider::cuboid(30.0, 0.5),
+    ));
+
+    let solvers = [
+        (SoftBodySolver::Fem, Color::srgb(0.3, 0.55, 0.9)),
+        (SoftBodySolver::Constraints, Color::srgb(0.95, 0.6, 0.3)),
+    ];
+
+    for (row, (solver, color)) in solvers.into_iter().enumerate() {
+        let y = 2.0 + row as f32 * ROW;
+        let color = materials.add(color);
+
+        /*
+         * A stiff cantilever bolted to a wall.
+         */
+        let (length, thickness) = (4.0, 0.4);
+        let beam = SoftBody::grid(Vec2::new(length * 0.5, thickness * 0.5), 17, 3)
+            .map(|b| b.cell_model(SoftBodyCellModel::Corotational).mass(8.0));
+        let pinned = pinned_particles(&beam, |p| p.x < -length * 0.5 + 1.0e-4);
+        commands.spawn((
+            Transform::from_xyz(length * 0.5 - 8.0, y, 0.0),
+            beam.map(|b| b.pinned_particles(pinned)),
+            stiff(2.0e6),
+            SoftBodyElasticitySolver(solver),
+            SoftBodyMeshSync::default(),
+            MeshMaterial2d(color.clone()),
+        ));
+
+        /*
+         * A plank pinned at both ends, loaded by a heavy box dropped in its middle.
+         */
+        let plank = SoftBody::grid(Vec2::new(3.0, 0.25), 21, 3)
+            .map(|b| b.cell_model(SoftBodyCellModel::Corotational).mass(20.0));
+        let pinned = pinned_particles(&plank, |p| p.x.abs() > 2.9);
+        commands.spawn((
+            Transform::from_xyz(2.0, y, 0.0),
+            plank.map(|b| b.pinned_particles(pinned)),
+            stiff(4.0e6),
+            SoftBodyElasticitySolver(solver),
+            SoftBodyMeshSync::default(),
+            MeshMaterial2d(color.clone()),
+        ));
+        commands.spawn((
+            Transform::from_xyz(2.0, y + 2.5, 0.0),
+            RigidBody::Dynamic,
+            Collider::cuboid(0.5, 0.5),
+            ColliderMassProperties::Density(20.0),
+        ));
+
+        /*
+         * A Neo-Hookean jelly square dropped next to the plank.
+         */
+        commands.spawn((
+            Transform::from_xyz(9.0, y + 1.0, 0.0),
+            SoftBody::grid(Vec2::splat(0.8), 5, 5).map(|b| {
+                b.cell_model(SoftBodyCellModel::NeoHookean)
+                    .particle_mass(0.1)
+            }),
+            SoftBodyMaterial(RapierSoftBodyMaterial {
+                young_modulus: 2.0e4,
+                poisson_ratio: 0.4,
+                elastic_damping_ratio: 0.5,
+                ..default()
+            }),
+            SoftBodyElasticitySolver(solver),
+            SoftBodyMeshSync::default(),
+            MeshMaterial2d(color),
+        ));
+    }
+}
diff --git a/bindings/bevy_rapier/bevy_rapier2d/examples/soft_joints2.rs b/bindings/bevy_rapier/bevy_rapier2d/examples/soft_joints2.rs
new file mode 100644
index 000000000..3c9a85ca9
--- /dev/null
+++ b/bindings/bevy_rapier/bevy_rapier2d/examples/soft_joints2.rs
@@ -0,0 +1,387 @@
+//! Impulse joints attached to soft bodies, through the soft body entities (for the whole body) or
+//! `SoftBodyCluster` entities: every 2D joint type on jellies, a motorized hinge between two
+//! clusters of one soft bar, a jelly hanging from a two-link arm and tied to a crate, and a
+//! kinematic cluster waving a rope.
+
+use bevy::prelude::*;
+use bevy_rapier2d::prelude::*;
+
+/// Marks the joint of the jelly shuttled along its rail.
+#[derive(Component)]
+struct RailJoint;
+
+/// Marks the hinge between the two halves of the soft bar.
+#[derive(Component)]
+struct FlapJoint;
+
+/// The cluster of the rope's top particles, waved kinematically from its initial position.
+#[derive(Component)]
+struct Grip {
+    /// The initial position of the cluster's center.
+    home: Vec2,
+}
+
+fn main() {
+    App::new()
+        .insert_resource(ClearColor(Color::srgb(
+            0xF9 as f32 / 255.0,
+            0xF9 as f32 / 255.0,
+            0xFF as f32 / 255.0,
+        )))
+        .add_plugins((
+            DefaultPlugins,
+            RapierPhysicsPlugin::<NoUserData>::default(),
+            RapierDebugRenderPlugin::default(),
+        ))
+        .add_systems(Startup, (setup_graphics, setup_physics))
+        .add_systems(Update, (animate_motors, wave_grip))
+        .run();
+}
+
+fn setup_graphics(mut commands: Commands, mut debug_render: ResMut<DebugRenderContext>) {
+    commands.spawn((
+        Camera2d,
+        Projection::from(OrthographicProjection {
+            scale: 1.0 / 32.0,
+            ..OrthographicProjection::default_2d()
+        }),
+        Transform::from_xyz(2.0, 3.0, 0.0),
+    ));
+    // Draw the elements of the soft bodies (e.g. the rope).
+    debug_render.mode.soft_bodies = true;
+}
+
+/// The components of a jelly square of 5x5 particles centered at `center`.
+fn jelly(
+    center: Vec2,
+    half_extents: Vec2,
+    young_modulus: f32,
+    color: &Handle<ColorMaterial>,
+) -> impl Bundle {
+    (
+        Transform::from_translation(center.extend(0.0)),
+        SoftBody::grid(half_extents, 5, 5).map(|b| {
+            b.cell_model(SoftBodyCellModel::Corotational)
+                .particle_mass(0.08)
+                .particle_radius(0.06)
+        }),
+        SoftBodyMaterial(RapierSoftBodyMaterial {
+            young_modulus,
+            poisson_ratio: 0.35,
+            elastic_damping_ratio: 0.8,
+            ..default()
+        }),
+        Friction::coefficient(0.6),
+        SoftBodyMeshSync::default(),
+        MeshMaterial2d(color.clone()),
+    )
+}
+
+fn setup_physics(mut commands: Commands, mut materials: ResMut<Assets<ColorMaterial>>) {
+    let color = materials.add(Color::srgb(0.55, 0.75, 0.95));
+
+    /*
+     * Ground.
+     */
+    commands.spawn((
+        Transform::from_xyz(0.0, -0.5, 0.0),
+        Collider::cuboid(30.0, 0.5),
+    ));
+
+    /*
+     * Revolute + velocity motor: a jelly spun about its center.
+     */
+    let center = Vec2::new(-12.0, 2.0);
+    let pivot = commands
+        .spawn((
+            Transform::from_translation(center.extend(0.0)),
+            RigidBody::Fixed,
+        ))
+        .id();
+    // A joint on a soft body entity attaches the whole soft body.
+    commands.spawn((
+        jelly(center, Vec2::splat(0.6), 8.0e3, &color),
+        ImpulseJoint::new(pivot, RevoluteJointBuilder::new().motor_velocity(1.5, 60.0)),
+    ));
+
+    /*
+     * Fixed: a rigid plate welded onto a jelly's top-edge cluster; the full-rank edge cluster
+     * holds the plate's orientation as the jelly wobbles.
+     */
+    let center = Vec2::new(-8.0, 0.61);
+    let wobbler = jelly(center, Vec2::splat(0.6), 2.5e3, &color);
+    let top_edge: Vec<u32> = (0..5).map(|i| i * 5 + 4).collect();
+    let wobbler = commands.spawn(wobbler).id();
+    let top_pos = center + Vec2::new(0.0, 0.6);
+    let plate = commands
+        .spawn((
+            Transform::from_translation((top_pos + Vec2::new(0.0, 0.12)).extend(0.0)),
+            RigidBody::Dynamic,
+            Collider::cuboid(0.7, 0.06),
+            ColliderMassProperties::Density(0.4),
+        ))
+        .id();
+    commands.spawn((
+        SoftBodyCluster::new(wobbler, top_edge),
+        ImpulseJoint::new(
+            plate,
+            FixedJointBuilder::new().local_anchor1(Vec2::new(0.0, -0.12)),
+        ),
+    ));
+    // A small crate dropped on the plate to make it wobble.
+    commands.spawn((
+        Transform::from_translation((top_pos + Vec2::new(0.3, 1.4)).extend(0.0)),
+        RigidBody::Dynamic,
+        Collider::cuboid(0.15, 0.15),
+        ColliderMassProperties::Density(1.5),
+    ));
+
+    /*
+     * Prismatic + limits + position motor: a jelly shuttled along a rail between two stops.
+     */
+    let center = Vec2::new(-3.0, 0.85);
+    let rail = commands
+        .spawn((
+            Transform::from_translation(center.extend(0.0)),
+            RigidBody::Fixed,
+        ))
+        .id();
+    commands.spawn((
+        RailJoint,
+        jelly(center, Vec2::splat(0.4), 6.0e3, &color),
+        ImpulseJoint::new(
+            rail,
+            PrismaticJointBuilder::new(Vec2::X)
+                .limits([-1.8, 1.8])
+                .motor_position(0.0, 40.0, 8.0),
+        ),
+    ));
+
+    /*
+     * Rope: two jellies chained over a ledge, one dragging the other.
+     */
+    commands.spawn((
+        Transform::from_xyz(1.5, 1.0, 0.0),
+        Collider::cuboid(1.2, 1.0),
+    ));
+    let anchor_jelly = commands
+        .spawn(jelly(Vec2::new(1.5, 2.6), Vec2::splat(0.5), 1.2e4, &color))
+        .id();
+    commands.spawn((
+        jelly(Vec2::new(3.8, 2.6), Vec2::splat(0.5), 1.2e4, &color),
+        ImpulseJoint::new(anchor_jelly, RopeJointBuilder::new(2.2)),
+    ));
+
+    /*
+     * Spring: a bungee jelly bouncing under a gantry.
+     */
+    let gantry = commands
+        .spawn((Transform::from_xyz(6.5, 5.5, 0.0), RigidBody::Fixed))
+        .id();
+    commands.spawn((
+        jelly(Vec2::new(6.5, 3.2), Vec2::splat(0.45), 6.0e3, &color),
+        ImpulseJoint::new(gantry, SpringJointBuilder::new(1.2, 25.0, 1.5)),
+    ));
+
+    /*
+     * Pin-slot: a jelly bead sliding and spinning along a vertical pole, caught by the slot
+     * limits. The pole collides with nothing: the bead's particles would otherwise rest on it.
+     */
+    let pole_pos = Vec2::new(9.5, 2.5);
+    let pole = commands
+        .spawn((
+            Transform::from_translation(pole_pos.extend(0.0)),
+            RigidBody::Fixed,
+            Collider::cuboid(0.05, 2.5),
+            CollisionGroups::new(Group::NONE, Group::NONE),
+        ))
+        .id();
+    commands.spawn((
+        jelly(
+            pole_pos + Vec2::new(0.0, 1.7),
+            Vec2::splat(0.35),
+            8.0e3,
+            &color,
+        ),
+        ImpulseJoint::new(pole, PinSlotJointBuilder::new(Vec2::Y).limits([-1.8, 1.8])),
+    ));
+
+    /*
+     * Same-soft-body joint: a motorized revolute hinges two disjoint half clusters of one soft
+     * bar at its middle, so the body folds and flaps at its own hinge.
+     */
+    let bar_center = Vec2::new(13.5, 3.0);
+    let bar = SoftBody::grid(Vec2::new(1.0, 0.22), 9, 3).map(|b| {
+        b.cell_model(SoftBodyCellModel::Corotational)
+            .particle_mass(0.08)
+            .particle_radius(0.06)
+    });
+    let positions: Vec<Vec2> = bar
+        .builder
+        .particle_positions()
+        .iter()
+        .map(|p| bar_center + *p)
+        .collect();
+    let half = |left: bool| -> Vec<u32> {
+        (0..positions.len() as u32)
+            .filter(|i| {
+                let dx = positions[*i as usize].x - bar_center.x;
+                if left {
+                    dx < -1.0e-3
+                } else {
+                    dx > 1.0e-3
+                }
+            })
+            .collect()
+    };
+    let (left_half, right_half) = (half(true), half(false));
+    let centroid = |particles: &[u32]| {
+        particles
+            .iter()
+            .map(|i| positions[*i as usize])
+            .sum::<Vec2>()
+            / particles.len() as f32
+    };
+    let (left_pos, right_pos) = (centroid(&left_half), centroid(&right_half));
+    let bar = commands
+        .spawn((
+            Transform::from_translation(bar_center.extend(0.0)),
+            bar,
+            SoftBodyMaterial(RapierSoftBodyMaterial {
+                young_modulus: 2.0e4,
+                poisson_ratio: 0.35,
+                elastic_damping_ratio: 1.0,
+                ..default()
+            }),
+            SoftBodyMeshSync::default(),
+            MeshMaterial2d(color.clone()),
+        ))
+        .id();
+    // Hold the bar's left half in the air, then flap the right half about the middle hinge.
+    let bar_anchor = commands
+        .spawn((
+            Transform::from_translation(left_pos.extend(0.0)),
+            RigidBody::Fixed,
+        ))
+        .id();
+    let left_cluster = commands
+        .spawn((
+            SoftBodyCluster::new(bar, left_half),
+            ImpulseJoint::new(bar_anchor, FixedJointBuilder::new()),
+        ))
+        .id();
+    commands.spawn((
+        FlapJoint,
+        SoftBodyCluster::new(bar, right_half),
+        ImpulseJoint::new(
+            left_cluster,
+            RevoluteJointBuilder::new()
+                .local_anchor1(bar_center - left_pos)
+                .local_anchor2(bar_center - right_pos)
+                .motor_position(0.0, 80.0, 10.0),
+        ),
+    ));
+
+    /*
+     * A jelly hanging from a two-link arm, while a rope joint ties the same jelly to a rigid
+     * crate on the ground.
+     */
+    let arm_root = commands
+        .spawn((Transform::from_xyz(17.0, 6.0, 0.0), RigidBody::Fixed))
+        .id();
+    let link1 = commands
+        .spawn((
+            Transform::from_xyz(18.2, 6.0, 0.0),
+            RigidBody::Dynamic,
+            Collider::capsule_x(0.5, 0.08),
+            ColliderMassProperties::Density(2.0),
+            ImpulseJoint::new(
+                arm_root,
+                RevoluteJointBuilder::new().local_anchor2(Vec2::new(-1.2, 0.0)),
+            ),
+        ))
+        .id();
+    let link2 = commands
+        .spawn((
+            Transform::from_xyz(19.4, 6.0, 0.0),
+            RigidBody::Dynamic,
+            Collider::capsule_x(0.5, 0.08),
+            ColliderMassProperties::Density(2.0),
+            ImpulseJoint::new(
+                link1,
+                RevoluteJointBuilder::new()
+                    .local_anchor1(Vec2::new(0.6, 0.0))
+                    .local_anchor2(Vec2::new(-0.6, 0.0)),
+            ),
+        ))
+        .id();
+    let pendulum = commands
+        .spawn((
+            jelly(Vec2::new(20.2, 5.2), Vec2::splat(0.5), 5.0e3, &color),
+            ImpulseJoint::new(
+                link2,
+                RevoluteJointBuilder::new()
+                    .local_anchor1(Vec2::new(0.7, 0.0))
+                    .local_anchor2(Vec2::new(0.0, 0.6))
+                    .contacts_enabled(false),
+            ),
+        ))
+        .id();
+    commands.spawn((
+        Transform::from_xyz(20.2, 0.3, 0.0),
+        RigidBody::Dynamic,
+        Collider::cuboid(0.3, 0.3),
+        ColliderMassProperties::Density(0.5),
+        ImpulseJoint::new(pendulum, RopeJointBuilder::new(4.2)),
+    ));
+
+    /*
+     * Kinematic cluster (no joint): a soft rope whose pinned top cluster is waved rigidly.
+     */
+    let rope_top = Vec2::new(-16.0, 5.5);
+    let rope = commands
+        .spawn((
+            Transform::from_translation(rope_top.extend(0.0)),
+            SoftBody::rope(Vec2::ZERO, Vec2::new(0.0, -4.0), 20).map(|b| b.particle_mass(0.05)),
+        ))
+        .id();
+    // The center of the first two particles, the rope's particles being 4 / 19 apart.
+    let home = rope_top - Vec2::new(0.0, 2.0 / 19.0);
+    commands.spawn((
+        SoftBodyCluster::new(rope, [0, 1]),
+        Grip { home },
+        // Pins the cluster, and moves it to this pose.
+        SoftBodyClusterKinematicTarget(Transform::from_translation(home.extend(0.0))),
+    ));
+}
+
+/// Moves the targets of the prismatic and flapping motors.
+fn animate_motors(
+    time: Res<Time>,
+    mut rail_joints: Query<&mut ImpulseJoint, (With<RailJoint>, Without<FlapJoint>)>,
+    mut flap_joints: Query<&mut ImpulseJoint, With<FlapJoint>>,
+) {
+    let t = time.elapsed_secs();
+    for mut joint in &mut rail_joints {
+        joint
+            .data
+            .as_mut()
+            .set_motor_position(JointAxis::LinX, 1.5 * (0.6 * t).sin(), 40.0, 8.0);
+    }
+    for mut joint in &mut flap_joints {
+        joint
+            .data
+            .as_mut()
+            .set_motor_position(JointAxis::AngX, 0.8 * (1.4 * t).sin(), 80.0, 10.0);
+    }
+}
+
+/// Waves the grip cluster along a kinematic path.
+fn wave_grip(time: Res<Time>, mut grips: Query<(&Grip, &mut SoftBodyClusterKinematicTarget)>) {
+    let t = time.elapsed_secs();
+    for (grip, mut target) in &mut grips {
+        let position = grip.home + Vec2::new(1.2 * (0.7 * t).sin(), 0.15 * (1.9 * t).sin());
+        target.0 = Transform::from_translation(position.extend(0.0))
+            .with_rotation(Quat::from_rotation_z(0.5 * (1.1 * t).sin()));
+    }
+}
diff --git a/bindings/bevy_rapier/bevy_rapier2d/examples/soft_plasticity2.rs b/bindings/bevy_rapier/bevy_rapier2d/examples/soft_plasticity2.rs
new file mode 100644
index 000000000..ef5447c00
--- /dev/null
+++ b/bindings/bevy_rapier/bevy_rapier2d/examples/soft_plasticity2.rs
@@ -0,0 +1,216 @@
+//! Plasticity: elastic cells whose rest shape flows once their strain exceeds a yield
+//! (`plastic_yield` and `plastic_creep` of the soft-body material), shown on squares hit by disks,
+//! a clay slab stamped by a kinematic press, a creeping column, and clay disks splatting on a wall.
+
+use bevy::prelude::*;
+use bevy_rapier2d::prelude::*;
+
+/// Marks the kinematic press.
+#[derive(Component)]
+struct Press;
+
+/// The position of the press above its first spot.
+const PRESS_REST: Vec2 = Vec2::new(-2.0, 2.4);
+
+fn main() {
+    App::new()
+        .insert_resource(ClearColor(Color::srgb(
+            0xF9 as f32 / 255.0,
+            0xF9 as f32 / 255.0,
+            0xFF as f32 / 255.0,
+        )))
+        .add_plugins((
+            DefaultPlugins,
+            RapierPhysicsPlugin::<NoUserData>::default(),
+            RapierDebugRenderPlugin::default(),
+        ))
+        .add_systems(Startup, (setup_graphics, setup_physics))
+        .add_systems(Update, move_press)
+        .run();
+}
+
+fn setup_graphics(mut commands: Commands) {
+    commands.spawn((
+        Camera2d,
+        Projection::from(OrthographicProjection {
+            scale: 1.0 / 38.0,
+            ..OrthographicProjection::default_2d()
+        }),
+        Transform::from_xyz(0.0, 3.0, 0.0),
+    ));
+}
+
+/// A clay material: elastic up to `plastic_yield`, flowing at the rate `plastic_creep` beyond.
+fn clay(young_modulus: f32, plastic_yield: f32, plastic_creep: f32) -> SoftBodyMaterial {
+    SoftBodyMaterial(RapierSoftBodyMaterial {
+        young_modulus,
+        poisson_ratio: 0.35,
+        elastic_damping_ratio: 1.0,
+        plastic_yield,
+        plastic_creep,
+        deformation_damping: 4.0,
+        ..default()
+    })
+}
+
+fn setup_physics(
+    mut commands: Commands,
+    mut meshes: ResMut<Assets<Mesh>>,
+    mut materials: ResMut<Assets<ColorMaterial>>,
+) {
+    let clay_color = materials.add(Color::srgb(0.8, 0.5, 0.35));
+    let elastic_color = materials.add(Color::srgb(0.4, 0.7, 0.9));
+    let disk_color = materials.add(Color::srgb(0.3, 0.3, 0.4));
+    let clay_color = |plastic_yield: f32| {
+        if plastic_yield > 0.0 {
+            clay_color.clone()
+        } else {
+            elastic_color.clone()
+        }
+    };
+
+    /*
+     * Ground, and a wall for the clay disks.
+     */
+    commands.spawn((
+        Transform::from_xyz(0.0, -0.5, 0.0),
+        Collider::cuboid(16.0, 0.5),
+    ));
+    commands.spawn((
+        Transform::from_xyz(13.0, 2.0, 0.0),
+        Collider::cuboid(0.2, 2.0),
+        Friction::coefficient(0.8),
+    ));
+
+    /*
+     * The yield ladder: identical squares, from purely elastic (left) to very plastic (right),
+     * each hit by the same heavy disk.
+     */
+    for (i, plastic_yield) in [0.0, 0.2, 0.08, 0.02].into_iter().enumerate() {
+        let x = -13.0 + i as f32 * 2.4;
+        commands.spawn((
+            Transform::from_xyz(x, 0.75, 0.0),
+            SoftBody::grid(Vec2::splat(0.75), 6, 6).map(|b| {
+                b.cell_model(SoftBodyCellModel::Corotational)
+                    .particle_mass(0.1)
+            }),
+            clay(1.0e4, plastic_yield, 20.0),
+            Friction::coefficient(0.8),
+            SoftBodyMeshSync::default(),
+            MeshMaterial2d(clay_color(plastic_yield)),
+        ));
+        commands.spawn((
+            Transform::from_xyz(x, 6.0, 0.0),
+            RigidBody::Dynamic,
+            Collider::ball(0.4),
+            ColliderMassProperties::Density(5.0),
+            Mesh2d(meshes.add(Circle::new(0.4))),
+            MeshMaterial2d(disk_color.clone()),
+        ));
+    }
+
+    /*
+     * A clay slab stamped by a kinematic press: the imprints stay after the press lifts.
+     */
+    commands.spawn((
+        Transform::from_xyz(0.0, 0.5, 0.0),
+        SoftBody::grid(Vec2::new(3.0, 0.5), 25, 5).map(|b| {
+            b.cell_model(SoftBodyCellModel::Corotational)
+                .particle_mass(0.1)
+        }),
+        clay(3.0e4, 0.02, 50.0),
+        Friction::coefficient(0.8),
+        SoftBodyMeshSync::default(),
+        MeshMaterial2d(clay_color(0.02)),
+    ));
+    commands.spawn((
+        Press,
+        Transform::from_translation(PRESS_REST.extend(0.0))
+            .with_rotation(Quat::from_rotation_z(std::f32::consts::FRAC_PI_4)),
+        RigidBody::KinematicPositionBased,
+        Collider::cuboid(0.4, 0.4),
+        Friction::coefficient(0.5),
+        Mesh2d(meshes.add(Rectangle::new(0.8, 0.8))),
+        MeshMaterial2d(disk_color.clone()),
+    ));
+
+    /*
+     * Two soft columns under their own weight: the elastic one stands, the plastic one creeps,
+     * leans and collapses into a heap (a body whose cells keep flowing is kept awake).
+     */
+    for (i, plastic_yield) in [0.0, 0.04].into_iter().enumerate() {
+        let x = 5.5 + i as f32 * 1.5;
+        commands.spawn((
+            Transform::from_xyz(x, 1.2, 0.0),
+            SoftBody::grid(Vec2::new(0.3, 1.2), 3, 12).map(|b| {
+                b.cell_model(SoftBodyCellModel::Corotational)
+                    .particle_mass(0.2)
+            }),
+            SoftBodyMaterial(RapierSoftBodyMaterial {
+                young_modulus: 2.0e3,
+                poisson_ratio: 0.35,
+                elastic_damping_ratio: 1.0,
+                plastic_yield,
+                plastic_creep: 0.5,
+                deformation_damping: 4.0,
+                ..default()
+            }),
+            Friction::coefficient(1.0),
+            SoftBodyMeshSync::default(),
+            MeshMaterial2d(clay_color(plastic_yield)),
+        ));
+    }
+
+    /*
+     * Clay disks thrown at the wall: 24-gons filled with triangular cells.
+     */
+    let n = 24;
+    let vertices: Vec<Vec2> = (0..n)
+        .map(|k| Vec2::from_angle(k as f32 / n as f32 * std::f32::consts::TAU) * 0.5)
+        .collect();
+    let indices: Vec<[u32; 2]> = (0..n).map(|i| [i as u32, ((i + 1) % n) as u32]).collect();
+    for i in 0..3 {
+        let Some(disk) = SoftBody::volumetric(&vertices, &indices, 0.15) else {
+            continue;
+        };
+        commands.spawn((
+            Transform::from_xyz(11.5 - i as f32 * 1.5, 1.0 + i as f32 * 0.5, 0.0),
+            disk.map(|b| {
+                b.cell_model(SoftBodyCellModel::Corotational)
+                    .particle_mass(0.05)
+            }),
+            clay(1.0e4, 0.03, 60.0),
+            Friction::coefficient(0.8),
+            // Throw the whole disk toward the wall.
+            SoftBodyExternalImpulse {
+                velocity_change: Vec2::new(10.0, 1.0),
+                ..default()
+            },
+            SoftBodyMeshSync::default(),
+            MeshMaterial2d(clay_color(0.03)),
+        ));
+    }
+}
+
+/// Stamps a new spot of the slab every 3 seconds: down for a second, up for a second, then
+/// slides to the next spot.
+fn move_press(time: Res<Time>, mut presses: Query<&mut Transform, With<Press>>) {
+    let t = time.elapsed_secs();
+    let period = 3.0;
+    let cycle = (t / period).floor();
+    let phase = t - cycle * period;
+    let depth = 1.0;
+    let x = PRESS_REST.x + (cycle % 5.0);
+    let y = PRESS_REST.y
+        - if phase < 1.0 {
+            depth * phase
+        } else if phase < 2.0 {
+            depth * (2.0 - phase)
+        } else {
+            0.0
+        };
+    for mut transform in &mut presses {
+        transform.translation.x = x;
+        transform.translation.y = y;
+    }
+}
diff --git a/bindings/bevy_rapier/bevy_rapier2d/examples/soft_tearing2.rs b/bindings/bevy_rapier/bevy_rapier2d/examples/soft_tearing2.rs
new file mode 100644
index 000000000..366ce625a
--- /dev/null
+++ b/bindings/bevy_rapier/bevy_rapier2d/examples/soft_tearing2.rs
@@ -0,0 +1,290 @@
+//! Tearing (`tear_strain`): a pinned jelly bridge broken by a heavy disk, a hanging strip shot
+//! through by a fast disk, and a jelly bar pulled apart by its pinned ends. Cracks split particles
+//! and shed pieces as new soft body entities.
+//!
+//! Every `SoftBodyTearEvent` is logged and its cracks flash red. Press the up/down arrows to set
+//! the smallest piece a tear may split off, and `D` to restore the default (3 cells).
+
+use bevy::prelude::*;
+use bevy_rapier2d::prelude::*;
+
+/// The smallest piece a tear may split off (`None` for Rapier's default), applied to every soft
+/// body.
+#[derive(Resource, Default)]
+struct MinPiece(Option<u32>);
+
+/// Marks the text showing [`MinPiece`].
+#[derive(Component)]
+struct MinPieceText;
+
+/// Where recent cracks opened, with their remaining display time.
+#[derive(Resource, Default)]
+struct TearMarks(Vec<(Vec2, f32)>);
+
+fn main() {
+    App::new()
+        .insert_resource(ClearColor(Color::srgb(
+            0xF9 as f32 / 255.0,
+            0xF9 as f32 / 255.0,
+            0xFF as f32 / 255.0,
+        )))
+        .init_resource::<MinPiece>()
+        .init_resource::<TearMarks>()
+        .add_plugins((
+            DefaultPlugins,
+            RapierPhysicsPlugin::<NoUserData>::default(),
+            RapierDebugRenderPlugin::default(),
+        ))
+        .add_systems(Startup, (setup_graphics, setup_physics))
+        .add_systems(
+            Update,
+            (
+                drive_bar,
+                (log_tears, draw_tear_marks).chain(),
+                update_min_piece,
+            ),
+        )
+        .run();
+}
+
+fn setup_graphics(mut commands: Commands, mut debug_render: ResMut<DebugRenderContext>) {
+    commands.spawn((
+        Camera2d,
+        Projection::from(OrthographicProjection {
+            scale: 1.0 / 36.0,
+            ..OrthographicProjection::default_2d()
+        }),
+        Transform::from_xyz(0.0, 4.0, 0.0),
+    ));
+    commands.spawn((
+        MinPieceText,
+        Text::new(""),
+        TextColor(Color::BLACK),
+        Node {
+            position_type: PositionType::Absolute,
+            top: Val::Px(10.0),
+            left: Val::Px(10.0),
+            ..default()
+        },
+    ));
+    // Color the soft-body elements by their load, up to the tear threshold.
+    debug_render.mode.soft_bodies = true;
+    debug_render.mode.soft_body_stress = true;
+}
+
+/// A jelly material tearing past `tear_strain`.
+fn jelly(young_modulus: f32, tear_strain: f32) -> SoftBodyMaterial {
+    SoftBodyMaterial(RapierSoftBodyMaterial {
+        young_modulus,
+        poisson_ratio: 0.3,
+        elastic_damping_ratio: 1.0,
+        tear_strain: Some(tear_strain),
+        ..default()
+    })
+}
+
+fn setup_physics(
+    mut commands: Commands,
+    mut meshes: ResMut<Assets<Mesh>>,
+    mut materials: ResMut<Assets<ColorMaterial>>,
+) {
+    let jelly_color = materials.add(Color::srgb(0.55, 0.8, 0.6));
+    let disk_color = materials.add(Color::srgb(0.2, 0.4, 0.8));
+
+    /*
+     * Ground, and a wall catching the disk shot through the strip.
+     */
+    commands.spawn((
+        Transform::from_xyz(0.0, -0.5, 0.0),
+        Collider::cuboid(30.0, 0.5),
+    ));
+    commands.spawn((
+        Transform::from_xyz(16.0, 3.0, 0.0),
+        Collider::cuboid(0.3, 3.0),
+    ));
+
+    /*
+     * A bridge pinned at both ends: the heavy disk dropped on its middle breaks it. Particle
+     * `(i, j)` of a grid has the index `i * ny + j`.
+     */
+    let (nx, ny) = (31, 6);
+    let idx = move |i: usize, j: usize| (i * ny + j) as u32;
+    commands.spawn((
+        Transform::from_xyz(-8.0, 4.0, 0.0),
+        SoftBody::grid(Vec2::new(3.0, 0.5), nx, ny).map(|b| {
+            b.cell_model(SoftBodyCellModel::Corotational)
+                .pinned_particles((0..ny).flat_map(|j| [idx(0, j), idx(nx - 1, j)]))
+                .particle_mass(0.05)
+        }),
+        // Stiff enough to hold its own weight under the tear strain.
+        jelly(1.0e6, 0.35),
+        Friction::coefficient(0.8),
+        SoftBodyMeshSync::default(),
+        MeshMaterial2d(jelly_color.clone()),
+    ));
+    commands.spawn((
+        Transform::from_xyz(-8.0, 9.0, 0.0),
+        RigidBody::Dynamic,
+        Collider::ball(0.6),
+        ColliderMassProperties::Density(20.0),
+        Mesh2d(meshes.add(Circle::new(0.6))),
+        MeshMaterial2d(disk_color.clone()),
+    ));
+
+    /*
+     * A strip hanging from its top edge, with a fast disk shot through it.
+     */
+    let (nx, ny) = (7, 41);
+    let idx = move |i: usize, j: usize| (i * ny + j) as u32;
+    commands.spawn((
+        Transform::from_xyz(2.0, 5.0, 0.0),
+        SoftBody::grid(Vec2::new(0.45, 3.0), nx, ny).map(|b| {
+            b.cell_model(SoftBodyCellModel::Corotational)
+                .pinned_particles((0..nx).map(|i| idx(i, ny - 1)))
+                .particle_mass(0.05)
+        }),
+        jelly(3.0e4, 0.35),
+        Friction::coefficient(0.8),
+        SoftBodyMeshSync::default(),
+        MeshMaterial2d(jelly_color.clone()),
+    ));
+    commands.spawn((
+        Transform::from_xyz(-4.0, 4.5, 0.0),
+        RigidBody::Dynamic,
+        Velocity::linear(Vec2::new(20.0, 0.0)),
+        Collider::ball(0.4),
+        ColliderMassProperties::Density(10.0),
+        Mesh2d(meshes.add(Circle::new(0.4))),
+        MeshMaterial2d(disk_color),
+    ));
+
+    /*
+     * A jelly bar pinned at both ends: the right end is pulled away until the bar snaps.
+     */
+    let bar_center = Vec2::new(-3.0, 1.0);
+    let bar = SoftBody::grid(Vec2::new(2.0, 0.4), 21, 5).map(|b| {
+        b.cell_model(SoftBodyCellModel::Corotational)
+            .particle_mass(0.05)
+    });
+    let positions = bar.builder.particle_positions().to_vec();
+    let left: Vec<u32> = (0..positions.len() as u32)
+        .filter(|i| positions[*i as usize].x < -1.99)
+        .collect();
+    let right: Vec<u32> = (0..positions.len() as u32)
+        .filter(|i| positions[*i as usize].x > 1.99)
+        .collect();
+    let pinned: Vec<u32> = left.iter().chain(&right).copied().collect();
+    commands.spawn((
+        Transform::from_translation(bar_center.extend(0.0)),
+        bar.map(|b| b.pinned_particles(pinned)),
+        // The right end is dragged by moving these targets (see `drive_bar`). A tear moves
+        // them to the pieces holding their particles.
+        SoftBodyKinematicTargets(
+            right
+                .iter()
+                .map(|i| (*i, bar_center + positions[*i as usize]))
+                .collect(),
+        ),
+        jelly(5.0e4, 0.35),
+        Friction::coefficient(0.8),
+        SoftBodyMeshSync::default(),
+        MeshMaterial2d(jelly_color),
+    ));
+}
+
+/// Drags the right end of the bar by moving its kinematic targets.
+fn drive_bar(
+    time: Res<Time>,
+    mut last_shift: Local<f32>,
+    mut targets: Query<&mut SoftBodyKinematicTargets>,
+) {
+    // The right end starts moving after a second, at half a meter per second, and stops once
+    // the bar has doubled its length.
+    let shift = ((time.elapsed_secs() - 1.0).max(0.0) * 0.5).min(4.0);
+    let delta = shift - std::mem::replace(&mut *last_shift, shift);
+    if delta == 0.0 {
+        return;
+    }
+    for mut targets in &mut targets {
+        for (_, target) in &mut targets.0 {
+            *target += Vec2::new(delta, 0.0);
+        }
+    }
+}
+
+/// Logs the tears, and remembers where their cracks opened.
+fn log_tears(
+    context: ReadRapierContext,
+    mut tears: MessageReader<SoftBodyTearEvent>,
+    mut marks: ResMut<TearMarks>,
+) {
+    let Ok(context) = context.single() else {
+        return;
+    };
+    for tear in tears.read() {
+        let pieces: Vec<_> = tear.pieces.iter().map(|piece| piece.soft_body).collect();
+        info!(
+            "Soft body {} tore: {} edges and {} cells cracked, pieces: {pieces:?}",
+            tear.soft_body,
+            tear.raw.torn_edges.len(),
+            tear.raw.torn_cells.len(),
+        );
+
+        // The current position of a particle of the torn body (a post-tear index).
+        let position = |particle: u32| {
+            let (handle, i) = tear.raw.particle_destination(particle)?;
+            let sb = context.rigidbody_set.soft_bodies.get(handle)?;
+            (i < sb.num_particles() as u32).then(|| sb.particle_position(i as usize))
+        };
+        let edges = tear.raw.torn_edges.iter().map(|e| e.as_slice());
+        let cells = tear.raw.torn_cells.iter().map(|c| c.as_slice());
+        for element in edges.chain(cells) {
+            let points: Option<Vec<Vec2>> = element.iter().map(|v| position(*v)).collect();
+            if let Some(points) = points {
+                let center = points.iter().sum::<Vec2>() / points.len() as f32;
+                marks.0.push((center, 1.0));
+            }
+        }
+    }
+}
+
+/// Draws the recent cracks, fading out over a second.
+fn draw_tear_marks(time: Res<Time>, mut marks: ResMut<TearMarks>, mut gizmos: Gizmos) {
+    for (center, life) in &mut marks.0 {
+        gizmos.circle_2d(*center, 0.12, Color::srgba(0.9, 0.1, 0.1, *life));
+        *life -= time.delta_secs();
+    }
+    marks.0.retain(|(_, life)| *life > 0.0);
+}
+
+/// Changes the smallest piece a tear may split off with the keyboard.
+fn update_min_piece(
+    keys: Res<ButtonInput<KeyCode>>,
+    mut min_piece: ResMut<MinPiece>,
+    mut soft_bodies: Query<&mut SoftBodyMaterial>,
+    mut text: Query<&mut Text, With<MinPieceText>>,
+) {
+    if keys.just_pressed(KeyCode::ArrowUp) {
+        min_piece.0 = Some(min_piece.0.map_or(3, |n| (n + 1).min(40)));
+    }
+    if keys.just_pressed(KeyCode::ArrowDown) {
+        min_piece.0 = Some(min_piece.0.map_or(3, |n| n.saturating_sub(1).max(1)));
+    }
+    if keys.just_pressed(KeyCode::KeyD) {
+        min_piece.0 = None;
+    }
+    if !min_piece.is_changed() {
+        return;
+    }
+
+    // The pieces split off by a tear are clones of their soft body's entity, material included.
+    for mut material in &mut soft_bodies {
+        material.min_piece = min_piece.0;
+    }
+    for mut text in &mut text {
+        text.0 = match min_piece.0 {
+            Some(n) => format!("Minimum piece: {n} elements (up/down, D for default)"),
+            None => "Minimum piece: default, 3 cells (up/down to change)".to_string(),
+        };
+    }
+}
diff --git a/bindings/bevy_rapier/bevy_rapier2d/examples/testbed2.rs b/bindings/bevy_rapier/bevy_rapier2d/examples/testbed2.rs
new file mode 100644
index 000000000..b906b5d66
--- /dev/null
+++ b/bindings/bevy_rapier/bevy_rapier2d/examples/testbed2.rs
@@ -0,0 +1,355 @@
+#![allow(dead_code)]
+
+mod boxes2;
+mod debug_despawn2;
+mod debug_toggle2;
+mod despawn2;
+mod events2;
+mod joints2;
+mod joints_despawn2;
+mod locked_rotations2;
+mod multiple_colliders2;
+mod player_movement2;
+mod rope_joint2;
+mod soft_bodies2;
+mod voxels2;
+
+use bevy::{
+    camera::visibility::RenderLayers,
+    ecs::{resource::IsResource, world::error::EntityDespawnError},
+    prelude::*,
+};
+use bevy_rapier2d::prelude::*;
+
+#[derive(Debug, Reflect, Clone, Copy, Eq, PartialEq, Default, Hash, States)]
+pub enum Examples {
+    #[default]
+    None,
+    Boxes2,
+    Voxels2,
+    DebugToggle2,
+    RopeJoint2,
+    DebugDespawn2,
+    Despawn2,
+    Events2,
+    Joints2,
+    JointsDespawn2,
+    LockedRotations2,
+    MultipleColliders2,
+    PlayerMovement2,
+    SoftBodies2,
+}
+
+#[derive(Resource, Default, Reflect)]
+struct ExamplesRes {
+    entities_before: Vec<Entity>,
+}
+
+#[derive(Resource, Debug, Default, Reflect)]
+struct ExampleSelected(pub usize);
+
+#[derive(Debug, Reflect)]
+struct ExampleDefinition {
+    pub state: Examples,
+    pub name: &'static str,
+}
+
+impl From<(Examples, &'static str)> for ExampleDefinition {
+    fn from((state, name): (Examples, &'static str)) -> Self {
+        Self { state, name }
+    }
+}
+
+#[derive(Resource, Debug, Reflect)]
+struct ExampleSet(pub Vec<ExampleDefinition>);
+
+fn main() {
+    let mut app = App::new();
+    app.init_resource::<ExamplesRes>()
+        .add_plugins((
+            DefaultPlugins,
+            RapierPhysicsPlugin::<NoUserData>::pixels_per_meter(10.0),
+            RapierDebugRenderPlugin::default(),
+        ))
+        .register_type::<Examples>()
+        .register_type::<ExamplesRes>()
+        .register_type::<ExampleSelected>()
+        .init_state::<Examples>()
+        .insert_resource(ExampleSet(vec![
+            (Examples::Boxes2, "Boxes3").into(),
+            (Examples::Voxels2, "Voxels2").into(),
+            (Examples::RopeJoint2, "RopeJoint2").into(),
+            (Examples::DebugDespawn2, "DebugDespawn2").into(),
+            (Examples::Despawn2, "Despawn3").into(),
+            (Examples::Events2, "Events3").into(),
+            (Examples::Joints2, "Joints3").into(),
+            (Examples::JointsDespawn2, "JointsDespawn3").into(),
+            (Examples::LockedRotations2, "LockedRotations3").into(),
+            (Examples::MultipleColliders2, "MultipleColliders3").into(),
+            (Examples::PlayerMovement2, "PlayerMovement2").into(),
+            (Examples::SoftBodies2, "SoftBodies2").into(),
+        ]))
+        .init_resource::<ExampleSelected>()
+        .add_systems(PreStartup, |mut commands: Commands| {
+            commands.spawn((
+                Camera2d,
+                IsDefaultUiCamera,
+                Camera {
+                    order: 999,
+                    ..Default::default()
+                },
+                RenderLayers::none(),
+            ));
+            commands.spawn((
+                ExampleLabel,
+                Text::default(),
+                Node {
+                    position_type: PositionType::Absolute,
+                    top: px(8),
+                    left: px(8),
+                    ..default()
+                },
+            ));
+        })
+        //
+        //boxes2
+        .add_systems(
+            OnEnter(Examples::Boxes2),
+            (boxes2::setup_graphics, boxes2::setup_physics),
+        )
+        .add_systems(OnExit(Examples::Boxes2), cleanup)
+        //
+        //voxels2
+        .add_systems(
+            OnEnter(Examples::Voxels2),
+            (voxels2::setup_graphics, voxels2::setup_physics),
+        )
+        .add_systems(OnExit(Examples::Voxels2), cleanup)
+        //
+        // Debug toggle
+        .add_systems(
+            OnEnter(Examples::DebugToggle2),
+            (debug_toggle2::setup_graphics, debug_toggle2::setup_physics),
+        )
+        .add_systems(
+            Update,
+            (
+                debug_toggle2::toggle_debug,
+                (|mut debug_render_context: ResMut<DebugRenderContext>| {
+                    debug_render_context.enabled = !debug_render_context.enabled;
+                })
+                .run_if(debug_toggle2::input_just_pressed(KeyCode::KeyV)),
+            )
+                .run_if(in_state(Examples::DebugToggle2)),
+        )
+        .add_systems(OnExit(Examples::DebugToggle2), cleanup)
+        //
+        // rope joint
+        .add_systems(
+            OnEnter(Examples::RopeJoint2),
+            (rope_joint2::setup_graphics, rope_joint2::setup_physics),
+        )
+        .add_systems(OnExit(Examples::RopeJoint2), cleanup)
+        //
+        //debug despawn
+        .init_resource::<debug_despawn2::Game>()
+        .add_systems(OnEnter(Examples::DebugDespawn2), debug_despawn2::setup_game)
+        .add_systems(
+            Update,
+            debug_despawn2::cube_sleep_detection.run_if(in_state(Examples::DebugDespawn2)),
+        )
+        .add_systems(OnExit(Examples::DebugDespawn2), cleanup)
+        //
+        //despawn2
+        .insert_resource(despawn2::DespawnResource::default())
+        .insert_resource(despawn2::ResizeResource::default())
+        .add_systems(
+            OnEnter(Examples::Despawn2),
+            (despawn2::setup_graphics, despawn2::setup_physics),
+        )
+        .add_systems(
+            Update,
+            (despawn2::despawn, despawn2::resize).run_if(in_state(Examples::Despawn2)),
+        )
+        .add_systems(OnExit(Examples::Despawn2), cleanup)
+        //
+        //events
+        .add_systems(
+            OnEnter(Examples::Events2),
+            (events2::setup_graphics, events2::setup_physics),
+        )
+        .add_systems(
+            Update,
+            events2::display_events.run_if(in_state(Examples::Events2)),
+        )
+        .add_systems(OnExit(Examples::Events2), cleanup)
+        //
+        //events
+        .add_systems(
+            OnEnter(Examples::Joints2),
+            (joints2::setup_graphics, joints2::setup_physics),
+        )
+        .add_systems(OnExit(Examples::Joints2), cleanup)
+        //
+        //despawn2
+        .insert_resource(joints_despawn2::DespawnResource::default())
+        .add_systems(
+            OnEnter(Examples::JointsDespawn2),
+            (
+                joints_despawn2::setup_graphics,
+                joints_despawn2::setup_physics,
+            ),
+        )
+        .add_systems(
+            Update,
+            (joints_despawn2::despawn).run_if(in_state(Examples::JointsDespawn2)),
+        )
+        .add_systems(OnExit(Examples::JointsDespawn2), cleanup)
+        //
+        //locked rotations
+        .add_systems(
+            OnEnter(Examples::LockedRotations2),
+            (
+                locked_rotations2::setup_graphics,
+                locked_rotations2::setup_physics,
+            ),
+        )
+        .add_systems(OnExit(Examples::LockedRotations2), cleanup)
+        //
+        //multiple colliders
+        .add_systems(
+            OnEnter(Examples::MultipleColliders2),
+            (
+                multiple_colliders2::setup_graphics,
+                multiple_colliders2::setup_physics,
+            ),
+        )
+        .add_systems(OnExit(Examples::MultipleColliders2), cleanup)
+        //
+        // soft bodies
+        .add_systems(
+            OnEnter(Examples::SoftBodies2),
+            (soft_bodies2::setup_graphics, soft_bodies2::setup_physics),
+        )
+        .add_systems(
+            OnExit(Examples::SoftBodies2),
+            (cleanup, |mut debug_render: ResMut<DebugRenderContext>| {
+                debug_render.mode.soft_bodies = false;
+            }),
+        )
+        //
+        //player movement
+        .add_systems(
+            OnEnter(Examples::PlayerMovement2),
+            player_movement2::spawn_player,
+        )
+        .add_systems(
+            Update,
+            (player_movement2::player_movement).run_if(in_state(Examples::PlayerMovement2)),
+        )
+        .add_systems(
+            OnExit(Examples::PlayerMovement2),
+            (
+                cleanup,
+                |mut rapier_config: Query<&mut RapierConfiguration>,
+                 ctxt: ReadRapierContext|
+                 -> Result<()> {
+                    let mut rapier_config = rapier_config.single_mut()?;
+                    rapier_config.gravity = RapierConfiguration::new(
+                        ctxt.single()?.simulation.integration_parameters.length_unit,
+                    )
+                    .gravity;
+                    Ok(())
+                },
+            ),
+        )
+        //
+        //testbed
+        .add_systems(
+            OnEnter(Examples::None),
+            |mut next_state: ResMut<NextState<Examples>>| {
+                next_state.set(Examples::Boxes2);
+            },
+        )
+        .add_systems(OnExit(Examples::None), init)
+        .add_systems(
+            Update,
+            (
+                select_example,
+                (change_example, update_example_label).run_if(resource_changed::<ExampleSelected>),
+            )
+                .chain(),
+        );
+
+    app.run();
+}
+
+fn init(world: &mut World) {
+    // save all entities that are in the world before setting up any example
+    // to be able to always return to this state when switching from one example to the other.
+    // Resource-backed entities (carrying `IsResource`) are excluded: in Bevy 0.19 resources are
+    // stored as entities, and despawning them in `cleanup` panics.
+    world.resource_mut::<ExamplesRes>().entities_before = world
+        .query_filtered::<Entity, Without<IsResource>>()
+        .iter(world)
+        .collect::<Vec<_>>();
+}
+
+fn cleanup(world: &mut World) {
+    let keep_alive = world.resource::<ExamplesRes>().entities_before.clone();
+
+    let remove = world
+        .query_filtered::<Entity, Without<IsResource>>()
+        .iter(world)
+        .filter(|e| !keep_alive.contains(e))
+        .collect::<Vec<_>>();
+
+    for r in remove {
+        // The entity may already have been despawned as part of a parent's despawn cascade;
+        // skip it in that case to avoid a flood of spurious "invalid entity" warnings.
+        if !world.entities().contains(r) {
+            continue;
+        }
+        if let Err(error @ EntityDespawnError(_)) = world.try_despawn(r) {
+            warn!("Cleanup error: {error:?}");
+        }
+    }
+}
+
+fn change_example(
+    example_selected: Res<ExampleSelected>,
+    examples_available: Res<ExampleSet>,
+    mut next_state: ResMut<NextState<Examples>>,
+) {
+    next_state.set(examples_available.0[example_selected.0].state);
+}
+
+/// Marks the text node displaying the current example's name.
+#[derive(Component)]
+struct ExampleLabel;
+
+fn select_example(
+    keys: Res<ButtonInput<KeyCode>>,
+    mut current_example: ResMut<ExampleSelected>,
+    examples_available: Res<ExampleSet>,
+) {
+    let len = examples_available.0.len();
+    if keys.just_pressed(KeyCode::PageDown) {
+        current_example.0 = (current_example.0 + 1) % len;
+    } else if keys.just_pressed(KeyCode::PageUp) {
+        current_example.0 = (current_example.0 + len - 1) % len;
+    }
+}
+
+fn update_example_label(
+    current_example: Res<ExampleSelected>,
+    examples_available: Res<ExampleSet>,
+    mut label: Query<&mut Text, With<ExampleLabel>>,
+) {
+    for mut text in &mut label {
+        text.0 = format!(
+            "Example: {} (PageUp/PageDown to switch)",
+            examples_available.0[current_example.0].name
+        );
+    }
+}
diff --git a/bindings/bevy_rapier/bevy_rapier2d/examples/voxels2.rs b/bindings/bevy_rapier/bevy_rapier2d/examples/voxels2.rs
new file mode 100644
index 000000000..feea19817
--- /dev/null
+++ b/bindings/bevy_rapier/bevy_rapier2d/examples/voxels2.rs
@@ -0,0 +1,92 @@
+use bevy::prelude::*;
+use bevy_rapier2d::prelude::*;
+
+fn main() {
+    App::new()
+        .insert_resource(ClearColor(Color::srgb(
+            0xF9 as f32 / 255.0,
+            0xF9 as f32 / 255.0,
+            0xFF as f32 / 255.0,
+        )))
+        .add_plugins((
+            DefaultPlugins,
+            RapierPhysicsPlugin::<NoUserData>::pixels_per_meter(10.0),
+            RapierDebugRenderPlugin::default(),
+        ))
+        .add_systems(Startup, (setup_graphics, setup_physics))
+        .run();
+}
+
+pub fn setup_graphics(mut commands: Commands) {
+    commands.spawn((Camera2d, Transform::from_xyz(0.0, 20.0, 0.0)));
+}
+
+pub fn setup_physics(mut commands: Commands) {
+    let scale = 15f32;
+    /*
+     * Create dynamic objects to fall on voxels.
+     */
+    let nx = 50;
+    for i in 0..nx {
+        for j in 0..10 {
+            let falling_objects = (j + i) % 3;
+
+            let ball_radius = 0.5 * scale;
+            let co = match falling_objects {
+                0 => Collider::ball(ball_radius),
+                1 => Collider::cuboid(ball_radius, ball_radius),
+                2 => Collider::capsule_y(ball_radius, ball_radius),
+                _ => unreachable!(),
+            };
+            commands.spawn((
+                Transform::from_xyz(
+                    (i as f32 * 2.0 - nx as f32 / 2.0) * scale,
+                    (20.0 + j as f32 * 2.0) * scale,
+                    0.0,
+                ),
+                RigidBody::Dynamic,
+                co,
+            ));
+        }
+    }
+
+    /*
+     * Voxelization.
+     */
+    let polyline = [
+        Vec2::new(0.0, 0.0),
+        Vec2::new(0.0, 10.0),
+        Vec2::new(7.0, 4.0),
+        Vec2::new(14.0, 10.0),
+        Vec2::new(14.0, 0.0),
+        Vec2::new(13.0, 7.0),
+        Vec2::new(7.0, 2.0),
+        Vec2::new(1.0, 7.0),
+    ]
+    .iter()
+    .map(|p| p * scale)
+    .collect::<Vec<_>>();
+    let indices: Vec<_> = (0..polyline.len() as u32)
+        .map(|i| [i, (i + 1) % polyline.len() as u32])
+        .collect();
+
+    commands.spawn((
+        Transform::from_xyz(-20.0 * scale, -10.0 * scale, 0.0),
+        Collider::voxelized_mesh(&polyline, &indices, 0.2 * scale, FillMode::default()),
+    ));
+
+    /*
+     * A voxel wavy floor.
+     */
+    let voxel_size = Vec2::new(scale, scale);
+    let voxels: Vec<_> = (0..300)
+        .map(|i| {
+            let y = (i as f32 / 20.0).sin().clamp(-0.5, 0.5) * 20.0;
+            Vec2::new((i as f32 - 125.0) * voxel_size.x / 2.0, y * voxel_size.y)
+        })
+        .collect();
+    commands.spawn((
+        Transform::from_xyz(0.0, 0.0, 0.0),
+        Collider::voxels_from_points(voxel_size, &voxels),
+    ));
+}
diff --git a/bindings/bevy_rapier/bevy_rapier2d/examples/voxels2_no_collider.rs b/bindings/bevy_rapier/bevy_rapier2d/examples/voxels2_no_collider.rs
new file mode 100644
index 000000000..67e8b9bf5
--- /dev/null
+++ b/bindings/bevy_rapier/bevy_rapier2d/examples/voxels2_no_collider.rs
@@ -0,0 +1,119 @@
+use bevy::prelude::*;
+use bevy_rapier2d::geometry::RapierColliderHandle;
+use bevy_rapier2d::prelude::*;
+
+fn main() {
+    App::new()
+        .insert_resource(ClearColor(Color::srgb(
+            0xF9 as f32 / 255.0,
+            0xF9 as f32 / 255.0,
+            0xFF as f32 / 255.0,
+        )))
+        .add_plugins((
+            DefaultPlugins,
+            RapierPhysicsPlugin::<NoUserData>::pixels_per_meter(10.0),
+            RapierDebugRenderPlugin::default(),
+        ))
+        .add_systems(Startup, setup)
+        .add_systems(Update, (check_collisions, check_collider_enabled))
+        .run();
+}
+
+fn setup(mut commands: Commands) {
+    // 2D camera
+    commands.spawn((Camera2d, Transform::from_xyz(0.0, 20.0, 0.0)));
+
+    let scale = 15f32;
+
+    let nx = 50;
+    for i in 0..nx {
+        for j in 0..10 {
+            let falling_objects = (j + i) % 3;
+            let ball_radius = 0.5 * scale;
+
+            let collider = match falling_objects {
+                0 => Collider::ball(ball_radius),
+                1 => Collider::cuboid(ball_radius, ball_radius),
+                2 => Collider::capsule_y(ball_radius, ball_radius),
+                _ => unreachable!(),
+            };
+
+            commands
+                .spawn((
+                    Transform::from_xyz(
+                        (i as f32 * 2.0 - nx as f32 / 2.0) * scale,
+                        (20.0 + j as f32 * 2.0) * scale,
+                        0.0,
+                    ),
+                    RigidBody::Dynamic,
+                    AdditionalMassProperties::Mass(1.0),
+                ))
+                .with_children(|parent| {
+                    parent.spawn((collider, ColliderDisabled));
+                });
+        }
+    }
+
+    let polyline = [
+        Vec2::new(0.0, 0.0),
+        Vec2::new(0.0, 10.0),
+        Vec2::new(7.0, 4.0),
+        Vec2::new(14.0, 10.0),
+        Vec2::new(14.0, 0.0),
+        Vec2::new(13.0, 7.0),
+        Vec2::new(7.0, 2.0),
+        Vec2::new(1.0, 7.0),
+    ]
+    .iter()
+    .map(|p| p * scale)
+    .collect::<Vec<_>>();
+    let indices: Vec<_> = (0..polyline.len() as u32)
+        .map(|i| [i, (i + 1) % polyline.len() as u32])
+        .collect();
+
+    commands.spawn((
+        Transform::from_xyz(-20.0 * scale, -10.0 * scale, 0.0),
+        Collider::voxelized_mesh(&polyline, &indices, 0.2 * scale, FillMode::default()),
+        ColliderDisabled,
+    ));
+
+    let voxel_size = Vec2::new(scale, scale);
+    let voxels: Vec<_> = (0..300)
+        .map(|i| {
+            let y = (i as f32 / 20.0).sin().clamp(-0.5, 0.5) * 20.0;
+            Vec2::new((i as f32 - 125.0) * voxel_size.x / 2.0, y * voxel_size.y)
+        })
+        .collect();
+    commands.spawn((
+        Transform::from_xyz(0.0, 0.0, 0.0),
+        Collider::voxels_from_points(voxel_size, &voxels),
+    ));
+}
+
+fn check_collisions(mut collision_events: MessageReader<CollisionEvent>) {
+    for event in collision_events.read() {
+        info!("Collision event: {:?}", event);
+    }
+}
+
+fn check_collider_enabled(
+    rapier_context: ReadRapierContext,
+    query: Query<&RapierColliderHandle, With<ColliderDisabled>>,
+) {
+    let context = match rapier_context.single() {
+        Ok(c) => c,
+        Err(_) => return,
+    };
+
+    for rapier_handle in &query {
+        let handle = rapier_handle.0;
+        if let Some(col) = context.colliders.colliders.get(handle) {
+            if col.is_enabled() {
+                info!(
+                    "FIX ME: Voxel collider should NOT be enabled: {}",
+                    col.is_enabled()
+                );
+            }
+        }
+    }
+}
diff --git a/bindings/bevy_rapier/bevy_rapier3d/Cargo.toml b/bindings/bevy_rapier/bevy_rapier3d/Cargo.toml
new file mode 100644
index 000000000..25d330856
--- /dev/null
+++ b/bindings/bevy_rapier/bevy_rapier3d/Cargo.toml
@@ -0,0 +1,158 @@
+[package]
+name = "bevy_rapier3d"
+version = "0.36.0"
+authors = ["Sébastien Crozet <developer@crozet.re>"]
+description = "3-dimensional physics engine in Rust, official Bevy plugin."
+documentation = "http://docs.rs/bevy_rapier3d"
+homepage = "http://rapier.rs"
+repository = "https://github.com/dimforge/rapier"
+readme = "../README.md"
+keywords = ["physics", "dynamics", "rigid", "real-time", "joints"]
+license = "Apache-2.0"
+edition = "2021"
+
+
+# See more keys and their definitions at https://doc.rust-lang.org/cargo/reference/manifest.html
+[lib]
+path = "../src/lib.rs"
+required-features = ["dim3"]
+
+[lints]
+rust.unexpected_cfgs = { level = "warn", check-cfg = [
+    'cfg(feature, values("dim2"))',
+] }
+clippy = { needless_lifetimes = "allow" }
+
+[features]
+default = [
+    "dim3",
+    "async-collider",
+    "debug-render-3d",
+    "picking-backend",
+    "to-bevy-mesh",
+]
+dim3 = []
+# Alias of the debug-render feature matching this crate's dimension.
+debug-render = ["debug-render-3d"]
+debug-render-2d = [
+    "bevy/bevy_core_pipeline",
+    "bevy/bevy_sprite",
+    "bevy/bevy_gizmos",
+    "rapier3d/debug-render",
+    "bevy/bevy_asset",
+]
+debug-render-3d = [
+    "bevy/bevy_core_pipeline",
+    "bevy/bevy_pbr",
+    "bevy/bevy_gizmos",
+    "rapier3d/debug-render",
+    "bevy/bevy_asset",
+]
+rapier-debug-render = ["rapier3d/debug-render"]
+
+parallel = ["rapier3d/parallel"]
+simd8 = ["rapier3d/simd8"]
+serde-serialize = ["rapier3d/serde-serialize", "bevy/serialize", "serde"]
+enhanced-determinism = ["rapier3d/enhanced-determinism"]
+# Couples the two normal constraints of a contact pair into a single 2x2 block solve.
+block-solver = ["rapier3d/block-solver"]
+# Enables Rapier's internal profiler, needed for the timings reported by `RapierDiagnosticsPlugin`.
+profiler = ["rapier3d/profiler"]
+# Drops the `Sync` requirement of Rapier's callbacks (this also removes the dedicated thread-pool
+# support enabled by `parallel`).
+unsync-callbacks = ["rapier3d/unsync-callbacks"]
+# Opt-in bounds checks on the solver's unchecked SIMD gathers (for debugging).
+solver-bounds-checks = ["rapier3d/solver-bounds-checks"]
+# Enables the experimental FEM soft-body solver.
+fem = ["rapier3d/fem"]
+picking-backend = ["bevy/bevy_picking", "bevy/bevy_render"]
+async-collider = [
+    "bevy/bevy_asset",
+    "bevy/bevy_world_serialization",
+    "bevy/bevy_render",
+    "bevy/bevy_image",
+]
+to-bevy-mesh = ["bevy/bevy_render", "bevy/bevy_asset"]
+# Spawns URDF robots as entities (see `bevy_rapier3d::loaders::urdf`). STL, Collada and OBJ
+# meshes referenced by the URDF files are loaded too.
+urdf = ["dep:rapier3d-urdf", "rapier3d-urdf/stl", "rapier3d-urdf/collada", "rapier3d-urdf/wavefront"]
+# Spawns MuJoCo MJCF models as entities (see `bevy_rapier3d::loaders::mjcf`). STL and OBJ
+# meshes referenced by the MJCF files are loaded too.
+mjcf = ["dep:rapier3d-mjcf", "rapier3d-mjcf/stl", "rapier3d-mjcf/wavefront"]
+# Builds colliders from STL, Collada and OBJ files (see `bevy_rapier3d::loaders::meshloader`).
+meshloader = [
+    "dep:rapier3d-meshloader",
+    "rapier3d-meshloader/stl",
+    "rapier3d-meshloader/collada",
+    "rapier3d-meshloader/wavefront",
+]
+
+[dependencies]
+bevy = { git = "https://github.com/bevyengine/bevy", branch = "main", default-features = false, features = ["std"] }
+nalgebra = { version = "0.35", features = ["convert-glam033"] }
+rapier3d = { workspace = true }
+rapier3d-urdf = { workspace = true, optional = true }
+rapier3d-mjcf = { workspace = true, optional = true }
+rapier3d-meshloader = { workspace = true, optional = true }
+bitflags = "2.10.0"
+log = "0.4"
+serde = { version = "1", features = ["derive"], optional = true }
+
+[dev-dependencies]
+bevy = { git = "https://github.com/bevyengine/bevy", branch = "main", default-features = false, features = [
+    "bevy_window",
+    "x11",
+    "tonemapping_luts",
+    "zstd_rust",
+    "bevy_state",
+    "bevy_debug_stepping",
+    "bevy_text",
+    "bevy_ui",
+    "bevy_ui_render",
+    "default_font",
+    "bevy_log",
+    "bevy_gizmos_render",
+] }
+approx = "0.5.1"
+glam = { version = "0.33", features = ["approx"] }
+serde_json = "1.0"
+
+[package.metadata.docs.rs]
+# Enable all the features when building the docs on docs.rs
+features = ["debug-render-3d", "serde-serialize", "async-collider", "urdf", "mjcf", "meshloader"]
+
+[package.metadata.cargo-all-features]
+
+# `enhanced-determinism` enables `glam/scalar-math` (through parry), which removes the serde
+# impls of `glam::BVec3A`/`BVec4A` that `bevy_reflect` requires unconditionally.
+denylist = ["enhanced-determinism"]
+
+# Features "dim2" and "dim3" are incompatible, so skip permutations including them
+skip_feature_sets = [["enhanced-determinism", "simd8"]]
+
+always_include_features = ["dim3"]
+
+# The maximum number of features to try at once. Does not count features from `always_include_features`.
+# This is useful for reducing the number of combinations run for a crate with a large amount of features,
+# since in most cases a bug just needs a small set of 2-3 features to reproduce.
+
+max_combination_size = 1
+[[example]]
+name = "urdf3"
+required-features = ["urdf"]
+
+[[example]]
+name = "mjcf3"
+required-features = ["mjcf"]
+
+[[example]]
+name = "picking3"
+required-features = ["picking-backend"]
+
+[[example]]
+name = "testbed3"
+required-features = ["picking-backend"]
+
+[[example]]
+name = "soft_fem3"
+required-features = ["fem"]
diff --git a/bindings/bevy_rapier/bevy_rapier3d/assets/robots/arm.urdf b/bindings/bevy_rapier/bevy_rapier3d/assets/robots/arm.urdf
new file mode 100644
index 000000000..7f222f2b1
--- /dev/null
+++ b/bindings/bevy_rapier/bevy_rapier3d/assets/robots/arm.urdf
@@ -0,0 +1,148 @@
+<?xml version="1.0"?>
+<!-- A small primitives-only arm with a two-finger gripper, written for the bevy_rapier examples. -->
+<robot name="arm">
+  <link name="world"/>
+
+  <link name="base">
+    <inertial>
+      <mass value="5"/>
+      <inertia ixx="0.05" ixy="0" ixz="0" iyy="0.05" iyz="0" izz="0.08"/>
+    </inertial>
+    <visual><geometry><cylinder radius="0.2" length="0.1"/></geometry></visual>
+    <collision>
+      <origin xyz="0 0 0.05"/>
+      <geometry><cylinder radius="0.2" length="0.1"/></geometry>
+    </collision>
+  </link>
+
+  <link name="turret">
+    <inertial>
+      <origin xyz="0 0 0.15"/>
+      <mass value="2"/>
+      <inertia ixx="0.02" ixy="0" ixz="0" iyy="0.02" iyz="0" izz="0.01"/>
+    </inertial>
+    <collision>
+      <origin xyz="0 0 0.15"/>
+      <geometry><cylinder radius="0.08" length="0.3"/></geometry>
+    </collision>
+  </link>
+
+  <link name="upper_arm">
+    <inertial>
+      <origin xyz="0 0 0.3"/>
+      <mass value="1"/>
+      <inertia ixx="0.03" ixy="0" ixz="0" iyy="0.03" iyz="0" izz="0.002"/>
+    </inertial>
+    <collision>
+      <origin xyz="0 0 0.3"/>
+      <geometry><box size="0.08 0.08 0.6"/></geometry>
+    </collision>
+  </link>
+
+  <link name="forearm">
+    <inertial>
+      <origin xyz="0 0 0.25"/>
+      <mass value="0.6"/>
+      <inertia ixx="0.013" ixy="0" ixz="0" iyy="0.013" iyz="0" izz="0.001"/>
+    </inertial>
+    <collision>
+      <origin xyz="0 0 0.25"/>
+      <geometry><capsule radius="0.035" length="0.43"/></geometry>
+    </collision>
+  </link>
+
+  <link name="hand">
+    <inertial>
+      <mass value="0.2"/>
+      <inertia ixx="0.001" ixy="0" ixz="0" iyy="0.001" iyz="0" izz="0.001"/>
+    </inertial>
+    <collision><geometry><box size="0.2 0.05 0.04"/></geometry></collision>
+  </link>
+
+  <link name="left_finger">
+    <inertial>
+      <origin xyz="0 0 0.05"/>
+      <mass value="0.05"/>
+      <inertia ixx="0.0001" ixy="0" ixz="0" iyy="0.0001" iyz="0" izz="0.0001"/>
+    </inertial>
+    <collision>
+      <origin xyz="0 0 0.05"/>
+      <geometry><box size="0.02 0.04 0.1"/></geometry>
+    </collision>
+  </link>
+
+  <link name="right_finger">
+    <inertial>
+      <origin xyz="0 0 0.05"/>
+      <mass value="0.05"/>
+      <inertia ixx="0.0001" ixy="0" ixz="0" iyy="0.0001" iyz="0" izz="0.0001"/>
+    </inertial>
+    <collision>
+      <origin xyz="0 0 0.05"/>
+      <geometry><box size="0.02 0.04 0.1"/></geometry>
+    </collision>
+  </link>
+
+  <!-- Empty frame, removed by the loader. -->
+  <link name="tool_center_point"/>
+
+  <joint name="world_anchor" type="fixed">
+    <parent link="world"/>
+    <child link="base"/>
+  </joint>
+
+  <joint name="base_yaw" type="continuous">
+    <parent link="base"/>
+    <child link="turret"/>
+    <origin xyz="0 0 0.1"/>
+    <axis xyz="0 0 1"/>
+    <dynamics damping="0.5" friction="0.1"/>
+  </joint>
+
+  <joint name="shoulder" type="revolute">
+    <parent link="turret"/>
+    <child link="upper_arm"/>
+    <origin xyz="0 0 0.3"/>
+    <axis xyz="0 1 0"/>
+    <limit lower="-1.5" upper="1.5" effort="50" velocity="2"/>
+    <dynamics damping="0.5"/>
+  </joint>
+
+  <joint name="elbow" type="revolute">
+    <parent link="upper_arm"/>
+    <child link="forearm"/>
+    <origin xyz="0 0 0.6"/>
+    <axis xyz="0 1 0"/>
+    <limit lower="-2.5" upper="2.5" effort="30" velocity="2"/>
+    <dynamics damping="0.3"/>
+  </joint>
+
+  <joint name="wrist" type="fixed">
+    <parent link="forearm"/>
+    <child link="hand"/>
+    <origin xyz="0 0 0.5"/>
+  </joint>
+
+  <joint name="left_finger_joint" type="prismatic">
+    <parent link="hand"/>
+    <child link="left_finger"/>
+    <origin xyz="0.05 0 0.02"/>
+    <axis xyz="1 0 0"/>
+    <limit lower="-0.04" upper="0.03" effort="10" velocity="0.2"/>
+  </joint>
+
+  <joint name="right_finger_joint" type="prismatic">
+    <parent link="hand"/>
+    <child link="right_finger"/>
+    <origin xyz="-0.05 0 0.02"/>
+    <axis xyz="1 0 0"/>
+    <limit lower="-0.03" upper="0.04" effort="10" velocity="0.2"/>
+    <mimic joint="left_finger_joint" multiplier="-1"/>
+  </joint>
+
+  <joint name="tool_center_point_joint" type="fixed">
+    <parent link="hand"/>
+    <child link="tool_center_point"/>
+    <origin xyz="0 0 0.12"/>
+  </joint>
+</robot>
diff --git a/bindings/bevy_rapier/bevy_rapier3d/assets/robots/cart_pole.xml b/bindings/bevy_rapier/bevy_rapier3d/assets/robots/cart_pole.xml
new file mode 100644
index 000000000..357cb56b6
--- /dev/null
+++ b/bindings/bevy_rapier/bevy_rapier3d/assets/robots/cart_pole.xml
@@ -0,0 +1,54 @@
+<!-- A primitives-only MJCF scene written for the bevy_rapier examples: an actuated cart-pole, a
+     damped double pendulum with springs, and a few free bodies. -->
+<mujoco model="cart_pole">
+  <compiler angle="radian" autolimits="true"/>
+  <option gravity="0 0 -9.81"/>
+
+  <default>
+    <geom contype="1" conaffinity="1" friction="0.8"/>
+  </default>
+
+  <worldbody>
+    <geom name="floor" type="plane" size="5 5 0.1"/>
+    <geom name="rail" type="box" pos="0 0 1" size="1.6 0.02 0.02" contype="0" conaffinity="0"/>
+
+    <body name="cart" pos="0 0 1">
+      <joint name="slider" type="slide" axis="1 0 0" range="-1.5 1.5" damping="1"/>
+      <geom name="cart_geom" type="box" size="0.15 0.1 0.05" mass="1"/>
+      <body name="pole" pos="0 0 0">
+        <joint name="pole_hinge" type="hinge" axis="0 1 0" damping="0.02"/>
+        <geom name="pole_geom" type="capsule" fromto="0 0 0 0 0 0.6" size="0.03" mass="0.2"/>
+      </body>
+    </body>
+
+    <body name="link1" pos="0 1 1.5">
+      <joint name="hinge1" type="hinge" axis="0 1 0" damping="0.1" armature="0.01" stiffness="1"/>
+      <geom name="link1_geom" type="capsule" fromto="0 0 0 0.4 0 0" size="0.04" mass="0.5"/>
+      <body name="link2" pos="0.4 0 0">
+        <joint name="hinge2" type="hinge" axis="0 1 0" frictionloss="0.05"/>
+        <geom name="link2_geom" type="capsule" fromto="0 0 0 0.4 0 0" size="0.04" mass="0.5"/>
+      </body>
+    </body>
+
+    <body name="box" pos="-0.4 0 2">
+      <freejoint/>
+      <geom name="box_geom" type="box" size="0.1 0.1 0.1" mass="0.3"/>
+    </body>
+    <body name="ghost_box" pos="0.4 0 2">
+      <freejoint/>
+      <geom name="ghost_box_geom" type="box" size="0.1 0.1 0.1" mass="0.3"/>
+    </body>
+  </worldbody>
+
+  <contact>
+    <!-- The ghost box goes through the cart and the pole. -->
+    <exclude body1="ghost_box" body2="cart"/>
+    <exclude body1="ghost_box" body2="pole"/>
+    <pair geom1="box_geom" geom2="cart_geom" friction="0.1"/>
+  </contact>
+
+  <actuator>
+    <motor name="cart_motor" joint="slider" gear="10" ctrlrange="-1 1"/>
+    <position name="elbow_servo" joint="hinge2" kp="2" kv="0.2"/>
+  </actuator>
+</mujoco>
diff --git a/bindings/bevy_rapier/bevy_rapier3d/examples/boxes3.rs b/bindings/bevy_rapier/bevy_rapier3d/examples/boxes3.rs
new file mode 100644
index 000000000..9f862212d
--- /dev/null
+++ b/bindings/bevy_rapier/bevy_rapier3d/examples/boxes3.rs
@@ -0,0 +1,81 @@
+use bevy::prelude::*;
+use bevy_rapier3d::prelude::*;
+
+fn main() {
+    App::new()
+        .insert_resource(ClearColor(Color::srgb(
+            0xF9 as f32 / 255.0,
+            0xF9 as f32 / 255.0,
+            0xFF as f32 / 255.0,
+        )))
+        .add_plugins((
+            DefaultPlugins,
+            RapierPhysicsPlugin::<NoUserData>::default(),
+            RapierDebugRenderPlugin::default(),
+        ))
+        .add_systems(Startup, (setup_graphics, setup_physics))
+        .run();
+}
+
+pub fn setup_graphics(mut commands: Commands) {
+    commands.spawn((
+        Camera3d::default(),
+        Transform::from_xyz(-30.0, 30.0, 100.0).looking_at(Vec3::new(0.0, 10.0, 0.0), Vec3::Y),
+    ));
+}
+
+pub fn setup_physics(mut commands: Commands) {
+    /*
+     * Ground
+     */
+    let ground_size = 200.1;
+    let ground_height = 0.1;
+
+    commands.spawn((
+        Transform::from_xyz(0.0, -ground_height, 0.0),
+        Collider::cuboid(ground_size, ground_height, ground_size),
+    ));
+
+    /*
+     * Create the cubes
+     */
+    let num = 8;
+    let rad = 1.0;
+
+    let shift = rad * 2.0 + rad;
+    let centerx = shift * (num / 2) as f32;
+    let centery = shift / 2.0;
+    let centerz = shift * (num / 2) as f32;
+
+    let mut offset = -(num as f32) * (rad * 2.0 + rad) * 0.5;
+    let mut color = 0;
+    let colors = [
+        Hsla::hsl(220.0, 1.0, 0.3),
+        Hsla::hsl(180.0, 1.0, 0.3),
+        Hsla::hsl(260.0, 1.0, 0.7),
+    ];
+
+    for j in 0usize..20 {
+        for i in 0..num {
+            for k in 0usize..num {
+                let x = i as f32 * shift - centerx + offset;
+                let y = j as f32 * shift + centery + 3.0;
+                let z = k as f32 * shift - centerz + offset;
+                color += 1;
+
+                commands
+                    .spawn(Transform::from_rotation(Quat::from_rotation_x(0.2)))
+                    .with_children(|child| {
+                        child.spawn((
+                            Transform::from_xyz(x, y, z),
+                            RigidBody::Dynamic,
+                            Collider::cuboid(rad, rad, rad),
+                            ColliderDebugColor(colors[color % 3]),
+                        ));
+                    });
+            }
+        }
+
+        offset -= 0.05 * rad * (num as f32 - 1.0);
+    }
+}
diff --git a/bindings/bevy_rapier/bevy_rapier3d/examples/change_contexts3.rs b/bindings/bevy_rapier/bevy_rapier3d/examples/change_contexts3.rs
new file mode 100644
index 000000000..e72303c7b
--- /dev/null
+++ b/bindings/bevy_rapier/bevy_rapier3d/examples/change_contexts3.rs
@@ -0,0 +1,126 @@
+use bevy::prelude::*;
+use bevy_rapier3d::prelude::*;
+
+const N_CONTEXTS: usize = 5;
+const WORLD_CHANGE_DELAY_SEC: f32 = 3.0;
+
+#[derive(Component)]
+/// Denotes which object(s) to change the world of
+struct ChangeWorld;
+
+#[derive(Resource, Debug)]
+struct Contexts(Vec<Entity>);
+
+fn main() {
+    App::new()
+        .insert_resource(ClearColor(Color::linear_rgb(
+            0xF9 as f32 / 255.0,
+            0xF9 as f32 / 255.0,
+            0xFF as f32 / 255.0,
+        )))
+        .add_plugins((
+            DefaultPlugins,
+            RapierPhysicsPlugin::<NoUserData>::default(),
+            RapierDebugRenderPlugin::default(),
+        ))
+        .add_systems(Startup, (setup_graphics, setup_physics))
+        .add_systems(Update, change_world)
+        .run();
+}
+
+fn change_world(
+    mut query: Query<&mut RapierContextEntityLink, With<ChangeWorld>>,
+    time: Res<Time>,
+    worlds: Res<Contexts>,
+) {
+    for mut context_entity_link in query.iter_mut() {
+        let idx = (worlds.0.len() - 1).min((time.elapsed_secs() / WORLD_CHANGE_DELAY_SEC) as usize);
+
+        // Prevent needless change detection
+        if context_entity_link.0 != worlds.0[idx] {
+            context_entity_link.0 = worlds.0[idx];
+            info!(
+                "Changing context to {:?} ({}/{N_CONTEXTS})",
+                context_entity_link.0,
+                idx + 1
+            )
+        }
+    }
+}
+
+fn setup_graphics(mut commands: Commands) {
+    commands.spawn((
+        Camera3d::default(),
+        Transform::from_xyz(0.0, 3.0, -10.0).looking_at(Vec3::new(0.0, 0.0, 0.0), Vec3::Y),
+    ));
+}
+
+pub fn setup_physics(
+    mut commands: Commands,
+    q_default_context: Query<Entity, With<DefaultRapierContext>>,
+) {
+    let default_context = q_default_context
+        .single()
+        .expect("This will automatically be created");
+
+    let mut contexts = Contexts(vec![default_context]);
+
+    for i in 1..N_CONTEXTS {
+        // Each context can have its own rapier configuration
+        let mut config = RapierConfiguration::new(1.0);
+        if i + 1 == N_CONTEXTS {
+            info!("The last context will have opposite gravity");
+            config.gravity = -config.gravity;
+        }
+        let context_ent = commands
+            .spawn((RapierContextSimulation::default(), config))
+            .id();
+        contexts.0.push(context_ent);
+    }
+
+    for (i, &world_ent) in contexts.0.iter().enumerate() {
+        let color = [
+            Color::hsl(220.0, 1.0, 0.3),
+            Color::hsl(180.0, 1.0, 0.3),
+            Color::hsl(260.0, 1.0, 0.7),
+        ][i % 3];
+
+        /*
+         * Ground
+         */
+        let ground_size = 5.1;
+        let ground_height = 0.1;
+
+        commands.spawn((
+            Transform::from_xyz(0.0, (i as f32) * -0.5 - ground_height, 0.0),
+            Collider::cuboid(ground_size, ground_height, ground_size),
+            ColliderDebugColor(color.into()),
+            RigidBody::Fixed,
+            RapierContextEntityLink(world_ent),
+        ));
+    }
+
+    /*
+     * Create the cube
+     *
+     * The child is just there to show that physics world changes will also change the children.
+     */
+    commands
+        .spawn((
+            // This will spawn in the default world, since no RapierContextEntityLink was added
+            Transform::from_xyz(0.0, 3.0, 0.0),
+            RigidBody::Dynamic,
+            ChangeWorld,
+        ))
+        .with_children(|p| {
+            p.spawn((
+                Transform::from_xyz(0.0, 0.0, 0.0),
+                Collider::cuboid(0.5, 0.5, 0.5),
+                ColliderDebugColor(Color::hsl(260.0, 1.0, 0.7).into()),
+            ));
+        });
+
+    info!("Spawning cube in default world (1/{N_CONTEXTS})");
+
+    commands.insert_resource(contexts);
+}
diff --git a/bindings/bevy_rapier/bevy_rapier3d/examples/character_controller3.rs b/bindings/bevy_rapier/bevy_rapier3d/examples/character_controller3.rs
new file mode 100644
index 000000000..f1eed0680
--- /dev/null
+++ b/bindings/bevy_rapier/bevy_rapier3d/examples/character_controller3.rs
@@ -0,0 +1,196 @@
+use bevy::{
+    input::{mouse::MouseMotion, InputSystems},
+    prelude::*,
+};
+use bevy_rapier3d::{control::KinematicCharacterController, prelude::*};
+
+const MOUSE_SENSITIVITY: f32 = 0.3;
+const GROUND_TIMER: f32 = 0.5;
+const MOVEMENT_SPEED: f32 = 8.0;
+const JUMP_SPEED: f32 = 20.0;
+const GRAVITY: f32 = -9.81;
+
+fn main() {
+    App::new()
+        .insert_resource(ClearColor(Color::srgb(
+            0xF9 as f32 / 255.0,
+            0xF9 as f32 / 255.0,
+            0xFF as f32 / 255.0,
+        )))
+        .init_resource::<MovementInput>()
+        .init_resource::<LookInput>()
+        .add_plugins((
+            DefaultPlugins,
+            RapierPhysicsPlugin::<NoUserData>::default(),
+            RapierDebugRenderPlugin::default(),
+        ))
+        .add_systems(Startup, (setup_player, setup_map))
+        .add_systems(PreUpdate, handle_input.after(InputSystems))
+        .add_systems(Update, player_look)
+        .add_systems(FixedUpdate, player_movement)
+        .run();
+}
+
+pub fn setup_player(mut commands: Commands) {
+    commands
+        .spawn((
+            Transform::from_xyz(0.0, 5.0, 0.0),
+            Visibility::default(),
+            Collider::round_cylinder(0.9, 0.3, 0.2),
+            KinematicCharacterController {
+                custom_mass: Some(5.0),
+                up: Vec3::Y,
+                offset: CharacterLength::Absolute(0.01),
+                slide: true,
+                autostep: Some(CharacterAutostep {
+                    max_height: CharacterLength::Relative(0.3),
+                    min_width: CharacterLength::Relative(0.5),
+                    include_dynamic_bodies: false,
+                }),
+                // Don’t allow climbing slopes larger than 45 degrees.
+                max_slope_climb_angle: 45.0_f32.to_radians(),
+                // Automatically slide down on slopes smaller than 30 degrees.
+                min_slope_slide_angle: 30.0_f32.to_radians(),
+                apply_impulse_to_dynamic_bodies: true,
+                snap_to_ground: None,
+                ..default()
+            },
+        ))
+        .with_children(|b| {
+            // FPS Camera
+            b.spawn((Camera3d::default(), Transform::from_xyz(0.0, 0.2, -0.1)));
+        });
+}
+
+fn setup_map(mut commands: Commands) {
+    /*
+     * Ground
+     */
+    let ground_size = 50.0;
+    let ground_height = 0.1;
+
+    commands.spawn((
+        Transform::from_xyz(0.0, -ground_height, 0.0),
+        Collider::cuboid(ground_size, ground_height, ground_size),
+    ));
+    /*
+     * Stairs
+     */
+    let stair_len = 30;
+    let stair_step = 0.2;
+    for i in 1..=stair_len {
+        let step = i as f32;
+        let collider = Collider::cuboid(1.0, step * stair_step, 1.0);
+        commands.spawn((
+            Transform::from_xyz(40.0, step * stair_step, step * 2.0 - 20.0),
+            collider.clone(),
+        ));
+        commands.spawn((
+            Transform::from_xyz(-40.0, step * stair_step, step * -2.0 + 20.0),
+            collider.clone(),
+        ));
+        commands.spawn((
+            Transform::from_xyz(step * 2.0 - 20.0, step * stair_step, 40.0),
+            collider.clone(),
+        ));
+        commands.spawn((
+            Transform::from_xyz(step * -2.0 + 20.0, step * stair_step, -40.0),
+            collider.clone(),
+        ));
+    }
+}
+
+/// Keyboard input vector
+#[derive(Default, Resource, Deref, DerefMut)]
+struct MovementInput(Vec3);
+
+/// Mouse input vector
+#[derive(Default, Resource, Deref, DerefMut)]
+struct LookInput(Vec2);
+
+fn handle_input(
+    keyboard: Res<ButtonInput<KeyCode>>,
+    mut movement: ResMut<MovementInput>,
+    mut look: ResMut<LookInput>,
+    mut mouse_events: MessageReader<MouseMotion>,
+) {
+    if keyboard.pressed(KeyCode::KeyW) {
+        movement.z -= 1.0;
+    }
+    if keyboard.pressed(KeyCode::KeyS) {
+        movement.z += 1.0
+    }
+    if keyboard.pressed(KeyCode::KeyA) {
+        movement.x -= 1.0;
+    }
+    if keyboard.pressed(KeyCode::KeyD) {
+        movement.x += 1.0
+    }
+    **movement = movement.normalize_or_zero();
+    if keyboard.pressed(KeyCode::ShiftLeft) {
+        **movement *= 2.0;
+    }
+    if keyboard.pressed(KeyCode::Space) {
+        movement.y = 1.0;
+    }
+
+    for event in mouse_events.read() {
+        look.x -= event.delta.x * MOUSE_SENSITIVITY;
+        look.y -= event.delta.y * MOUSE_SENSITIVITY;
+        look.y = look.y.clamp(-89.9, 89.9); // Limit pitch
+    }
+}
+
+fn player_movement(
+    time: Res<Time>,
+    mut input: ResMut<MovementInput>,
+    mut player: Query<(
+        &mut Transform,
+        &mut KinematicCharacterController,
+        Option<&KinematicCharacterControllerOutput>,
+    )>,
+    mut vertical_movement: Local<f32>,
+    mut grounded_timer: Local<f32>,
+) {
+    let Ok((transform, mut controller, output)) = player.single_mut() else {
+        return;
+    };
+    let delta_time = time.delta_secs();
+    // Retrieve input
+    let mut movement = Vec3::new(input.x, 0.0, input.z) * MOVEMENT_SPEED;
+    let jump_speed = input.y * JUMP_SPEED;
+    // Clear input
+    **input = Vec3::ZERO;
+    // Check physics ground check
+    if output.map(|o| o.grounded).unwrap_or(false) {
+        *grounded_timer = GROUND_TIMER;
+        *vertical_movement = 0.0;
+    }
+    // If we are grounded we can jump
+    if *grounded_timer > 0.0 {
+        *grounded_timer -= delta_time;
+        // If we jump we clear the grounded tolerance
+        if jump_speed > 0.0 {
+            *vertical_movement = jump_speed;
+            *grounded_timer = 0.0;
+        }
+    }
+    movement.y = *vertical_movement;
+    *vertical_movement += GRAVITY * delta_time * controller.custom_mass.unwrap_or(1.0);
+    controller.translation = Some(transform.rotation * (movement * delta_time));
+}
+
+fn player_look(
+    mut player: Query<&mut Transform, (With<KinematicCharacterController>, Without<Camera>)>,
+    mut camera: Query<&mut Transform, With<Camera>>,
+    input: Res<LookInput>,
+) {
+    let Ok(mut transform) = player.single_mut() else {
+        return;
+    };
+    transform.rotation = Quat::from_axis_angle(Vec3::Y, input.x.to_radians());
+    let Ok(mut transform) = camera.single_mut() else {
+        return;
+    };
+    transform.rotation = Quat::from_axis_angle(Vec3::X, input.y.to_radians());
+}
diff --git a/bindings/bevy_rapier/bevy_rapier3d/examples/collision_groups3.rs b/bindings/bevy_rapier/bevy_rapier3d/examples/collision_groups3.rs
new file mode 100644
index 000000000..c45ddf3fd
--- /dev/null
+++ b/bindings/bevy_rapier/bevy_rapier3d/examples/collision_groups3.rs
@@ -0,0 +1,113 @@
+//! Collision filtering with `CollisionGroups`, including a group relying on
+//! `InteractionTestMode::Or`.
+//!
+//! Green cubes only collide with the green floor and blue cubes only with the blue floor. Orange
+//! cubes fall through both and land on the orange floor: their memberships match the floor's
+//! filter but not the other way around, which is enough since both use `InteractionTestMode::Or`.
+
+use bevy::prelude::*;
+use bevy_rapier3d::prelude::*;
+
+const GREEN_GROUP: CollisionGroups = CollisionGroups::new(Group::GROUP_1, Group::GROUP_1);
+const BLUE_GROUP: CollisionGroups = CollisionGroups::new(Group::GROUP_2, Group::GROUP_2);
+// The orange floor's memberships are not in the orange cubes' filter: with the default
+// `InteractionTestMode::And`, they would never interact.
+const ORANGE_GROUP: CollisionGroups =
+    CollisionGroups::new(Group::GROUP_3, Group::GROUP_1.union(Group::GROUP_3))
+        .with_test_mode(InteractionTestMode::Or);
+const ORANGE_FLOOR_GROUP: CollisionGroups =
+    CollisionGroups::new(Group::GROUP_4, Group::GROUP_3).with_test_mode(InteractionTestMode::Or);
+
+fn main() {
+    App::new()
+        .insert_resource(ClearColor(Color::srgb(
+            0xF9 as f32 / 255.0,
+            0xF9 as f32 / 255.0,
+            0xFF as f32 / 255.0,
+        )))
+        .add_plugins((
+            DefaultPlugins,
+            RapierPhysicsPlugin::<NoUserData>::default(),
+            RapierDebugRenderPlugin::default(),
+        ))
+        .add_systems(Startup, (setup_graphics, setup_physics))
+        .run();
+}
+
+fn setup_graphics(mut commands: Commands) {
+    commands.spawn((
+        Camera3d::default(),
+        Transform::from_xyz(4.0, 4.0, 4.0).looking_at(Vec3::new(0.0, 1.0, 0.0), Vec3::Y),
+    ));
+}
+
+fn setup_physics(mut commands: Commands) {
+    let green = Hsla::hsl(120.0, 1.0, 0.35);
+    let blue = Hsla::hsl(220.0, 1.0, 0.4);
+    let orange = Hsla::hsl(30.0, 1.0, 0.5);
+
+    /*
+     * Ground
+     */
+    let ground_size = 5.0;
+    let ground_height = 0.1;
+
+    commands.spawn((
+        Transform::from_xyz(0.0, -ground_height, 0.0),
+        Collider::cuboid(ground_size, ground_height, ground_size),
+    ));
+
+    /*
+     * Floors colliding only with the cubes of their color.
+     */
+    let floors = [
+        (0.5, ORANGE_FLOOR_GROUP, orange),
+        (1.0, GREEN_GROUP, green),
+        (2.0, BLUE_GROUP, blue),
+    ];
+
+    for (y, groups, color) in floors {
+        commands.spawn((
+            Transform::from_xyz(0.0, y, 0.0),
+            Collider::cuboid(1.0, 0.1, 1.0),
+            groups,
+            ColliderDebugColor(color),
+        ));
+    }
+
+    /*
+     * Create the cubes
+     */
+    let num = 9;
+    let rad = 0.1;
+
+    let shift = rad * 2.0;
+    let centerx = shift * (num / 2) as f32;
+    let centery = 2.5;
+    let centerz = shift * (num / 2) as f32;
+
+    for j in 0usize..4 {
+        for i in 0..num {
+            for k in 0usize..num {
+                let x = i as f32 * shift - centerx;
+                let y = j as f32 * shift + centery;
+                let z = k as f32 * shift - centerz;
+
+                // Cycle through the green, blue, and orange groups.
+                let (groups, color) = match k % 3 {
+                    0 => (GREEN_GROUP, green),
+                    1 => (BLUE_GROUP, blue),
+                    _ => (ORANGE_GROUP, orange),
+                };
+
+                commands.spawn((
+                    Transform::from_xyz(x, y, z),
+                    RigidBody::Dynamic,
+                    Collider::cuboid(rad, rad, rad),
+                    groups,
+                    ColliderDebugColor(color),
+                ));
+            }
+        }
+    }
+}
diff --git a/bindings/bevy_rapier/bevy_rapier3d/examples/collision_only3.rs b/bindings/bevy_rapier/bevy_rapier3d/examples/collision_only3.rs
new file mode 100644
index 000000000..6fa102d9e
--- /dev/null
+++ b/bindings/bevy_rapier/bevy_rapier3d/examples/collision_only3.rs
@@ -0,0 +1,125 @@
+//! Collision detection without dynamics using `SimulationMode::CollisionOnly`.
+//!
+//! Two kinematic bodies, a ball and a cube, are driven through their `Transform`. They report
+//! collision events when they touch the fixed obstacles, which turn red while touched. Nothing
+//! is pushed or stopped.
+
+use bevy::prelude::*;
+use bevy_rapier3d::prelude::*;
+
+/// A kinematic body following a path parameterized by the elapsed time.
+#[derive(Component)]
+struct Mover(fn(f32) -> Vec3);
+
+/// The number of colliders currently touching a fixed obstacle.
+#[derive(Component, Default)]
+struct Touching(usize);
+
+const IDLE_COLOR: Hsla = Hsla::hsl(220.0, 1.0, 0.3);
+const TOUCHED_COLOR: Hsla = Hsla::hsl(0.0, 1.0, 0.5);
+
+fn main() {
+    App::new()
+        .insert_resource(ClearColor(Color::srgb(
+            0xF9 as f32 / 255.0,
+            0xF9 as f32 / 255.0,
+            0xFF as f32 / 255.0,
+        )))
+        .add_plugins((
+            DefaultPlugins,
+            RapierPhysicsPlugin::<NoUserData>::default(),
+            RapierDebugRenderPlugin::default(),
+        ))
+        .add_systems(Startup, (setup_graphics, setup_physics))
+        .add_systems(Update, move_bodies)
+        .add_systems(PostUpdate, handle_events.after(PhysicsSet::Writeback))
+        .run();
+}
+
+fn setup_graphics(mut commands: Commands) {
+    commands.spawn((
+        Camera3d::default(),
+        Transform::from_xyz(0.0, 12.0, 12.0).looking_at(Vec3::ZERO, Vec3::Y),
+    ));
+}
+
+fn setup_physics(
+    mut commands: Commands,
+    mut config: Query<&mut RapierConfiguration>,
+) -> Result<()> {
+    config.single_mut()?.simulation_mode = SimulationMode::CollisionOnly;
+
+    /*
+     * Fixed obstacles: three on the path of the ball, one on the path of the cube.
+     */
+    let obstacles = [
+        (Vec3::new(-5.0, 0.0, 0.0), Collider::cuboid(1.0, 1.0, 1.0)),
+        (Vec3::new(5.0, 0.0, 0.0), Collider::ball(1.2)),
+        (Vec3::new(0.0, 0.0, -5.0), Collider::cuboid(1.5, 1.0, 0.1)),
+        (Vec3::new(0.0, 0.0, 1.5), Collider::cuboid(1.0, 1.0, 0.5)),
+    ];
+
+    for (pos, collider) in obstacles {
+        commands.spawn((
+            Transform::from_translation(pos),
+            collider,
+            ActiveEvents::COLLISION_EVENTS,
+            ColliderDebugColor(IDLE_COLOR),
+            Touching::default(),
+        ));
+    }
+
+    /*
+     * The movers. Kinematic-fixed pairs are ignored by default, so they are enabled with
+     * `ActiveCollisionTypes`.
+     */
+    let ball_path = Mover(|t| Vec3::new(5.0 * (t * 0.8).cos(), 0.0, 5.0 * (t * 0.8).sin()));
+    let cube_path = Mover(|t| Vec3::new(0.0, 0.0, 3.0 * (t * 1.2).sin()));
+    let movers = [
+        (ball_path, Collider::ball(0.5)),
+        (cube_path, Collider::cuboid(0.5, 0.5, 0.5)),
+    ];
+
+    for (path, collider) in movers {
+        commands.spawn((
+            Transform::from_translation(path.0(0.0)),
+            RigidBody::KinematicPositionBased,
+            collider,
+            ActiveCollisionTypes::default() | ActiveCollisionTypes::KINEMATIC_STATIC,
+            path,
+        ));
+    }
+
+    Ok(())
+}
+
+fn move_bodies(time: Res<Time>, mut movers: Query<(&Mover, &mut Transform)>) {
+    for (mover, mut transform) in &mut movers {
+        transform.translation = mover.0(time.elapsed_secs());
+    }
+}
+
+fn handle_events(
+    mut collision_events: MessageReader<CollisionEvent>,
+    mut obstacles: Query<(&mut Touching, &mut ColliderDebugColor)>,
+) {
+    for event in collision_events.read() {
+        info!("Received collision event: {event:?}");
+
+        let (e1, e2, delta) = match *event {
+            CollisionEvent::Started(e1, e2, _) => (e1, e2, 1),
+            CollisionEvent::Stopped(e1, e2, _) => (e1, e2, -1),
+        };
+
+        for entity in [e1, e2] {
+            if let Ok((mut touching, mut color)) = obstacles.get_mut(entity) {
+                touching.0 = touching.0.saturating_add_signed(delta);
+                color.0 = if touching.0 > 0 {
+                    TOUCHED_COLOR
+                } else {
+                    IDLE_COLOR
+                };
+            }
+        }
+    }
+}
diff --git a/bindings/bevy_rapier/bevy_rapier3d/examples/compound3.rs b/bindings/bevy_rapier/bevy_rapier3d/examples/compound3.rs
new file mode 100644
index 000000000..59185a8dc
--- /dev/null
+++ b/bindings/bevy_rapier/bevy_rapier3d/examples/compound3.rs
@@ -0,0 +1,108 @@
+//! The two ways of giving several shapes to a rigid-body: one child collider per shape (blue),
+//! or a single `Collider::compound` (orange).
+
+use bevy::prelude::*;
+use bevy_rapier3d::prelude::*;
+
+fn main() {
+    App::new()
+        .insert_resource(ClearColor(Color::srgb(
+            0xF9 as f32 / 255.0,
+            0xF9 as f32 / 255.0,
+            0xFF as f32 / 255.0,
+        )))
+        .add_plugins((
+            DefaultPlugins,
+            RapierPhysicsPlugin::<NoUserData>::default(),
+            RapierDebugRenderPlugin::default(),
+        ))
+        .add_systems(Startup, (setup_graphics, setup_physics))
+        .run();
+}
+
+fn setup_graphics(mut commands: Commands) {
+    commands.spawn((
+        Camera3d::default(),
+        Transform::from_xyz(-30.0, 30.0, 50.0).looking_at(Vec3::new(0.0, 5.0, 0.0), Vec3::Y),
+    ));
+}
+
+fn setup_physics(mut commands: Commands) {
+    /*
+     * Ground
+     */
+    let ground_size = 50.0;
+    let ground_height = 0.1;
+
+    commands.spawn((
+        Transform::from_xyz(0.0, -ground_height, 0.0),
+        Collider::cuboid(ground_size, ground_height, ground_size),
+    ));
+
+    /*
+     * Create the U-shaped bodies
+     */
+    let num = 4;
+    let numy = 10;
+    let rad = 0.2;
+
+    let shift = rad * 4.0 + rad;
+    let centerx = shift * (num / 2) as f32;
+    let centery = shift / 2.0;
+    let centerz = shift * (num / 2) as f32;
+
+    let mut offset = -(num as f32) * (rad * 2.0 + rad) * 0.5;
+    let blue = Hsla::hsl(220.0, 1.0, 0.3);
+    let orange = Hsla::hsl(30.0, 1.0, 0.5);
+
+    let parts = [
+        (Vec3::ZERO, Vec3::new(rad * 10.0, rad, rad)),
+        (
+            Vec3::new(rad * 10.0, rad * 10.0, 0.0),
+            Vec3::new(rad, rad * 10.0, rad),
+        ),
+        (
+            Vec3::new(-rad * 10.0, rad * 10.0, 0.0),
+            Vec3::new(rad, rad * 10.0, rad),
+        ),
+    ];
+
+    for j in 0usize..numy {
+        for i in 0..num {
+            for k in 0usize..num {
+                let x = i as f32 * shift * 5.0 - centerx + offset;
+                let y = j as f32 * (shift * 5.0) + centery + 3.0;
+                let z = k as f32 * shift * 2.0 - centerz + offset;
+                let mut body = commands.spawn((Transform::from_xyz(x, y, z), RigidBody::Dynamic));
+
+                if j < numy / 2 {
+                    // First option: attach several colliders to a single rigid-body.
+                    body.with_children(|children| {
+                        for (pos, half_extents) in parts {
+                            children.spawn((
+                                Transform::from_translation(pos),
+                                Collider::cuboid(half_extents.x, half_extents.y, half_extents.z),
+                                ColliderDebugColor(blue),
+                            ));
+                        }
+                    });
+                } else {
+                    // Second option: create a compound shape attached to a single collider.
+                    let shapes = parts
+                        .iter()
+                        .map(|(pos, half_extents)| {
+                            (
+                                *pos,
+                                Quat::IDENTITY,
+                                Collider::cuboid(half_extents.x, half_extents.y, half_extents.z),
+                            )
+                        })
+                        .collect();
+                    body.insert((Collider::compound(shapes), ColliderDebugColor(orange)));
+                }
+            }
+        }
+
+        offset -= 0.05 * rad * (num as f32 - 1.0);
+    }
+}
diff --git a/bindings/bevy_rapier/bevy_rapier3d/examples/contact_filter3.rs b/bindings/bevy_rapier/bevy_rapier3d/examples/contact_filter3.rs
new file mode 100644
index 000000000..92add4264
--- /dev/null
+++ b/bindings/bevy_rapier/bevy_rapier3d/examples/contact_filter3.rs
@@ -0,0 +1,101 @@
+use bevy::{ecs::system::SystemParam, prelude::*};
+use bevy_rapier3d::prelude::*;
+
+#[derive(PartialEq, Eq, Clone, Copy, Component)]
+enum CustomFilterTag {
+    GroupA,
+    GroupB,
+}
+
+// A custom filter that allows contacts only between rigid-bodies with the
+// same user_data value.
+// Note that using collision groups would be a more efficient way of doing
+// this, but we use custom filters instead for demonstration purpose.
+#[derive(SystemParam)]
+struct SameUserDataFilter<'w, 's> {
+    tags: Query<'w, 's, &'static CustomFilterTag>,
+}
+
+impl BevyPhysicsHooks for SameUserDataFilter<'_, '_> {
+    fn filter_contact_pair(&self, context: PairFilterContextView) -> Option<SolverFlags> {
+        if self.tags.get(context.collider1()).ok().copied()
+            == self.tags.get(context.collider2()).ok().copied()
+        {
+            Some(SolverFlags::COMPUTE_RIGID_IMPULSES)
+        } else {
+            None
+        }
+    }
+}
+
+fn main() {
+    App::new()
+        .insert_resource(ClearColor(Color::srgb(
+            0xF9 as f32 / 255.0,
+            0xF9 as f32 / 255.0,
+            0xFF as f32 / 255.0,
+        )))
+        .add_plugins((
+            DefaultPlugins,
+            RapierPhysicsPlugin::<SameUserDataFilter>::default(),
+            RapierDebugRenderPlugin::default(),
+        ))
+        .add_systems(Startup, (setup_graphics, setup_physics))
+        .run();
+}
+
+fn setup_graphics(mut commands: Commands) {
+    commands.spawn((
+        Camera3d::default(),
+        Transform::from_xyz(-30.0, 30.0, 100.0).looking_at(Vec3::new(0.0, 10.0, 0.0), Vec3::Y),
+    ));
+}
+
+pub fn setup_physics(mut commands: Commands) {
+    /*
+     * Ground
+     */
+    let ground_size = 10.0;
+
+    commands.spawn((
+        Transform::from_xyz(0.0, -10.0, 0.0),
+        Collider::cuboid(ground_size, 1.2, ground_size),
+        CustomFilterTag::GroupA,
+    ));
+
+    commands.spawn((
+        Transform::from_xyz(0.0, 0.0, 0.0),
+        Collider::cuboid(ground_size, 1.2, ground_size),
+        CustomFilterTag::GroupB,
+    ));
+
+    /*
+     * Create the cubes
+     */
+    let num = 4;
+    let rad = 0.5;
+
+    let shift = rad * 2.0;
+    let centerx = shift * (num as f32) / 2.0;
+    let centery = shift / 2.0;
+    let mut group_id = 0;
+    let tags = [CustomFilterTag::GroupA, CustomFilterTag::GroupB];
+    let colors = [Hsla::hsl(220.0, 1.0, 0.3), Hsla::hsl(260.0, 1.0, 0.7)];
+
+    for i in 0..num {
+        for j in 0usize..num * 5 {
+            let x = (i as f32 + j as f32 * 0.2) * shift - centerx;
+            let y = j as f32 * shift + centery + 2.0;
+            group_id += 1;
+
+            commands.spawn((
+                Transform::from_xyz(x, y, 0.0),
+                RigidBody::Dynamic,
+                Collider::cuboid(rad, rad, rad),
+                ActiveHooks::FILTER_CONTACT_PAIRS,
+                tags[group_id % 2],
+                ColliderDebugColor(colors[group_id % 2]),
+            ));
+        }
+    }
+}
diff --git a/bindings/bevy_rapier/bevy_rapier3d/examples/convex_decomposition3.rs b/bindings/bevy_rapier/bevy_rapier3d/examples/convex_decomposition3.rs
new file mode 100644
index 000000000..3744eac58
--- /dev/null
+++ b/bindings/bevy_rapier/bevy_rapier3d/examples/convex_decomposition3.rs
@@ -0,0 +1,212 @@
+//! Concave dynamic bodies approximated with `Collider::convex_decomposition`, falling on a
+//! wavy triangle mesh built with `TriMeshFlags::FIX_INTERNAL_EDGES`.
+//!
+//! The meshes are generated procedurally (a torus, a tube, and a star-shaped prism) instead of
+//! being loaded from files.
+
+use bevy::prelude::*;
+use bevy_rapier3d::prelude::*;
+use std::f32::consts::TAU;
+
+fn main() {
+    App::new()
+        .insert_resource(ClearColor(Color::srgb(
+            0xF9 as f32 / 255.0,
+            0xF9 as f32 / 255.0,
+            0xFF as f32 / 255.0,
+        )))
+        .add_plugins((
+            DefaultPlugins,
+            RapierPhysicsPlugin::<NoUserData>::default(),
+            RapierDebugRenderPlugin::default(),
+        ))
+        .add_systems(Startup, (setup_graphics, setup_physics))
+        .run();
+}
+
+fn setup_graphics(mut commands: Commands) {
+    commands.spawn((
+        Camera3d::default(),
+        Transform::from_xyz(40.0, 30.0, 40.0).looking_at(Vec3::ZERO, Vec3::Y),
+    ));
+}
+
+fn setup_physics(mut commands: Commands) {
+    /*
+     * Ground: a wavy triangle mesh.
+     */
+    let nsubdivs = 50;
+    let (vertices, indices) = grid_mesh(nsubdivs, Vec3::new(100.0, 2.0, 100.0), |i, j| {
+        let n = nsubdivs as f32;
+        -(i as f32 * 40.0 / n / 2.0).cos() - (j as f32 * 40.0 / n / 2.0).cos()
+    });
+    commands.spawn(
+        Collider::trimesh_with_flags(vertices, indices, TriMeshFlags::FIX_INTERNAL_EDGES).unwrap(),
+    );
+
+    /*
+     * Create the convex decompositions.
+     */
+    let meshes = [
+        torus_mesh(3.0, 1.0, 24, 12),
+        tube_mesh(3.5, 2.5, 4.0, 24),
+        star_prism_mesh(4.0, 1.8, 2.0, 5),
+    ];
+    let colors = [
+        Hsla::hsl(220.0, 1.0, 0.3),
+        Hsla::hsl(180.0, 1.0, 0.3),
+        Hsla::hsl(30.0, 1.0, 0.5),
+    ];
+    let num_duplications = 4;
+    let shift_xz = 10.0;
+
+    for (igeom, ((vertices, indices), color)) in meshes.into_iter().zip(colors).enumerate() {
+        info!("Decomposing mesh {igeom}.");
+        // The decomposition is computed once and shared by all the duplicates.
+        let collider = Collider::convex_decomposition(&vertices, &indices);
+
+        for k in 0..num_duplications {
+            let x = (igeom as f32 - 1.0) * shift_xz;
+            let z = (k as f32 - (num_duplications - 1) as f32 / 2.0) * shift_xz;
+            let rotation = Quat::from_rotation_x(0.3 * k as f32);
+
+            commands.spawn((
+                Transform::from_xyz(x, 10.0, z).with_rotation(rotation),
+                RigidBody::Dynamic,
+                collider.clone(),
+                ContactSkin(0.1),
+                ColliderDebugColor(color),
+            ));
+        }
+    }
+}
+
+/// A regular grid centered at the origin, with `height(i, j)` giving the height of each vertex.
+fn grid_mesh(
+    nsubdivs: usize,
+    scale: Vec3,
+    height: impl Fn(usize, usize) -> f32,
+) -> (Vec<Vec3>, Vec<[u32; 3]>) {
+    let n = nsubdivs as f32;
+    let vertices = (0..=nsubdivs)
+        .flat_map(|i| (0..=nsubdivs).map(move |j| (i, j)))
+        .map(|(i, j)| Vec3::new(i as f32 / n - 0.5, height(i, j), j as f32 / n - 0.5) * scale)
+        .collect();
+    let id = |i: usize, j: usize| (i * (nsubdivs + 1) + j) as u32;
+    let indices = (0..nsubdivs)
+        .flat_map(|i| (0..nsubdivs).map(move |j| (i, j)))
+        .flat_map(|(i, j)| {
+            [
+                [id(i, j), id(i, j + 1), id(i + 1, j)],
+                [id(i + 1, j), id(i, j + 1), id(i + 1, j + 1)],
+            ]
+        })
+        .collect();
+    (vertices, indices)
+}
+
+/// Quads connecting two closed loops of `n` vertices starting at `a` and `b`.
+fn loop_strip(indices: &mut Vec<[u32; 3]>, a: u32, b: u32, n: u32) {
+    for k in 0..n {
+        let k1 = (k + 1) % n;
+        indices.push([a + k, b + k, a + k1]);
+        indices.push([a + k1, b + k, b + k1]);
+    }
+}
+
+/// A torus lying on the XZ plane.
+fn torus_mesh(
+    major_radius: f32,
+    minor_radius: f32,
+    nu: u32,
+    nv: u32,
+) -> (Vec<Vec3>, Vec<[u32; 3]>) {
+    let mut vertices = vec![];
+    let mut indices = vec![];
+
+    for iu in 0..nu {
+        let (su, cu) = (iu as f32 / nu as f32 * TAU).sin_cos();
+        for iv in 0..nv {
+            let (sv, cv) = (iv as f32 / nv as f32 * TAU).sin_cos();
+            let r = major_radius + minor_radius * cv;
+            vertices.push(Vec3::new(r * cu, minor_radius * sv, r * su));
+        }
+    }
+
+    for iu in 0..nu {
+        loop_strip(&mut indices, iu * nv, ((iu + 1) % nu) * nv, nv);
+    }
+
+    (vertices, indices)
+}
+
+/// A vertical tube (a cylinder with a cylindrical hole) centered at the origin.
+fn tube_mesh(
+    outer_radius: f32,
+    inner_radius: f32,
+    height: f32,
+    n: u32,
+) -> (Vec<Vec3>, Vec<[u32; 3]>) {
+    // Four loops: outer bottom, outer top, inner top, inner bottom.
+    let loops = [
+        (outer_radius, -height / 2.0),
+        (outer_radius, height / 2.0),
+        (inner_radius, height / 2.0),
+        (inner_radius, -height / 2.0),
+    ];
+    let vertices = loops
+        .iter()
+        .flat_map(|(radius, y)| {
+            (0..n).map(move |k| {
+                let (s, c) = (k as f32 / n as f32 * TAU).sin_cos();
+                Vec3::new(radius * c, *y, radius * s)
+            })
+        })
+        .collect();
+
+    let mut indices = vec![];
+    for l in 0..4 {
+        loop_strip(&mut indices, l * n, ((l + 1) % 4) * n, n);
+    }
+
+    (vertices, indices)
+}
+
+/// A prism whose cross-section is a star with `num_branches` branches.
+fn star_prism_mesh(
+    outer_radius: f32,
+    inner_radius: f32,
+    height: f32,
+    num_branches: u32,
+) -> (Vec<Vec3>, Vec<[u32; 3]>) {
+    let n = num_branches * 2;
+    let mut vertices: Vec<Vec3> = [-height / 2.0, height / 2.0]
+        .into_iter()
+        .flat_map(|y| {
+            (0..n).map(move |k| {
+                let radius = if k % 2 == 0 {
+                    outer_radius
+                } else {
+                    inner_radius
+                };
+                let (s, c) = (k as f32 / n as f32 * TAU).sin_cos();
+                Vec3::new(radius * c, y, radius * s)
+            })
+        })
+        .collect();
+    let bottom_center = vertices.len() as u32;
+    vertices.push(Vec3::new(0.0, -height / 2.0, 0.0));
+    vertices.push(Vec3::new(0.0, height / 2.0, 0.0));
+    let top_center = bottom_center + 1;
+
+    let mut indices = vec![];
+    loop_strip(&mut indices, 0, n, n);
+    // The star is star-shaped with respect to its center, so its caps can be triangle fans.
+    for k in 0..n {
+        let k1 = (k + 1) % n;
+        indices.push([bottom_center, k, k1]);
+        indices.push([top_center, n + k1, n + k]);
+    }
+
+    (vertices, indices)
+}
diff --git a/bindings/bevy_rapier/bevy_rapier3d/examples/custom_system_setup3.rs b/bindings/bevy_rapier/bevy_rapier3d/examples/custom_system_setup3.rs
new file mode 100644
index 000000000..2fb61bd45
--- /dev/null
+++ b/bindings/bevy_rapier/bevy_rapier3d/examples/custom_system_setup3.rs
@@ -0,0 +1,120 @@
+use bevy::{diagnostic::FrameCount, prelude::*};
+use bevy_rapier3d::prelude::*;
+
+fn main() {
+    let mut app = App::new();
+
+    app.insert_resource(ClearColor(Color::srgb(
+        0xF9 as f32 / 255.0,
+        0xF9 as f32 / 255.0,
+        0xFF as f32 / 255.0,
+    )))
+    .add_plugins((
+        DefaultPlugins,
+        RapierPhysicsPlugin::<NoUserData>::default().with_default_system_setup(false),
+        RapierDebugRenderPlugin::default(),
+    ))
+    .add_systems(Startup, (setup_graphics, setup_physics));
+
+    app.configure_sets(
+        PostUpdate,
+        (
+            PhysicsSet::SyncBackend,
+            PhysicsSet::StepSimulation,
+            PhysicsSet::Writeback,
+        )
+            .chain()
+            .before(TransformSystems::Propagate),
+    );
+
+    app.add_systems(
+        PostUpdate,
+        (
+            RapierPhysicsPlugin::<NoUserData>::get_systems(PhysicsSet::SyncBackend)
+                .in_set(PhysicsSet::SyncBackend),
+            (
+                RapierPhysicsPlugin::<NoUserData>::get_systems(PhysicsSet::StepSimulation),
+                despawn_one_box,
+            )
+                .in_set(PhysicsSet::StepSimulation),
+            RapierPhysicsPlugin::<NoUserData>::get_systems(PhysicsSet::Writeback)
+                .in_set(PhysicsSet::Writeback),
+        ),
+    );
+
+    app.run();
+}
+
+fn despawn_one_box(
+    mut commands: Commands,
+    frame_count: ResMut<FrameCount>,
+    query: Query<Entity, (With<Collider>, With<RigidBody>)>,
+) {
+    // Delete a box every 5 frames
+    if frame_count.0.is_multiple_of(5) && !query.is_empty() {
+        let len = query.iter().len();
+        // Get a "random" box to make sim interesting
+        if let Some(entity) = query.iter().nth(frame_count.0 as usize % len) {
+            commands.entity(entity).despawn();
+        }
+    }
+}
+
+fn setup_graphics(mut commands: Commands) {
+    commands.spawn((
+        Camera3d::default(),
+        Transform::from_xyz(-30.0, 30.0, 100.0).looking_at(Vec3::new(0.0, 10.0, 0.0), Vec3::Y),
+    ));
+}
+
+pub fn setup_physics(mut commands: Commands) {
+    /*
+     * Ground
+     */
+    let ground_size = 200.1;
+    let ground_height = 0.1;
+
+    commands.spawn((
+        Transform::from_xyz(0.0, -ground_height, 0.0),
+        Collider::cuboid(ground_size, ground_height, ground_size),
+    ));
+
+    /*
+     * Create the cubes
+     */
+    let num = 8;
+    let rad = 1.0;
+
+    let shift = rad * 2.0 + rad;
+    let centerx = shift * (num / 2) as f32;
+    let centery = shift / 2.0;
+    let centerz = shift * (num / 2) as f32;
+
+    let mut offset = -(num as f32) * (rad * 2.0 + rad) * 0.5;
+    let mut color = 0;
+    let colors = [
+        Hsla::hsl(220.0, 1.0, 0.3),
+        Hsla::hsl(180.0, 1.0, 0.3),
+        Hsla::hsl(260.0, 1.0, 0.7),
+    ];
+
+    for j in 0usize..20 {
+        for i in 0..num {
+            for k in 0usize..num {
+                let x = i as f32 * shift - centerx + offset;
+                let y = j as f32 * shift + centery + 3.0;
+                let z = k as f32 * shift - centerz + offset;
+                color += 1;
+
+                commands.spawn((
+                    Transform::from_xyz(x, y, z),
+                    RigidBody::Dynamic,
+                    Collider::cuboid(rad, rad, rad),
+                    ColliderDebugColor(colors[color % 3]),
+                ));
+            }
+        }
+
+        offset -= 0.05 * rad * (num as f32 - 1.0);
+    }
+}
diff --git a/bindings/bevy_rapier/bevy_rapier3d/examples/debug_toggle3.rs b/bindings/bevy_rapier/bevy_rapier3d/examples/debug_toggle3.rs
new file mode 100644
index 000000000..78468750e
--- /dev/null
+++ b/bindings/bevy_rapier/bevy_rapier3d/examples/debug_toggle3.rs
@@ -0,0 +1,114 @@
+use std::time::Duration;
+
+pub use bevy::input::common_conditions::input_just_pressed;
+use bevy::prelude::*;
+use bevy_rapier3d::prelude::*;
+
+fn main() {
+    App::new()
+        .insert_resource(ClearColor(Color::srgb(
+            0xF9 as f32 / 255.0,
+            0xF9 as f32 / 255.0,
+            0xFF as f32 / 255.0,
+        )))
+        .add_plugins((
+            DefaultPlugins,
+            RapierPhysicsPlugin::<NoUserData>::default(),
+            RapierDebugRenderPlugin::default(),
+        ))
+        .add_systems(Startup, (setup_graphics, setup_physics))
+        .add_systems(
+            Update,
+            (
+                toggle_debug,
+                (|mut debug_render_context: ResMut<DebugRenderContext>| {
+                    debug_render_context.enabled = !debug_render_context.enabled;
+                })
+                .run_if(input_just_pressed(KeyCode::KeyV)),
+            ),
+        )
+        .run();
+}
+
+pub fn setup_graphics(mut commands: Commands) {
+    commands.spawn((
+        Camera3d::default(),
+        Transform::from_xyz(-30.0, 30.0, 100.0).looking_at(Vec3::new(0.0, 10.0, 0.0), Vec3::Y),
+    ));
+}
+
+#[derive(Component)]
+pub struct DebugCooldown(pub Timer);
+
+pub fn setup_physics(mut commands: Commands) {
+    /*
+     * Ground
+     */
+    let ground_size = 200.1;
+    let ground_height = 0.1;
+
+    commands.spawn((
+        Transform::from_xyz(0.0, -ground_height, 0.0),
+        Collider::cuboid(ground_size, ground_height, ground_size),
+    ));
+
+    /*
+     * Create the cubes
+     */
+    let num = 8;
+    let rad = 1.0;
+
+    let shift = rad * 2.0 + rad;
+    let centerx = shift * (num / 2) as f32;
+    let centery = shift / 2.0;
+    let centerz = shift * (num / 2) as f32;
+
+    let mut offset = -(num as f32) * (rad * 2.0 + rad) * 0.5;
+    let mut color = 0;
+    let colors = [
+        Hsla::hsl(220.0, 1.0, 0.3),
+        Hsla::hsl(180.0, 1.0, 0.3),
+        Hsla::hsl(260.0, 1.0, 0.7),
+    ];
+
+    for j in 0usize..20 {
+        for i in 0..num {
+            for k in 0usize..num {
+                let x = i as f32 * shift - centerx + offset;
+                let y = j as f32 * shift + centery + 3.0;
+                let z = k as f32 * shift - centerz + offset;
+                color += 1;
+
+                commands
+                    .spawn(Transform::from_rotation(Quat::from_rotation_x(0.2)))
+                    .with_children(|child| {
+                        child.spawn((
+                            Transform::from_xyz(x, y, z),
+                            RigidBody::Dynamic,
+                            Collider::cuboid(rad, rad, rad),
+                            ColliderDebugColor(colors[color % 3]),
+                            ColliderDebug::AlwaysRender,
+                            DebugCooldown(Timer::new(
+                                Duration::from_secs_f32(0.4f32 + (i % 3 + (j + 1) % 3) as f32),
+                                TimerMode::Repeating,
+                            )),
+                        ));
+                    });
+            }
+        }
+
+        offset -= 0.05 * rad * (num as f32 - 1.0);
+    }
+}
+
+pub fn toggle_debug(time: Res<Time>, mut query: Query<(&mut ColliderDebug, &mut DebugCooldown)>) {
+    for (mut debug, mut cooldown) in query.iter_mut() {
+        cooldown.0.tick(time.delta());
+        if cooldown.0.just_finished() {
+            *debug = match *debug {
+                ColliderDebug::AlwaysRender => ColliderDebug::NeverRender,
+                ColliderDebug::NeverRender => ColliderDebug::AlwaysRender,
+            }
+        }
+    }
+}
diff --git a/bindings/bevy_rapier/bevy_rapier3d/examples/despawn3.rs b/bindings/bevy_rapier/bevy_rapier3d/examples/despawn3.rs
new file mode 100644
index 000000000..b841e9737
--- /dev/null
+++ b/bindings/bevy_rapier/bevy_rapier3d/examples/despawn3.rs
@@ -0,0 +1,104 @@
+use bevy::prelude::*;
+use bevy_rapier3d::prelude::*;
+
+#[derive(Component)]
+pub struct Despawn;
+
+#[derive(Resource, Default)]
+pub struct DespawnResource {
+    timer: Timer,
+}
+
+fn main() {
+    App::new()
+        .insert_resource(ClearColor(Color::srgb(
+            0xF9 as f32 / 255.0,
+            0xF9 as f32 / 255.0,
+            0xFF as f32 / 255.0,
+        )))
+        .insert_resource(DespawnResource::default())
+        .add_plugins((
+            DefaultPlugins,
+            RapierPhysicsPlugin::<NoUserData>::default(),
+            RapierDebugRenderPlugin::default(),
+        ))
+        .add_systems(Startup, (setup_graphics, setup_physics))
+        .add_systems(Update, despawn)
+        .run();
+}
+
+pub fn setup_graphics(mut commands: Commands, mut res: ResMut<DespawnResource>) {
+    res.timer = Timer::from_seconds(5.0, TimerMode::Once);
+
+    commands.spawn((
+        Camera3d::default(),
+        Transform::from_xyz(-30.0, 30.0, 100.0).looking_at(Vec3::new(0.0, 10.0, 0.0), Vec3::Y),
+    ));
+}
+
+pub fn setup_physics(mut commands: Commands) {
+    /*
+     * Ground
+     */
+    let ground_size = 200.1;
+    let ground_height = 0.1;
+
+    commands.spawn((
+        Transform::from_xyz(0.0, -ground_height, 0.0),
+        Collider::cuboid(ground_size, ground_height, ground_size),
+        Despawn,
+    ));
+
+    /*
+     * Create the cubes
+     */
+    let num = 8;
+    let rad = 1.0;
+
+    let shift = rad * 2.0 + rad;
+    let centerx = shift * (num / 2) as f32;
+    let centery = shift / 2.0;
+    let centerz = shift * (num / 2) as f32;
+
+    let mut offset = -(num as f32) * (rad * 2.0 + rad) * 0.5;
+    let mut color = 0;
+    let colors = [
+        Hsla::hsl(220.0, 1.0, 0.3),
+        Hsla::hsl(180.0, 1.0, 0.3),
+        Hsla::hsl(260.0, 1.0, 0.7),
+    ];
+
+    for j in 0usize..20 {
+        for i in 0..num {
+            for k in 0usize..num {
+                let x = i as f32 * shift - centerx + offset;
+                let y = j as f32 * shift + centery + 3.0;
+                let z = k as f32 * shift - centerz + offset;
+                color += 1;
+
+                commands.spawn((
+                    Transform::from_xyz(x, y, z),
+                    RigidBody::Dynamic,
+                    Collider::cuboid(rad, rad, rad),
+                    ColliderDebugColor(colors[color % 3]),
+                ));
+            }
+        }
+
+        offset -= 0.05 * rad * (num as f32 - 1.0);
+    }
+}
+
+pub fn despawn(
+    mut commands: Commands,
+    time: Res<Time>,
+    mut despawn: ResMut<DespawnResource>,
+    query: Query<Entity, With<Despawn>>,
+) {
+    if despawn.timer.tick(time.delta()).is_finished() {
+        for entity in &query {
+            println!("Despawning ground entity");
+            commands.entity(entity).despawn();
+        }
+    }
+}
diff --git a/bindings/bevy_rapier/bevy_rapier3d/examples/diagnostics3.rs b/bindings/bevy_rapier/bevy_rapier3d/examples/diagnostics3.rs
new file mode 100644
index 000000000..a0b04fc1e
--- /dev/null
+++ b/bindings/bevy_rapier/bevy_rapier3d/examples/diagnostics3.rs
@@ -0,0 +1,83 @@
+//! Simulation statistics (step time, body, collider and contact counts) measured by
+//! `RapierDiagnosticsPlugin` and printed by Bevy's `LogDiagnosticsPlugin` on a pile of boxes.
+//!
+//! Enable the `profiler` feature to also get the timings of each stage of the physics pipeline.
+
+use bevy::{diagnostic::LogDiagnosticsPlugin, prelude::*};
+use bevy_rapier3d::prelude::*;
+
+fn main() {
+    App::new()
+        .insert_resource(ClearColor(Color::srgb(
+            0xF9 as f32 / 255.0,
+            0xF9 as f32 / 255.0,
+            0xFF as f32 / 255.0,
+        )))
+        .add_plugins((
+            DefaultPlugins,
+            RapierPhysicsPlugin::<NoUserData>::default(),
+            RapierDebugRenderPlugin::default(),
+            RapierDiagnosticsPlugin::default(),
+            // Prints every registered diagnostic once per second.
+            LogDiagnosticsPlugin::default(),
+        ))
+        .add_systems(Startup, (setup_graphics, setup_physics))
+        .run();
+}
+
+fn setup_graphics(mut commands: Commands) {
+    commands.spawn((
+        Camera3d::default(),
+        Transform::from_xyz(-30.0, 30.0, 60.0).looking_at(Vec3::new(0.0, 10.0, 0.0), Vec3::Y),
+    ));
+}
+
+fn setup_physics(mut commands: Commands) {
+    /*
+     * Ground
+     */
+    let ground_size = 100.0;
+    let ground_height = 0.1;
+
+    commands.spawn((
+        Transform::from_xyz(0.0, -ground_height, 0.0),
+        Collider::cuboid(ground_size, ground_height, ground_size),
+    ));
+
+    /*
+     * Create the cubes
+     */
+    let num = 8;
+    let rad = 1.0;
+
+    let shift = rad * 2.0 + rad;
+    let centerx = shift * (num / 2) as f32;
+    let centery = shift / 2.0;
+    let centerz = shift * (num / 2) as f32;
+
+    let mut offset = -(num as f32) * (rad * 2.0 + rad) * 0.5;
+    let colors = [
+        Hsla::hsl(220.0, 1.0, 0.3),
+        Hsla::hsl(180.0, 1.0, 0.3),
+        Hsla::hsl(260.0, 1.0, 0.7),
+    ];
+
+    for j in 0usize..10 {
+        for i in 0..num {
+            for k in 0usize..num {
+                let x = i as f32 * shift - centerx + offset;
+                let y = j as f32 * shift + centery + 3.0;
+                let z = k as f32 * shift - centerz + offset;
+
+                commands.spawn((
+                    Transform::from_xyz(x, y, z),
+                    RigidBody::Dynamic,
+                    Collider::cuboid(rad, rad, rad),
+                    ColliderDebugColor(colors[(i + j + k) % 3]),
+                ));
+            }
+        }
+
+        offset -= 0.05 * rad * (num as f32 - 1.0);
+    }
+}
diff --git a/bindings/bevy_rapier/bevy_rapier3d/examples/events3.rs b/bindings/bevy_rapier/bevy_rapier3d/examples/events3.rs
new file mode 100644
index 000000000..bd56214d2
--- /dev/null
+++ b/bindings/bevy_rapier/bevy_rapier3d/examples/events3.rs
@@ -0,0 +1,63 @@
+use bevy::prelude::*;
+use bevy_rapier3d::prelude::*;
+
+fn main() {
+    App::new()
+        .insert_resource(ClearColor(Color::srgb(
+            0xF9 as f32 / 255.0,
+            0xF9 as f32 / 255.0,
+            0xFF as f32 / 255.0,
+        )))
+        .add_plugins((
+            DefaultPlugins,
+            RapierPhysicsPlugin::<NoUserData>::default(),
+            RapierDebugRenderPlugin::default(),
+        ))
+        .add_systems(Startup, (setup_graphics, setup_physics))
+        .add_systems(PostUpdate, display_events)
+        .run();
+}
+
+pub fn setup_graphics(mut commands: Commands) {
+    commands.spawn((
+        Camera3d::default(),
+        Transform::from_xyz(0.0, 0.0, 25.0).looking_at(Vec3::ZERO, Vec3::Y),
+    ));
+}
+
+pub fn display_events(
+    mut collision_events: MessageReader<CollisionEvent>,
+    mut contact_force_events: MessageReader<ContactForceEvent>,
+) {
+    for collision_event in collision_events.read() {
+        println!("Received collision event: {collision_event:?}");
+    }
+
+    for contact_force_event in contact_force_events.read() {
+        println!("Received contact force event: {contact_force_event:?}");
+    }
+}
+
+pub fn setup_physics(mut commands: Commands) {
+    /*
+     * Ground
+     */
+    commands.spawn((
+        Transform::from_xyz(0.0, -1.2, 0.0),
+        Collider::cuboid(4.0, 1.0, 1.0),
+    ));
+
+    commands.spawn((
+        Transform::from_xyz(0.0, 5.0, 0.0),
+        Collider::cuboid(4.0, 1.5, 1.0),
+        Sensor,
+    ));
+
+    commands.spawn((
+        Transform::from_xyz(0.0, 13.0, 0.0),
+        RigidBody::Dynamic,
+        Collider::cuboid(0.5, 0.5, 0.5),
+        ActiveEvents::COLLISION_EVENTS,
+        ContactForceEventThreshold(30.0),
+    ));
+}
diff --git a/bindings/bevy_rapier/bevy_rapier3d/examples/gyroscopic3.rs b/bindings/bevy_rapier/bevy_rapier3d/examples/gyroscopic3.rs
new file mode 100644
index 000000000..bebbbe7fd
--- /dev/null
+++ b/bindings/bevy_rapier/bevy_rapier3d/examples/gyroscopic3.rs
@@ -0,0 +1,63 @@
+//! Gyroscopic forces toggled with the `GyroscopicForces` component, illustrated by the
+//! Dzhanibekov effect (<https://en.wikipedia.org/wiki/Tennis_racket_theorem>).
+//!
+//! Both bodies spin around their unstable intermediate axis. The left one (with gyroscopic
+//! forces) periodically flips, while the right one (without them) keeps spinning steadily.
+
+use bevy::prelude::*;
+use bevy_rapier3d::prelude::*;
+
+fn main() {
+    App::new()
+        .insert_resource(ClearColor(Color::srgb(
+            0xF9 as f32 / 255.0,
+            0xF9 as f32 / 255.0,
+            0xFF as f32 / 255.0,
+        )))
+        .add_plugins((
+            DefaultPlugins,
+            RapierPhysicsPlugin::<NoUserData>::default(),
+            RapierDebugRenderPlugin::default(),
+        ))
+        .add_systems(Startup, (setup_graphics, setup_physics))
+        .run();
+}
+
+fn setup_graphics(mut commands: Commands) {
+    commands.spawn((
+        Camera3d::default(),
+        Transform::from_xyz(0.0, 3.0, 12.0).looking_at(Vec3::ZERO, Vec3::Y),
+    ));
+}
+
+fn setup_physics(mut commands: Commands) {
+    let bodies = [
+        (
+            -3.0,
+            GyroscopicForces::enabled(),
+            Hsla::hsl(220.0, 1.0, 0.3),
+        ),
+        (3.0, GyroscopicForces::disabled(), Hsla::hsl(20.0, 1.0, 0.5)),
+    ];
+
+    for (x, gyroscopic_forces, color) in bodies {
+        let shapes = vec![
+            (Vec3::ZERO, Quat::IDENTITY, Collider::cuboid(2.0, 0.2, 0.2)),
+            (
+                Vec3::new(0.0, 0.8, 0.0),
+                Quat::IDENTITY,
+                Collider::cuboid(0.2, 0.4, 0.2),
+            ),
+        ];
+
+        commands.spawn((
+            Transform::from_xyz(x, 0.0, 0.0),
+            RigidBody::Dynamic,
+            Collider::compound(shapes),
+            GravityScale(0.0),
+            Velocity::angular(Vec3::new(0.0, 20.0, 0.1)),
+            gyroscopic_forces,
+            ColliderDebugColor(color),
+        ));
+    }
+}
diff --git a/bindings/bevy_rapier/bevy_rapier3d/examples/heightfield3.rs b/bindings/bevy_rapier/bevy_rapier3d/examples/heightfield3.rs
new file mode 100644
index 000000000..466b87e45
--- /dev/null
+++ b/bindings/bevy_rapier/bevy_rapier3d/examples/heightfield3.rs
@@ -0,0 +1,110 @@
+//! Various shapes falling on a heightfield built with `Collider::heightfield_with_flags` and
+//! `HeightFieldFlags::FIX_INTERNAL_EDGES` (preventing bumps at the triangle boundaries).
+
+use bevy::prelude::*;
+use bevy_rapier3d::prelude::*;
+
+fn main() {
+    App::new()
+        .insert_resource(ClearColor(Color::srgb(
+            0xF9 as f32 / 255.0,
+            0xF9 as f32 / 255.0,
+            0xFF as f32 / 255.0,
+        )))
+        .add_plugins((
+            DefaultPlugins,
+            RapierPhysicsPlugin::<NoUserData>::default(),
+            RapierDebugRenderPlugin::default(),
+        ))
+        .add_systems(Startup, (setup_graphics, setup_physics))
+        .run();
+}
+
+fn setup_graphics(mut commands: Commands) {
+    commands.spawn((
+        Camera3d::default(),
+        Transform::from_xyz(60.0, 60.0, 60.0).looking_at(Vec3::ZERO, Vec3::Y),
+    ));
+}
+
+fn setup_physics(mut commands: Commands) {
+    /*
+     * Ground
+     */
+    let ground_size = Vec3::new(100.0, 1.0, 100.0);
+    let nsubdivs = 20;
+    let num_rows = nsubdivs + 1;
+    let num_cols = nsubdivs + 1;
+
+    // The heights are given in column-major order, with raised borders to keep the shapes in.
+    let heights: Vec<f32> = (0..num_cols)
+        .flat_map(|j| (0..num_rows).map(move |i| (i, j)))
+        .map(|(i, j)| {
+            if i == 0 || i == nsubdivs || j == 0 || j == nsubdivs {
+                10.0
+            } else {
+                let x = i as f32 * ground_size.x / nsubdivs as f32;
+                let z = j as f32 * ground_size.z / nsubdivs as f32;
+                x.sin() + z.cos()
+            }
+        })
+        .collect();
+
+    commands.spawn(Collider::heightfield_with_flags(
+        heights,
+        num_rows,
+        num_cols,
+        ground_size,
+        HeightFieldFlags::FIX_INTERNAL_EDGES,
+    ));
+
+    /*
+     * Create the shapes
+     */
+    let num = 8;
+    let rad = 1.0;
+
+    let shift = rad * 2.0 + rad;
+    let centerx = shift * (num / 2) as f32;
+    let centery = shift / 2.0;
+    let centerz = shift * (num / 2) as f32;
+
+    for j in 0usize..6 {
+        for i in 0..num {
+            for k in 0usize..num {
+                let x = i as f32 * shift - centerx;
+                let y = j as f32 * shift + centery + 3.0;
+                let z = k as f32 * shift - centerz;
+
+                let collider = match j % 6 {
+                    0 => Collider::cuboid(rad, rad, rad),
+                    1 => Collider::ball(rad),
+                    // Rounded cylinders are much more efficient than cylinders, even if the
+                    // rounding margin is small.
+                    2 => Collider::round_cylinder(rad, rad, rad / 10.0),
+                    3 => Collider::cone(rad, rad),
+                    4 => Collider::capsule_y(rad, rad),
+                    _ => Collider::compound(vec![
+                        (
+                            Vec3::ZERO,
+                            Quat::IDENTITY,
+                            Collider::cuboid(rad, rad / 2.0, rad / 2.0),
+                        ),
+                        (
+                            Vec3::new(rad, 0.0, 0.0),
+                            Quat::IDENTITY,
+                            Collider::cuboid(rad / 2.0, rad, rad / 2.0),
+                        ),
+                        (
+                            Vec3::new(-rad, 0.0, 0.0),
+                            Quat::IDENTITY,
+                            Collider::cuboid(rad / 2.0, rad, rad / 2.0),
+                        ),
+                    ]),
+                };
+
+                commands.spawn((Transform::from_xyz(x, y, z), RigidBody::Dynamic, collider));
+            }
+        }
+    }
+}
diff --git a/bindings/bevy_rapier/bevy_rapier3d/examples/inverse_kinematics3.rs b/bindings/bevy_rapier/bevy_rapier3d/examples/inverse_kinematics3.rs
new file mode 100644
index 000000000..e40f6573e
--- /dev/null
+++ b/bindings/bevy_rapier/bevy_rapier3d/examples/inverse_kinematics3.rs
@@ -0,0 +1,136 @@
+//! Multibody inverse kinematics: the end of a chain of ten spherical multibody joints follows the
+//! mouse cursor projected on a camera-facing plane (or a circle while the cursor is outside of the
+//! window).
+
+use bevy::prelude::*;
+use bevy::window::PrimaryWindow;
+use bevy_rapier3d::prelude::*;
+
+fn main() {
+    App::new()
+        .insert_resource(ClearColor(Color::srgb(
+            0xF9 as f32 / 255.0,
+            0xF9 as f32 / 255.0,
+            0xFF as f32 / 255.0,
+        )))
+        .add_plugins((
+            DefaultPlugins,
+            RapierPhysicsPlugin::<NoUserData>::default(),
+            RapierDebugRenderPlugin::default(),
+        ))
+        .add_systems(Startup, (setup_graphics, setup_physics))
+        .add_systems(Update, (update_target, track_target).chain())
+        .run();
+}
+
+/// The last link of the chain, driven by the inverse kinematics solver.
+#[derive(Resource)]
+struct EndEffector(Entity);
+
+/// The world-space point the end effector tries to reach.
+#[derive(Resource, Default)]
+struct IkTarget(Vec3);
+
+pub fn setup_graphics(mut commands: Commands) {
+    commands.spawn((
+        Camera3d::default(),
+        Transform::from_xyz(0.0, 0.5, 2.5).looking_at(Vec3::new(0.0, 0.5, 0.0), Vec3::Y),
+    ));
+}
+
+pub fn setup_physics(mut commands: Commands) {
+    /*
+     * Ground.
+     */
+    let ground_size = 0.2;
+    let ground_height = 0.01;
+    commands.spawn((
+        Transform::from_xyz(0.0, -ground_height, 0.0),
+        Collider::cuboid(ground_size, ground_height, ground_size),
+    ));
+
+    /*
+     * The chain, attached to a fixed root with spherical multibody joints.
+     */
+    let num_segments = 10;
+    let size = 1.0 / num_segments as f32;
+    let mut last_body = commands
+        .spawn((Transform::default(), RigidBody::Fixed))
+        .id();
+
+    for i in 0..num_segments {
+        let joint = SphericalJointBuilder::new()
+            .local_anchor1(Vec3::new(0.0, if i == 0 { 0.0 } else { size / 2.0 }, 0.0))
+            .local_anchor2(Vec3::new(0.0, -size / 2.0, 0.0));
+
+        // The sensor collider is only here to let the debug-renderer draw the links.
+        last_body = commands
+            .spawn((
+                Transform::from_xyz(0.0, (i as f32 + 0.5) * size, 0.0),
+                RigidBody::Dynamic,
+                Sleeping::disabled(),
+                Collider::cuboid(size / 8.0, size / 2.0, size / 8.0),
+                ColliderMassProperties::Density(0.0),
+                Sensor,
+                MultibodyJoint::new(last_body, joint),
+            ))
+            .id();
+    }
+
+    commands.insert_resource(EndEffector(last_body));
+    commands.insert_resource(IkTarget::default());
+}
+
+/// Moves the target to the intersection between the mouse ray and the camera-facing plane
+/// passing through the origin, or along a circle if the cursor isn’t in the window.
+fn update_target(
+    time: Res<Time>,
+    window: Single<&Window, With<PrimaryWindow>>,
+    camera: Single<(&Camera, &GlobalTransform)>,
+    mut target: ResMut<IkTarget>,
+    mut gizmos: Gizmos,
+) {
+    let (camera, camera_transform) = *camera;
+    let plane = InfinitePlane3d::new(camera_transform.back());
+    let cursor = window
+        .cursor_position()
+        .and_then(|cursor| camera.viewport_to_world(camera_transform, cursor).ok())
+        .and_then(|ray| Some(ray.get_point(ray.intersect_plane(Vec3::ZERO, plane)?)));
+
+    target.0 = cursor.unwrap_or_else(|| {
+        let t = time.elapsed_secs();
+        Vec3::new(0.0, 0.5, 0.0) + 0.4 * Vec3::new(t.cos(), t.sin(), (0.5 * t).sin())
+    });
+    gizmos.sphere(
+        Isometry3d::from_translation(target.0),
+        0.02,
+        Color::srgb(0.9, 0.2, 0.2),
+    );
+}
+
+/// Runs the inverse kinematics solver on the chain and applies the resulting displacements.
+fn track_target(
+    mut context: WriteRapierContext,
+    end_effector: Res<EndEffector>,
+    target: Res<IkTarget>,
+    mut displacements: Local<Vec<f32>>,
+) -> Result<()> {
+    let options = InverseKinematicsOption {
+        constrained_axes: JointAxesMask::LIN_AXES,
+        ..Default::default()
+    };
+
+    // The displacements buffer is reset by the solver, so it can be reused across frames.
+    let mut context = context.single_mut()?;
+    if context.multibody_inverse_kinematics(
+        end_effector.0,
+        Transform::from_translation(target.0),
+        &options,
+        |_| true,
+        &mut displacements,
+    ) {
+        context.multibody_apply_displacements(end_effector.0, &displacements);
+    }
+
+    Ok(())
+}
diff --git a/bindings/bevy_rapier/bevy_rapier3d/examples/joint_motor_position3.rs b/bindings/bevy_rapier/bevy_rapier3d/examples/joint_motor_position3.rs
new file mode 100644
index 000000000..89282df0d
--- /dev/null
+++ b/bindings/bevy_rapier/bevy_rapier3d/examples/joint_motor_position3.rs
@@ -0,0 +1,116 @@
+//! Revolute joint motors without gravity: the bottom row uses position motors reaching increasing
+//! target angles, and the top row uses velocity motors stopped by increasing angular limits.
+//!
+//! The current and target angles of every joint are printed once per second.
+
+use std::f32::consts::PI;
+
+use bevy::prelude::*;
+use bevy::time::common_conditions::on_timer;
+use bevy_rapier3d::prelude::*;
+use std::time::Duration;
+
+fn main() {
+    App::new()
+        .insert_resource(ClearColor(Color::srgb(
+            0xF9 as f32 / 255.0,
+            0xF9 as f32 / 255.0,
+            0xFF as f32 / 255.0,
+        )))
+        .add_plugins((
+            DefaultPlugins,
+            RapierPhysicsPlugin::<NoUserData>::default(),
+            RapierDebugRenderPlugin::default(),
+        ))
+        .add_systems(Startup, (setup_graphics, setup_physics))
+        .add_systems(
+            Update,
+            print_joint_angles.run_if(on_timer(Duration::from_secs(1))),
+        )
+        .run();
+}
+
+/// The angle a joint motor is expected to settle at.
+#[derive(Component)]
+struct TargetAngle(f32);
+
+pub fn setup_graphics(mut commands: Commands) {
+    commands.spawn((
+        Camera3d::default(),
+        Transform::from_xyz(0.0, 3.5, 14.0).looking_at(Vec3::new(0.0, 3.5, 0.0), Vec3::Y),
+    ));
+}
+
+pub fn setup_physics(
+    mut commands: Commands,
+    mut rapier_config: Query<&mut RapierConfiguration>,
+) -> Result<()> {
+    rapier_config.single_mut()?.gravity = Vec3::ZERO;
+
+    /*
+     * Fixed ground to attach one end of the joints.
+     */
+    let ground = commands
+        .spawn((Transform::default(), RigidBody::Fixed))
+        .id();
+
+    /*
+     * Rectangles on motors with a target position.
+     */
+    for num in 0..9 {
+        let x_pos = -6.0 + 1.5 * num as f32;
+        let target_angle = -PI + PI / 4.0 * num as f32;
+        let joint = RevoluteJointBuilder::new(Vec3::Z)
+            .local_anchor1(Vec3::new(x_pos, 1.5, 0.0))
+            .local_anchor2(Vec3::new(0.0, -0.5, 0.0))
+            .motor_position(target_angle, 1000.0, 150.0);
+
+        commands.spawn((
+            Transform::from_xyz(x_pos, 2.0, 0.0),
+            RigidBody::Dynamic,
+            Sleeping::disabled(),
+            Collider::cuboid(0.1, 0.5, 0.1),
+            ImpulseJoint::new(ground, joint),
+            TargetAngle(target_angle),
+        ));
+    }
+
+    /*
+     * Rectangles on velocity motors, stopped by their limits.
+     */
+    for num in 0..8 {
+        let x_pos = -6.0 + 1.5 * num as f32;
+        let max_angle_limit = -PI + PI / 4.0 * num as f32;
+        let joint = RevoluteJointBuilder::new(Vec3::Z)
+            .local_anchor1(Vec3::new(x_pos, 5.0, 0.0))
+            .local_anchor2(Vec3::new(0.0, -0.5, 0.0))
+            .motor_velocity(1.5, 30.0)
+            .motor_max_force(100.0)
+            .limits([-PI, max_angle_limit]);
+
+        commands.spawn((
+            Transform::from_xyz(x_pos, 4.5, 0.0).with_rotation(Quat::from_rotation_z(PI)),
+            RigidBody::Dynamic,
+            Sleeping::disabled(),
+            Collider::cuboid(0.1, 0.5, 0.1),
+            ImpulseJoint::new(ground, joint),
+            TargetAngle(max_angle_limit),
+        ));
+    }
+
+    Ok(())
+}
+
+fn print_joint_angles(
+    context: ReadRapierContext,
+    joints: Query<(Entity, &TargetAngle), With<ImpulseJoint>>,
+) -> Result<()> {
+    let context = context.single()?;
+    for (entity, target) in &joints {
+        if let Some(angle) = context.impulse_revolute_joint_angle(entity) {
+            println!("{entity}: rev angle: {angle:.3} (target = {:.3})", target.0);
+        }
+    }
+
+    Ok(())
+}
diff --git a/bindings/bevy_rapier/bevy_rapier3d/examples/joint_softness3.rs b/bindings/bevy_rapier/bevy_rapier3d/examples/joint_softness3.rs
new file mode 100644
index 000000000..e7818d189
--- /dev/null
+++ b/bindings/bevy_rapier/bevy_rapier3d/examples/joint_softness3.rs
@@ -0,0 +1,131 @@
+//! Joint softness: chains of balls linked by spherical impulse joints, from the default (rigid)
+//! softness on the left to increasingly soft joints on the right, which stretch like bungee cords.
+//!
+//! Press Space to toggle the `ImpulseJointDisabled` component on the joints attaching each chain
+//! to its anchor: disabled joints are ignored by the solver, and re-enabled joints pull their chain
+//! back up.
+
+use bevy::prelude::*;
+use bevy_rapier3d::prelude::*;
+
+/// The number of balls of each chain.
+const NUM_BALLS: usize = 6;
+/// The radius of each ball.
+const BALL_RADIUS: f32 = 0.25;
+/// The rest distance between two consecutive balls.
+const LINK_LENGTH: f32 = 0.8;
+/// The height of the fixed anchors of the chains.
+const ANCHOR_HEIGHT: f32 = 8.0;
+
+fn main() {
+    App::new()
+        .insert_resource(ClearColor(Color::srgb(
+            0xF9 as f32 / 255.0,
+            0xF9 as f32 / 255.0,
+            0xFF as f32 / 255.0,
+        )))
+        .add_plugins((
+            DefaultPlugins,
+            RapierPhysicsPlugin::<NoUserData>::default(),
+            RapierDebugRenderPlugin::default(),
+        ))
+        .add_systems(Startup, (setup_graphics, setup_physics))
+        .add_systems(Update, toggle_joints)
+        .run();
+}
+
+/// Marker for the joints attaching the chains to their anchors, toggled with Space.
+#[derive(Component)]
+struct TopJoint;
+
+pub fn setup_graphics(mut commands: Commands) {
+    commands.spawn((
+        Camera3d::default(),
+        Transform::from_xyz(0.0, 5.0, 16.0).looking_at(Vec3::new(0.0, 4.0, 0.0), Vec3::Y),
+    ));
+    commands.spawn((
+        Text::new(
+            "Joint softness, left to right: default, 20 Hz, 12 Hz, 8 Hz, 6 Hz\n\
+             Space: toggle the top joints",
+        ),
+        Node {
+            position_type: PositionType::Absolute,
+            top: Val::Px(12.0),
+            left: Val::Px(12.0),
+            ..default()
+        },
+        TextColor(Color::BLACK),
+    ));
+}
+
+pub fn setup_physics(mut commands: Commands) {
+    /*
+     * Ground.
+     */
+    commands.spawn((
+        Transform::from_xyz(0.0, -0.1, 0.0),
+        Collider::cuboid(10.0, 0.1, 3.0),
+    ));
+
+    /*
+     * One chain per softness. The natural frequency of the joint constraints controls how fast
+     * they resolve their errors: lower frequencies give softer joints.
+     */
+    let softnesses = [
+        SpringCoefficients::joint_defaults(),
+        SpringCoefficients::new(20.0, 1.0),
+        SpringCoefficients::new(12.0, 1.0),
+        SpringCoefficients::new(8.0, 1.0),
+        SpringCoefficients::new(6.0, 1.0),
+    ];
+
+    for (k, softness) in softnesses.into_iter().enumerate() {
+        let x = (k as f32 - (softnesses.len() - 1) as f32 * 0.5) * 3.0;
+        let mut prev = commands
+            .spawn((
+                Transform::from_xyz(x, ANCHOR_HEIGHT, 0.0),
+                RigidBody::Fixed,
+                Collider::cuboid(0.2, 0.2, 0.2),
+            ))
+            .id();
+
+        for i in 1..=NUM_BALLS {
+            let joint = SphericalJointBuilder::new()
+                .local_anchor1(Vec3::new(0.0, -LINK_LENGTH / 2.0, 0.0))
+                .local_anchor2(Vec3::new(0.0, LINK_LENGTH / 2.0, 0.0))
+                .softness(softness);
+
+            let mut ball = commands.spawn((
+                Transform::from_xyz(x, ANCHOR_HEIGHT - i as f32 * LINK_LENGTH, 0.0),
+                RigidBody::Dynamic,
+                Collider::ball(BALL_RADIUS),
+                ImpulseJoint::new(prev, joint),
+            ));
+
+            if i == 1 {
+                ball.insert(TopJoint);
+            }
+
+            prev = ball.id();
+        }
+    }
+}
+
+/// Toggles the `ImpulseJointDisabled` component of the top joints when Space is pressed.
+fn toggle_joints(
+    mut commands: Commands,
+    keys: Res<ButtonInput<KeyCode>>,
+    joints: Query<(Entity, Has<ImpulseJointDisabled>), With<TopJoint>>,
+) {
+    if !keys.just_pressed(KeyCode::Space) {
+        return;
+    }
+
+    for (entity, disabled) in &joints {
+        if disabled {
+            commands.entity(entity).remove::<ImpulseJointDisabled>();
+        } else {
+            commands.entity(entity).insert(ImpulseJointDisabled);
+        }
+    }
+}
diff --git a/bindings/bevy_rapier/bevy_rapier3d/examples/joints3.rs b/bindings/bevy_rapier/bevy_rapier3d/examples/joints3.rs
new file mode 100644
index 000000000..a07d9fcc3
--- /dev/null
+++ b/bindings/bevy_rapier/bevy_rapier3d/examples/joints3.rs
@@ -0,0 +1,296 @@
+use std::time::Duration;
+
+use bevy::{prelude::*, time::common_conditions::once_after_delay};
+use bevy_rapier3d::prelude::*;
+
+fn main() {
+    App::new()
+        .insert_resource(ClearColor(Color::srgb(
+            0xF9 as f32 / 255.0,
+            0xF9 as f32 / 255.0,
+            0xFF as f32 / 255.0,
+        )))
+        .add_plugins((
+            DefaultPlugins,
+            RapierPhysicsPlugin::<NoUserData>::default(),
+            RapierDebugRenderPlugin::default(),
+        ))
+        .add_systems(Startup, (setup_graphics, setup_physics))
+        .add_systems(
+            Last,
+            (print_impulse_revolute_joints,)
+                .run_if(once_after_delay(Duration::from_secs_f32(1f32))),
+        )
+        .run();
+}
+
+pub fn setup_graphics(mut commands: Commands) {
+    commands.spawn((
+        Camera3d::default(),
+        Transform::from_xyz(15.0, 5.0, 42.0).looking_at(Vec3::new(13.0, 1.0, 1.0), Vec3::Y),
+    ));
+}
+
+fn create_prismatic_joints(commands: &mut Commands, origin: Vect, num: usize) {
+    let rad = 0.4;
+    let shift = 1.0;
+
+    let mut curr_parent = commands
+        .spawn((
+            Transform::from_xyz(origin.x, origin.y, origin.z),
+            RigidBody::Fixed,
+            Collider::cuboid(rad, rad, rad),
+        ))
+        .id();
+
+    for i in 0..num {
+        let dz = (i + 1) as f32 * shift;
+
+        let axis = if i.is_multiple_of(2) {
+            Vec3::new(1.0, 1.0, 0.0)
+        } else {
+            Vec3::new(-1.0, 1.0, 0.0)
+        };
+
+        let prism = PrismaticJointBuilder::new(axis)
+            .local_anchor2(Vec3::new(0.0, 0.0, -shift))
+            .limits([-2.0, 2.0]);
+        let joint = ImpulseJoint::new(curr_parent, prism);
+
+        curr_parent = commands
+            .spawn((
+                Transform::from_xyz(origin.x, origin.y, origin.z + dz),
+                RigidBody::Dynamic,
+                Collider::cuboid(rad, rad, rad),
+                joint,
+            ))
+            .id();
+    }
+}
+
+fn create_rope_joints(commands: &mut Commands, origin: Vect, num: usize) {
+    let rad = 0.4;
+    let shift = 1.0;
+
+    let mut curr_parent = commands
+        .spawn((
+            Transform::from_xyz(origin.x, origin.y, origin.z),
+            RigidBody::Fixed,
+            Collider::cuboid(rad, rad, rad),
+        ))
+        .id();
+
+    for i in 0..num {
+        let dz = (i + 1) as f32 * shift;
+
+        let rope = RopeJointBuilder::new(2.0).local_anchor2(Vec3::new(0.0, 0.0, -shift));
+        let joint = ImpulseJoint::new(curr_parent, rope);
+
+        curr_parent = commands
+            .spawn((
+                Transform::from_xyz(origin.x, origin.y, origin.z + dz),
+                RigidBody::Dynamic,
+                Collider::cuboid(rad, rad, rad),
+                joint,
+            ))
+            .id();
+    }
+}
+
+fn create_revolute_joints(commands: &mut Commands, origin: Vec3, num: usize) {
+    let rad = 0.4;
+    let shift = 2.0;
+
+    let mut curr_parent = commands
+        .spawn((
+            Transform::from_xyz(origin.x, origin.y, 0.0),
+            RigidBody::Fixed,
+            Collider::cuboid(rad, rad, rad),
+        ))
+        .id();
+
+    for i in 0..num {
+        // Create four bodies.
+        let z = origin.z + i as f32 * shift * 2.0 + shift;
+        let positions = [
+            Vec3::new(origin.x, origin.y, z),
+            Vec3::new(origin.x + shift, origin.y, z),
+            Vec3::new(origin.x + shift, origin.y, z + shift),
+            Vec3::new(origin.x, origin.y, z + shift),
+        ];
+
+        let mut handles = [curr_parent; 4];
+        for k in 0..4 {
+            handles[k] = commands
+                .spawn((
+                    Transform::from_translation(positions[k]),
+                    RigidBody::Dynamic,
+                    Collider::cuboid(rad, rad, rad),
+                ))
+                .id();
+        }
+
+        // Setup four joints.
+        let x = Vec3::X;
+        let z = Vec3::Z;
+
+        let revs = [
+            RevoluteJointBuilder::new(z).local_anchor2(Vec3::new(0.0, 0.0, -shift)),
+            RevoluteJointBuilder::new(x).local_anchor2(Vec3::new(-shift, 0.0, 0.0)),
+            RevoluteJointBuilder::new(z).local_anchor2(Vec3::new(0.0, 0.0, -shift)),
+            RevoluteJointBuilder::new(x).local_anchor2(Vec3::new(shift, 0.0, 0.0)),
+        ];
+        commands
+            .entity(handles[0])
+            .insert(ImpulseJoint::new(curr_parent, revs[0]));
+        commands
+            .entity(handles[1])
+            .insert(ImpulseJoint::new(handles[0], revs[1]));
+        commands
+            .entity(handles[2])
+            .insert(ImpulseJoint::new(handles[1], revs[2]));
+        commands
+            .entity(handles[3])
+            .insert(ImpulseJoint::new(handles[2], revs[3]));
+
+        curr_parent = handles[3];
+    }
+}
+
+fn create_fixed_joints(commands: &mut Commands, origin: Vec3, num: usize) {
+    let rad = 0.4;
+    let shift = 1.0;
+
+    let mut body_entities = Vec::new();
+
+    for k in 0..num {
+        for i in 0..num {
+            let fk = k as f32;
+            let fi = i as f32;
+
+            // NOTE: the num - 2 test is to avoid two consecutive
+            // fixed bodies. Because physx will crash if we add
+            // a joint between these.
+            let rigid_body = if i == 0 && (k.is_multiple_of(4) && k != num - 2 || k == num - 1) {
+                RigidBody::Fixed
+            } else {
+                RigidBody::Dynamic
+            };
+
+            let child_entity = commands
+                .spawn((
+                    Transform::from_xyz(origin.x + fk * shift, origin.y, origin.z + fi * shift),
+                    rigid_body,
+                    Collider::ball(rad),
+                ))
+                .id();
+
+            // Vertical joint.
+            if i > 0 {
+                let parent_entity = *body_entities.last().unwrap();
+                let joint = FixedJointBuilder::new().local_anchor2(Vec3::new(0.0, 0.0, -shift));
+                commands.entity(child_entity).with_children(|children| {
+                    // NOTE: we want to attach multiple impulse joints to this entity, so
+                    //       we need to add the components to children of the entity. Otherwise
+                    //       the second joint component would just overwrite the first one.
+                    children.spawn(ImpulseJoint::new(parent_entity, joint));
+                });
+            }
+
+            // Horizontal joint.
+            if k > 0 {
+                let parent_index = body_entities.len() - num;
+                let parent_entity = body_entities[parent_index];
+                let joint = FixedJointBuilder::new().local_anchor2(Vec3::new(-shift, 0.0, 0.0));
+                commands.entity(child_entity).with_children(|children| {
+                    // NOTE: we want to attach multiple impulse joints to this entity, so
+                    //       we need to add the components to children of the entity. Otherwise
+                    //       the second joint component would just overwrite the first one.
+                    children.spawn(ImpulseJoint::new(parent_entity, joint));
+                });
+            }
+
+            body_entities.push(child_entity);
+        }
+    }
+}
+
+fn create_ball_joints(commands: &mut Commands, num: usize) {
+    let rad = 0.4;
+    let shift = 1.0;
+
+    let mut body_entities = Vec::new();
+
+    for k in 0..num {
+        for i in 0..num {
+            let fk = k as f32;
+            let fi = i as f32;
+
+            let rigid_body = if i == 0 && (k.is_multiple_of(4) || k == num - 1) {
+                RigidBody::Fixed
+            } else {
+                RigidBody::Dynamic
+            };
+
+            let child_entity = commands
+                .spawn((
+                    Transform::from_xyz(fk * shift, 0.0, fi * shift),
+                    rigid_body,
+                    Collider::ball(rad),
+                ))
+                .id();
+
+            // Vertical joint.
+            if i > 0 {
+                let parent_entity = *body_entities.last().unwrap();
+                let joint = SphericalJointBuilder::new().local_anchor2(Vec3::new(0.0, 0.0, -shift));
+                commands.entity(child_entity).with_children(|children| {
+                    // NOTE: we want to attach multiple impulse joints to this entity, so
+                    //       we need to add the components to children of the entity. Otherwise
+                    //       the second joint component would just overwrite the first one.
+                    children.spawn(ImpulseJoint::new(parent_entity, joint));
+                });
+            }
+
+            // Horizontal joint.
+            if k > 0 {
+                let parent_index = body_entities.len() - num;
+                let parent_entity = body_entities[parent_index];
+                let joint = SphericalJointBuilder::new().local_anchor2(Vec3::new(-shift, 0.0, 0.0));
+                commands.entity(child_entity).with_children(|children| {
+                    // NOTE: we want to attach multiple impulse joints to this entity, so
+                    //       we need to add the components to children of the entity. Otherwise
+                    //       the second joint component would just overwrite the first one.
+                    children.spawn(ImpulseJoint::new(parent_entity, joint));
+                });
+            }
+
+            body_entities.push(child_entity);
+        }
+    }
+}
+
+pub fn setup_physics(mut commands: Commands) {
+    create_prismatic_joints(&mut commands, Vec3::new(20.0, 10.0, 0.0), 5);
+    create_revolute_joints(&mut commands, Vec3::new(20.0, 0.0, 0.0), 3);
+    create_fixed_joints(&mut commands, Vec3::new(0.0, 10.0, 0.0), 5);
+    create_rope_joints(&mut commands, Vec3::new(30.0, 10.0, 0.0), 5);
+    create_ball_joints(&mut commands, 15);
+}
+
+pub fn print_impulse_revolute_joints(
+    context: ReadRapierContext,
+    joints: Query<(Entity, &ImpulseJoint)>,
+) -> Result<()> {
+    for (entity, impulse_joint) in joints.iter() {
+        if let TypedJoint::RevoluteJoint(_revolute_joint) = &impulse_joint.data {
+            println!(
+                "angle for {}: {:?}",
+                entity,
+                context.single()?.impulse_revolute_joint_angle(entity),
+            );
+        }
+    }
+
+    Ok(())
+}
diff --git a/bindings/bevy_rapier/bevy_rapier3d/examples/joints_despawn3.rs b/bindings/bevy_rapier/bevy_rapier3d/examples/joints_despawn3.rs
new file mode 100644
index 000000000..573f4a362
--- /dev/null
+++ b/bindings/bevy_rapier/bevy_rapier3d/examples/joints_despawn3.rs
@@ -0,0 +1,282 @@
+use bevy::prelude::*;
+use bevy_rapier3d::prelude::*;
+
+#[derive(Component)]
+pub struct Despawn;
+
+#[derive(Resource, Default)]
+pub struct DespawnResource {
+    timer: Timer,
+}
+
+fn main() {
+    App::new()
+        .insert_resource(ClearColor(Color::srgb(
+            0xF9 as f32 / 255.0,
+            0xF9 as f32 / 255.0,
+            0xFF as f32 / 255.0,
+        )))
+        .insert_resource(DespawnResource::default())
+        .add_plugins((
+            DefaultPlugins,
+            RapierPhysicsPlugin::<NoUserData>::default(),
+            RapierDebugRenderPlugin::default(),
+        ))
+        .add_systems(Startup, (setup_graphics, setup_physics))
+        .add_systems(Update, despawn)
+        .run();
+}
+
+pub fn setup_graphics(mut commands: Commands, mut res: ResMut<DespawnResource>) {
+    res.timer = Timer::from_seconds(5.0, TimerMode::Once);
+
+    commands.spawn((
+        Camera3d::default(),
+        Transform::from_xyz(15.0, 5.0, 42.0).looking_at(Vec3::new(13.0, 1.0, 1.0), Vec3::Y),
+    ));
+}
+
+fn create_prismatic_joints(commands: &mut Commands, origin: Vect, num: usize) {
+    let rad = 0.4;
+    let shift = 1.0;
+
+    let mut curr_parent = commands
+        .spawn((
+            Transform::from_xyz(origin.x, origin.y, origin.z),
+            RigidBody::Fixed,
+            Collider::cuboid(rad, rad, rad),
+        ))
+        .id();
+
+    for i in 0..num {
+        let dz = (i + 1) as f32 * shift;
+
+        let axis = if i.is_multiple_of(2) {
+            Vec3::new(1.0, 1.0, 0.0)
+        } else {
+            Vec3::new(-1.0, 1.0, 0.0)
+        };
+
+        let prism = PrismaticJointBuilder::new(axis)
+            .local_anchor2(Vec3::new(0.0, 0.0, -shift))
+            .limits([-2.0, 2.0]);
+        let joint = ImpulseJoint::new(curr_parent, prism);
+
+        let mut entity = commands.spawn((
+            Transform::from_xyz(origin.x, origin.y, origin.z + dz),
+            RigidBody::Dynamic,
+            Collider::cuboid(rad, rad, rad),
+            joint,
+        ));
+
+        curr_parent = entity.id();
+
+        if i == 2 {
+            entity.insert(Despawn);
+        }
+    }
+}
+
+fn create_revolute_joints(commands: &mut Commands, origin: Vec3, num: usize) {
+    let rad = 0.4;
+    let shift = 2.0;
+
+    let mut curr_parent = commands
+        .spawn((
+            Transform::from_xyz(origin.x, origin.y, 0.0),
+            RigidBody::Fixed,
+            Collider::cuboid(rad, rad, rad),
+        ))
+        .id();
+
+    for i in 0..num {
+        // Create four bodies.
+        let z = origin.z + i as f32 * shift * 2.0 + shift;
+        let positions = [
+            Vec3::new(origin.x, origin.y, z),
+            Vec3::new(origin.x + shift, origin.y, z),
+            Vec3::new(origin.x + shift, origin.y, z + shift),
+            Vec3::new(origin.x, origin.y, z + shift),
+        ];
+
+        let mut handles = [curr_parent; 4];
+        for k in 0..4 {
+            handles[k] = commands
+                .spawn((
+                    Transform::from_translation(positions[k]),
+                    RigidBody::Dynamic,
+                    Collider::cuboid(rad, rad, rad),
+                ))
+                .id();
+        }
+
+        // Setup four joints.
+        let x = Vec3::X;
+        let z = Vec3::Z;
+
+        let revs = [
+            RevoluteJointBuilder::new(z).local_anchor2(Vec3::new(0.0, 0.0, -shift)),
+            RevoluteJointBuilder::new(x).local_anchor2(Vec3::new(-shift, 0.0, 0.0)),
+            RevoluteJointBuilder::new(z).local_anchor2(Vec3::new(0.0, 0.0, -shift)),
+            RevoluteJointBuilder::new(x).local_anchor2(Vec3::new(shift, 0.0, 0.0)),
+        ];
+
+        commands
+            .entity(handles[0])
+            .insert(ImpulseJoint::new(curr_parent, revs[0]));
+        commands
+            .entity(handles[1])
+            .insert(ImpulseJoint::new(handles[0], revs[1]));
+        commands
+            .entity(handles[2])
+            .insert(ImpulseJoint::new(handles[1], revs[2]));
+        commands
+            .entity(handles[3])
+            .insert(ImpulseJoint::new(handles[2], revs[3]));
+
+        curr_parent = handles[3];
+
+        if i == 1 {
+            for e in handles {
+                commands.entity(e).insert(Despawn);
+            }
+        }
+    }
+}
+
+fn create_fixed_joints(commands: &mut Commands, origin: Vec3, num: usize) {
+    let rad = 0.4;
+    let shift = 1.0;
+
+    let mut body_entities = Vec::new();
+
+    for k in 0..num {
+        for i in 0..num {
+            let fk = k as f32;
+            let fi = i as f32;
+
+            // NOTE: the num - 2 test is to avoid two consecutive
+            // fixed bodies. Because physx will crash if we add
+            // a joint between these.
+            let rigid_body = if i == 0 && (k.is_multiple_of(4) && k != num - 2 || k == num - 1) {
+                RigidBody::Fixed
+            } else {
+                RigidBody::Dynamic
+            };
+
+            let child_entity = commands
+                .spawn((
+                    Transform::from_xyz(origin.x + fk * shift, origin.y, origin.z + fi * shift),
+                    rigid_body,
+                    Collider::ball(rad),
+                ))
+                .id();
+
+            // Vertical joint.
+            if i > 0 {
+                let parent_entity = *body_entities.last().unwrap();
+                let joint = FixedJointBuilder::new().local_anchor2(Vec3::new(0.0, 0.0, -shift));
+                commands.entity(child_entity).with_children(|children| {
+                    // NOTE: we want to attach multiple impulse joints to this entity, so
+                    //       we need to add the components to children of the entity. Otherwise
+                    //       the second joint component would just overwrite the first one.
+                    children.spawn(ImpulseJoint::new(parent_entity, joint));
+                });
+            }
+
+            // Horizontal joint.
+            if k > 0 {
+                let parent_index = body_entities.len() - num;
+                let parent_entity = body_entities[parent_index];
+                let joint = FixedJointBuilder::new().local_anchor2(Vec3::new(-shift, 0.0, 0.0));
+                commands.entity(child_entity).with_children(|children| {
+                    // NOTE: we want to attach multiple impulse joints to this entity, so
+                    //       we need to add the components to children of the entity. Otherwise
+                    //       the second joint component would just overwrite the first one.
+                    children.spawn((ImpulseJoint::new(parent_entity, joint), Despawn));
+                });
+            }
+
+            body_entities.push(child_entity);
+        }
+    }
+}
+
+fn create_ball_joints(commands: &mut Commands, num: usize) {
+    let rad = 0.4;
+    let shift = 1.0;
+
+    let mut body_entities = Vec::new();
+
+    for k in 0..num {
+        for i in 0..num {
+            let fk = k as f32;
+            let fi = i as f32;
+
+            let rigid_body = if i == 0 && (k.is_multiple_of(4) || k == num - 1) {
+                RigidBody::Fixed
+            } else {
+                RigidBody::Dynamic
+            };
+
+            let child_entity = commands
+                .spawn((
+                    Transform::from_xyz(fk * shift, 0.0, fi * shift),
+                    rigid_body,
+                    Collider::ball(rad),
+                ))
+                .id();
+
+            // Vertical joint.
+            if i > 0 {
+                let parent_entity = *body_entities.last().unwrap();
+                let joint = SphericalJointBuilder::new().local_anchor2(Vec3::new(0.0, 0.0, -shift));
+                commands.entity(child_entity).with_children(|children| {
+                    // NOTE: we want to attach multiple impulse joints to this entity, so
+                    //       we need to add the components to children of the entity. Otherwise
+                    //       the second joint component would just overwrite the first one.
+                    let mut entity = children.spawn(ImpulseJoint::new(parent_entity, joint));
+                    if i == 2 {
+                        entity.insert(Despawn);
+                    }
+                });
+            }
+
+            // Horizontal joint.
+            if k > 0 {
+                let parent_index = body_entities.len() - num;
+                let parent_entity = body_entities[parent_index];
+                let joint = SphericalJointBuilder::new().local_anchor2(Vec3::new(-shift, 0.0, 0.0));
+                commands.entity(child_entity).with_children(|children| {
+                    // NOTE: we want to attach multiple impulse joints to this entity, so
+                    //       we need to add the components to children of the entity. Otherwise
+                    //       the second joint component would just overwrite the first one.
+                    children.spawn(ImpulseJoint::new(parent_entity, joint));
+                });
+            }
+
+            body_entities.push(child_entity);
+        }
+    }
+}
+
+pub fn setup_physics(mut commands: Commands) {
+    create_prismatic_joints(&mut commands, Vec3::new(20.0, 10.0, 0.0), 5);
+    create_revolute_joints(&mut commands, Vec3::new(20.0, 0.0, 0.0), 3);
+    create_fixed_joints(&mut commands, Vec3::new(0.0, 10.0, 0.0), 5);
+    create_ball_joints(&mut commands, 15);
+}
+
+pub fn despawn(
+    mut commands: Commands,
+    time: Res<Time>,
+    mut despawn: ResMut<DespawnResource>,
+    query: Query<Entity, With<Despawn>>,
+) {
+    if despawn.timer.tick(time.delta()).is_finished() {
+        for entity in &query {
+            println!("Despawning joint entity");
+            commands.entity(entity).despawn();
+        }
+    }
+}
diff --git a/bindings/bevy_rapier/bevy_rapier3d/examples/locked_rotations3.rs b/bindings/bevy_rapier/bevy_rapier3d/examples/locked_rotations3.rs
new file mode 100644
index 000000000..a4feab941
--- /dev/null
+++ b/bindings/bevy_rapier/bevy_rapier3d/examples/locked_rotations3.rs
@@ -0,0 +1,60 @@
+use bevy::prelude::*;
+use bevy_rapier3d::prelude::*;
+
+fn main() {
+    App::new()
+        .insert_resource(ClearColor(Color::srgb(
+            0xF9 as f32 / 255.0,
+            0xF9 as f32 / 255.0,
+            0xFF as f32 / 255.0,
+        )))
+        .add_plugins((
+            DefaultPlugins,
+            RapierPhysicsPlugin::<NoUserData>::default(),
+            RapierDebugRenderPlugin::default(),
+        ))
+        .add_systems(Startup, (setup_graphics, setup_physics))
+        .run();
+}
+
+pub fn setup_graphics(mut commands: Commands) {
+    commands.spawn((
+        Camera3d::default(),
+        Transform::from_xyz(10.0, 3.0, 0.0).looking_at(Vec3::new(0.0, 3.0, 0.0), Vec3::Y),
+    ));
+}
+
+pub fn setup_physics(mut commands: Commands) {
+    /*
+     * The ground
+     */
+    let ground_size = 5.0;
+    let ground_height = 0.1;
+
+    commands.spawn((
+        Transform::from_xyz(0.0, -ground_height, 0.0),
+        Collider::cuboid(ground_size, ground_height, ground_size),
+    ));
+
+    /*
+     * A rectangle that only rotates along the `x` axis.
+     */
+    commands.spawn((
+        Transform::from_xyz(0.0, 3.0, 0.0),
+        RigidBody::Dynamic,
+        LockedAxes::TRANSLATION_LOCKED
+            | LockedAxes::ROTATION_LOCKED_Y
+            | LockedAxes::ROTATION_LOCKED_Z,
+        Collider::cuboid(0.2, 0.6, 2.0),
+    ));
+
+    /*
+     * A tilted cuboid that cannot rotate.
+     */
+    commands.spawn((
+        Transform::from_xyz(0.0, 5.0, 0.0).with_rotation(Quat::from_rotation_x(1.0)),
+        RigidBody::Dynamic,
+        LockedAxes::ROTATION_LOCKED,
+        Collider::cuboid(0.6, 0.4, 0.4),
+    ));
+}
diff --git a/bindings/bevy_rapier/bevy_rapier3d/examples/mjcf3.rs b/bindings/bevy_rapier/bevy_rapier3d/examples/mjcf3.rs
new file mode 100644
index 000000000..48948b080
--- /dev/null
+++ b/bindings/bevy_rapier/bevy_rapier3d/examples/mjcf3.rs
@@ -0,0 +1,85 @@
+//! Spawns a MuJoCo MJCF scene (an actuated cart-pole, a double pendulum and a few free bodies)
+//! with multibody joints, and drives its actuators.
+
+use std::f32::consts::FRAC_PI_2;
+
+use bevy::prelude::*;
+use bevy_rapier3d::loaders::mjcf::{
+    spawn_mjcf_model, MjcfActuator, MjcfLoaderOptions, MjcfPhysicsHooks, MjcfPlugin, MjcfRobot,
+    MjcfSpawnOptions,
+};
+use bevy_rapier3d::prelude::*;
+
+fn main() {
+    App::new()
+        .insert_resource(ClearColor(Color::srgb(
+            0xF9 as f32 / 255.0,
+            0xF9 as f32 / 255.0,
+            0xFF as f32 / 255.0,
+        )))
+        .add_plugins((
+            DefaultPlugins,
+            // The hooks apply the `<contact>` rules of the model.
+            RapierPhysicsPlugin::<MjcfPhysicsHooks>::default(),
+            RapierDebugRenderPlugin::default(),
+            // Applies the actuator controls to the joints.
+            MjcfPlugin::default(),
+        ))
+        .add_systems(Startup, (setup_graphics, setup_physics))
+        .add_systems(Update, drive_actuators)
+        .run();
+}
+
+fn setup_graphics(mut commands: Commands) {
+    commands.spawn((
+        Camera3d::default(),
+        Transform::from_xyz(0.5, 1.5, 4.0).looking_at(Vec3::new(0.0, 1.0, -0.5), Vec3::Y),
+    ));
+}
+
+fn setup_physics(
+    mut commands: Commands,
+    mut configuration: Query<&mut RapierConfiguration>,
+) -> Result {
+    // The model's floor plane is skipped by the loader, so add our own.
+    commands.spawn((
+        Transform::from_xyz(0.0, -0.1, 0.0),
+        Collider::cuboid(5.0, 0.1, 5.0),
+    ));
+
+    let path = concat!(env!("CARGO_MANIFEST_DIR"), "/assets/robots/cart_pole.xml");
+    let (robot, _) = MjcfRobot::from_file(path, MjcfLoaderOptions::default())
+        .expect("Failed to load the MJCF file.");
+    let model = spawn_mjcf_model(
+        &mut commands,
+        &robot,
+        &MjcfSpawnOptions {
+            // MJCF files are Z-up.
+            root_transform: Transform::from_rotation(Quat::from_rotation_x(-FRAC_PI_2)),
+            ..default()
+        },
+    );
+    info!(
+        "Spawned `{}` with {} bodies, {} joints and {} actuators.",
+        robot.name.as_deref().unwrap_or_default(),
+        model.bodies.iter().flatten().count(),
+        model.joints.iter().flatten().count(),
+        model.actuators.len()
+    );
+
+    // Use the gravity declared by the model (expressed in the Y-up frame).
+    configuration.single_mut()?.gravity = model.gravity;
+    Ok(())
+}
+
+/// Moves the cart back and forth, and swings the elbow servo of the double pendulum.
+fn drive_actuators(time: Res<Time>, mut actuators: Query<(&Name, &mut MjcfActuator)>) {
+    let t = time.elapsed_secs();
+    for (name, mut actuator) in actuators.iter_mut() {
+        match name.as_str() {
+            "cart_motor" => actuator.ctrl = (t * 1.5).sin(),
+            "elbow_servo" => actuator.ctrl = 1.2 * (t * 0.7).sin(),
+            _ => {}
+        }
+    }
+}
diff --git a/bindings/bevy_rapier/bevy_rapier3d/examples/multi_contexts3.rs b/bindings/bevy_rapier/bevy_rapier3d/examples/multi_contexts3.rs
new file mode 100644
index 000000000..16a31d59b
--- /dev/null
+++ b/bindings/bevy_rapier/bevy_rapier3d/examples/multi_contexts3.rs
@@ -0,0 +1,121 @@
+use bevy::{input::common_conditions::input_just_pressed, prelude::*};
+use bevy_rapier3d::prelude::*;
+
+const N_CONTEXTS: usize = 2;
+
+fn main() {
+    App::new()
+        .insert_resource(ClearColor(Color::srgb(
+            0xF9 as f32 / 255.0,
+            0xF9 as f32 / 255.0,
+            0xFF as f32 / 255.0,
+        )))
+        .add_plugins((
+            DefaultPlugins,
+            RapierPhysicsPlugin::<NoUserData>::default()
+                .with_custom_initialization(RapierContextInitialization::NoAutomaticRapierContext),
+            RapierDebugRenderPlugin::default(),
+        ))
+        .add_systems(
+            Startup,
+            ((create_contexts, setup_physics).chain(), setup_graphics),
+        )
+        .add_systems(Update, move_platforms)
+        .add_systems(
+            Update,
+            change_context.run_if(input_just_pressed(KeyCode::KeyC)),
+        )
+        .run();
+}
+
+fn create_contexts(mut commands: Commands) {
+    for i in 0..N_CONTEXTS {
+        let mut context = commands.spawn((RapierContextSimulation::default(), ContextId(i)));
+        if i == 0 {
+            context.insert((DefaultRapierContext, RapierContextSimulation::default()));
+        }
+    }
+}
+
+fn setup_graphics(mut commands: Commands) {
+    commands.spawn((
+        Camera3d::default(),
+        Transform::from_xyz(0.0, 3.0, -10.0).looking_at(Vec3::new(0.0, 0.0, 0.0), Vec3::Y),
+    ));
+}
+
+#[derive(Component)]
+pub struct ContextId(pub usize);
+
+#[derive(Component)]
+struct Platform {
+    starting_y: f32,
+}
+
+fn move_platforms(time: Res<Time>, mut query: Query<(&mut Transform, &Platform)>) {
+    for (mut transform, platform) in query.iter_mut() {
+        transform.translation.y = platform.starting_y + -time.elapsed_secs().sin();
+    }
+}
+
+/// Demonstrates how easy it is to move one entity to another context.
+fn change_context(
+    query_context: Query<Entity, With<DefaultRapierContext>>,
+    mut query_links: Query<(Entity, &mut RapierContextEntityLink)>,
+) -> Result<()> {
+    let default_context = query_context.single()?;
+    for (e, mut link) in query_links.iter_mut() {
+        if link.0 == default_context {
+            continue;
+        }
+        link.0 = default_context;
+        println!("changing context of {} for context {}", e, link.0);
+    }
+
+    Ok(())
+}
+
+pub fn setup_physics(
+    context: Query<(Entity, &ContextId), With<RapierContextSimulation>>,
+    mut commands: Commands,
+) {
+    for (context_entity, id) in context.iter() {
+        let id = id.0;
+
+        let color = [
+            Hsla::hsl(220.0, 1.0, 0.3),
+            Hsla::hsl(180.0, 1.0, 0.3),
+            Hsla::hsl(260.0, 1.0, 0.7),
+        ][id % 3];
+
+        /*
+         * Ground
+         */
+        let ground_size = 5.1;
+        let ground_height = 0.1;
+
+        let starting_y = (id as f32) * -0.5 - ground_height;
+
+        let mut platforms = commands.spawn((
+            Transform::from_xyz(0.0, starting_y, 0.0),
+            Collider::cuboid(ground_size, ground_height, ground_size),
+            ColliderDebugColor(color),
+            RapierContextEntityLink(context_entity),
+        ));
+        if id == 1 {
+            platforms.insert(Platform { starting_y });
+        }
+
+        /*
+         * Create the cube
+         */
+
+        commands.spawn((
+            Transform::from_xyz(0.0, 1.0 + id as f32 * 5.0, 0.0),
+            RigidBody::Dynamic,
+            Collider::cuboid(0.5, 0.5, 0.5),
+            ColliderDebugColor(color),
+            RapierContextEntityLink(context_entity),
+        ));
+    }
+}
diff --git a/bindings/bevy_rapier/bevy_rapier3d/examples/multibody_joints3.rs b/bindings/bevy_rapier/bevy_rapier3d/examples/multibody_joints3.rs
new file mode 100644
index 000000000..4fb7a2206
--- /dev/null
+++ b/bindings/bevy_rapier/bevy_rapier3d/examples/multibody_joints3.rs
@@ -0,0 +1,228 @@
+//! Multibody joints in 3D: a grid of capsule chains built from spherical multibody joints (tied
+//! together with impulse joints) falling on a tilted plate, and a row of revolute multibody chains
+//! showcasing `MultibodyJointDamping`, `MultibodyJointFriction`, `MultibodyJointSprings`,
+//! `MultibodyJointArmature` and a `KinematicMultibodyJoint` spinning its chain around the vertical
+//! axis.
+
+use bevy::prelude::*;
+use bevy_rapier3d::prelude::*;
+
+/// Half the length of the segments of the showcase chains.
+const HALF_LENGTH: f32 = 0.5;
+/// The number of segments of each showcase chain.
+const SEGMENTS: usize = 4;
+/// The angular velocity of the kinematic joints, in radians per second.
+const KINEMATIC_SPEED: f32 = 2.0;
+
+fn main() {
+    App::new()
+        .insert_resource(ClearColor(Color::srgb(
+            0xF9 as f32 / 255.0,
+            0xF9 as f32 / 255.0,
+            0xFF as f32 / 255.0,
+        )))
+        .add_plugins((
+            DefaultPlugins,
+            RapierPhysicsPlugin::<NoUserData>::default(),
+            RapierDebugRenderPlugin::default(),
+        ))
+        .add_systems(Startup, (setup_graphics, setup_physics))
+        .add_systems(Update, drive_kinematic_joints)
+        .run();
+}
+
+/// The multibody joint option showcased by a chain.
+#[derive(Copy, Clone)]
+enum ChainKind {
+    Default,
+    Damping,
+    Friction,
+    Springs,
+    Armature,
+    Kinematic,
+}
+
+pub fn setup_graphics(mut commands: Commands) {
+    commands.spawn((
+        Camera3d::default(),
+        Transform::from_xyz(15.0, 8.0, 42.0).looking_at(Vec3::new(13.0, 3.0, 1.0), Vec3::Y),
+    ));
+    commands.spawn((
+        Text::new(
+            "Upper chains, left to right: default joints, damping, friction, springs,\n\
+             armature, kinematic first joint",
+        ),
+        Node {
+            position_type: PositionType::Absolute,
+            top: Val::Px(12.0),
+            left: Val::Px(12.0),
+            ..default()
+        },
+        TextColor(Color::BLACK),
+    ));
+}
+
+pub fn setup_physics(mut commands: Commands) {
+    /*
+     * A dynamic plate resting on a fixed tilted ground.
+     */
+    let tilt = Quat::from_scaled_axis(Vec3::new(0.1, 0.0, 0.1));
+    commands.spawn((
+        Transform::from_xyz(0.0, -3.02, 0.0).with_rotation(tilt),
+        Collider::cuboid(30.0, 0.01, 30.0),
+    ));
+    commands.spawn((
+        Transform::from_xyz(0.0, -3.0, 0.0).with_rotation(tilt),
+        RigidBody::Dynamic,
+        Collider::cuboid(30.0, 0.01, 30.0),
+    ));
+
+    create_ball_articulations(&mut commands, 8);
+
+    /*
+     * The showcase chains.
+     */
+    let kinds = [
+        ChainKind::Default,
+        ChainKind::Damping,
+        ChainKind::Friction,
+        ChainKind::Springs,
+        ChainKind::Armature,
+        ChainKind::Kinematic,
+    ];
+    for (i, kind) in kinds.into_iter().enumerate() {
+        let base_pos = Vec3::new(-4.0 + 7.0 * i as f32, 12.0, 0.0);
+        create_showcase_chain(&mut commands, base_pos, kind);
+    }
+}
+
+/// A grid of capsules: each column is a multibody built with spherical joints, and neighboring
+/// columns are tied together with spherical impulse joints.
+fn create_ball_articulations(commands: &mut Commands, num: usize) {
+    let rad = 0.4;
+    let shift = 1.0;
+
+    let mut body_entities = Vec::new();
+
+    for k in 0..num {
+        for i in 0..num {
+            let fk = k as f32;
+            let fi = i as f32;
+
+            let rigid_body = if i == 0 {
+                RigidBody::Fixed
+            } else {
+                RigidBody::Dynamic
+            };
+
+            let mut body = commands.spawn((
+                Transform::from_xyz(fk * shift, 0.0, fi * shift * 2.0),
+                rigid_body,
+                Collider::capsule_z(rad * 1.25, rad),
+            ));
+
+            // Vertical multibody joint.
+            if i > 0 {
+                let parent = *body_entities.last().unwrap();
+                let joint =
+                    SphericalJointBuilder::new().local_anchor2(Vec3::new(0.0, 0.0, -shift * 2.0));
+                body.insert(MultibodyJoint::new(parent, joint));
+            }
+
+            // Horizontal impulse joint. It can live on the same entity as the multibody joint
+            // since they are different components.
+            if k > 0 && i > 0 {
+                let parent = body_entities[body_entities.len() - num];
+                let joint = SphericalJointBuilder::new().local_anchor2(Vec3::new(-shift, 0.0, 0.0));
+                body.insert(ImpulseJoint::new(parent, joint));
+            }
+
+            body_entities.push(body.id());
+        }
+    }
+}
+
+/// A horizontal chain of revolute multibody joints, configured according to `kind`.
+fn create_showcase_chain(commands: &mut Commands, base_pos: Vec3, kind: ChainKind) {
+    let mut prev = commands
+        .spawn((
+            Transform::from_translation(base_pos),
+            RigidBody::Fixed,
+            Collider::ball(0.2),
+            ColliderDebugColor(Hsla::hsl(0.0, 0.0, 0.2)),
+        ))
+        .id();
+
+    for i in 0..SEGMENTS {
+        let center = base_pos + Vec3::X * (2.0 * i as f32 + 1.0) * HALF_LENGTH;
+        let anchor1 = if i == 0 {
+            Vec3::ZERO
+        } else {
+            Vec3::X * HALF_LENGTH
+        };
+        // The kinematic chain spins around the vertical axis, the others swing around Z.
+        let axis = if matches!(kind, ChainKind::Kinematic) && i == 0 {
+            Vec3::Y
+        } else {
+            Vec3::Z
+        };
+        let joint = RevoluteJointBuilder::new(axis)
+            .local_anchor1(anchor1)
+            .local_anchor2(-Vec3::X * HALF_LENGTH)
+            .contacts_enabled(false);
+
+        let mut segment = commands.spawn((
+            Transform::from_translation(center),
+            RigidBody::Dynamic,
+            Sleeping::disabled(),
+            Collider::capsule_x(HALF_LENGTH, 0.1),
+            MultibodyJoint::new(prev, joint),
+        ));
+
+        // The free rotational degree of freedom of a revolute joint is `JointAxis::AngX`, mapped
+        // to the joint axis.
+        match kind {
+            ChainKind::Default => {}
+            ChainKind::Damping => {
+                segment.insert(MultibodyJointDamping::default().with(JointAxis::AngX, 0.3));
+            }
+            ChainKind::Friction => {
+                // The largest torque the friction can apply to stop each joint.
+                segment.insert(MultibodyJointFriction::default().with(JointAxis::AngX, 0.5));
+            }
+            ChainKind::Springs => {
+                // Pull each joint back towards its initial (straight) configuration.
+                segment.insert(MultibodyJointSprings::default().with(JointAxis::AngX, 3.0, 0.0));
+            }
+            ChainKind::Armature => {
+                // Extra rotor inertia makes each joint react more slowly.
+                segment.insert(MultibodyJointArmature::default().with(JointAxis::AngX, 1.0));
+            }
+            ChainKind::Kinematic => {
+                // Only the first joint is kinematic: it is driven by `drive_kinematic_joints`.
+                if i == 0 {
+                    segment.insert(KinematicMultibodyJoint);
+                }
+            }
+        }
+
+        prev = segment.id();
+    }
+}
+
+/// Sets the velocity of the kinematic joints, which the physics engine never modifies.
+fn drive_kinematic_joints(
+    mut context: WriteRapierContext,
+    joints: Query<Entity, With<KinematicMultibodyJoint>>,
+) -> Result<()> {
+    let mut context = context.single_mut()?;
+
+    for entity in &joints {
+        // This is `None` until the joint is inserted into the physics scene.
+        if let Some(velocity) = context.multibody_joint_velocity_mut(entity) {
+            velocity[0] = KINEMATIC_SPEED;
+        }
+    }
+
+    Ok(())
+}
diff --git a/bindings/bevy_rapier/bevy_rapier3d/examples/multiple_colliders3.rs b/bindings/bevy_rapier/bevy_rapier3d/examples/multiple_colliders3.rs
new file mode 100644
index 000000000..7ef45c725
--- /dev/null
+++ b/bindings/bevy_rapier/bevy_rapier3d/examples/multiple_colliders3.rs
@@ -0,0 +1,90 @@
+use bevy::prelude::*;
+use bevy_rapier3d::prelude::*;
+
+fn main() {
+    App::new()
+        .insert_resource(ClearColor(Color::srgb(
+            0xF9 as f32 / 255.0,
+            0xF9 as f32 / 255.0,
+            0xFF as f32 / 255.0,
+        )))
+        .add_plugins((
+            DefaultPlugins,
+            RapierPhysicsPlugin::<NoUserData>::default(),
+            RapierDebugRenderPlugin::default(),
+        ))
+        .add_systems(Startup, (setup_graphics, setup_physics))
+        .run();
+}
+
+pub fn setup_graphics(mut commands: Commands) {
+    commands.spawn((
+        Camera3d::default(),
+        Transform::from_xyz(-30.0, 30.0, 100.0).looking_at(Vec3::new(0.0, 10.0, 0.0), Vec3::Y),
+    ));
+}
+
+pub fn setup_physics(mut commands: Commands) {
+    /*
+     * Ground
+     */
+    let ground_size = 50.0;
+    let ground_height = 0.1;
+
+    commands.spawn((
+        Transform::from_xyz(0.0, -ground_height, 0.0),
+        Collider::cuboid(ground_size, ground_height, ground_size),
+    ));
+
+    /*
+     * Create the cubes
+     */
+    let num = 4;
+    let rad = 0.2;
+
+    let shift = rad * 4.0 + rad;
+    let centerx = shift * (num / 2) as f32;
+    let centery = shift / 2.0;
+    let centerz = shift * (num / 2) as f32;
+
+    let mut offset = -(num as f32) * (rad * 2.0 + rad) * 0.5;
+    let mut color = 0;
+    let colors = [
+        Hsla::hsl(220.0, 1.0, 0.3),
+        Hsla::hsl(180.0, 1.0, 0.3),
+        Hsla::hsl(260.0, 1.0, 0.7),
+    ];
+
+    for j in 0usize..20 {
+        for i in 0..num {
+            for k in 0usize..num {
+                let x = i as f32 * shift * 5.0 - centerx + offset;
+                let y = j as f32 * (shift * 5.0) + centery + 3.0;
+                let z = k as f32 * shift * 2.0 - centerz + offset;
+                color += 1;
+
+                // Crate a rigid-body with multiple colliders attached, using Bevy hierarchy.
+                commands
+                    .spawn((Transform::from_xyz(x, y, z), RigidBody::Dynamic))
+                    .with_children(|children| {
+                        children.spawn((
+                            Collider::cuboid(rad * 10.0, rad, rad),
+                            ColliderDebugColor(colors[color % 3]),
+                        ));
+                        children.spawn((
+                            Transform::from_xyz(rad * 10.0, rad * 10.0, 0.0),
+                            Collider::cuboid(rad, rad * 10.0, rad),
+                            ColliderDebugColor(colors[color % 3]),
+                        ));
+                        children.spawn((
+                            Transform::from_xyz(-rad * 10.0, rad * 10.0, 0.0),
+                            Collider::cuboid(rad, rad * 10.0, rad),
+                            ColliderDebugColor(colors[color % 3]),
+                        ));
+                    });
+            }
+        }
+
+        offset -= 0.05 * rad * (num as f32 - 1.0);
+    }
+}
diff --git a/bindings/bevy_rapier/bevy_rapier3d/examples/one_way_platforms3.rs b/bindings/bevy_rapier/bevy_rapier3d/examples/one_way_platforms3.rs
new file mode 100644
index 000000000..86bfb49ec
--- /dev/null
+++ b/bindings/bevy_rapier/bevy_rapier3d/examples/one_way_platforms3.rs
@@ -0,0 +1,123 @@
+//! One-way platforms and conveyor belts implemented with `BevyPhysicsHooks` and
+//! `ContactModificationContextView::update_as_oneway_platform`.
+
+use bevy::{ecs::system::SystemParam, prelude::*};
+use bevy_rapier3d::prelude::*;
+
+const MAX_CUBES: usize = 7;
+
+/// A platform only solid for contacts whose normal (in the platform's local-space) is close to
+/// `allowed_normal`, and moving what lies on it at `surface_speed` along the Z axis.
+#[derive(Component, Copy, Clone)]
+struct OneWayPlatform {
+    allowed_normal: Vec3,
+    surface_speed: f32,
+}
+
+#[derive(Component)]
+struct Cube;
+
+#[derive(SystemParam)]
+struct OneWayPlatformHook<'w, 's> {
+    platforms: Query<'w, 's, &'static OneWayPlatform>,
+}
+
+impl BevyPhysicsHooks for OneWayPlatformHook<'_, '_> {
+    fn modify_solver_contacts(&self, mut context: ContactModificationContextView) {
+        // The manifold normal points outward from the first collider, so the allowed direction
+        // and the surface velocity are flipped if the platform is the second collider.
+        let (platform, sign) = if let Ok(platform) = self.platforms.get(context.collider1()) {
+            (platform, 1.0)
+        } else if let Ok(platform) = self.platforms.get(context.collider2()) {
+            (platform, -1.0)
+        } else {
+            return;
+        };
+
+        context.update_as_oneway_platform(platform.allowed_normal * sign, 0.1);
+
+        if let Some(contacts) = context.solver_contacts_mut() {
+            for contact in contacts.iter_mut() {
+                contact.tangent_velocity.z = platform.surface_speed * sign;
+            }
+        }
+    }
+}
+
+fn main() {
+    App::new()
+        .insert_resource(ClearColor(Color::srgb(
+            0xF9 as f32 / 255.0,
+            0xF9 as f32 / 255.0,
+            0xFF as f32 / 255.0,
+        )))
+        .add_plugins((
+            DefaultPlugins,
+            RapierPhysicsPlugin::<OneWayPlatformHook>::default(),
+            RapierDebugRenderPlugin::default(),
+        ))
+        .add_systems(Startup, (setup_graphics, setup_physics))
+        .add_systems(Update, (spawn_cubes, flip_gravity))
+        .run();
+}
+
+fn setup_graphics(mut commands: Commands) {
+    commands.spawn((
+        Camera3d::default(),
+        Transform::from_xyz(100.0, 0.0, 0.0).looking_at(Vec3::ZERO, Vec3::Y),
+    ));
+}
+
+fn setup_physics(mut commands: Commands) {
+    // The first platform can be landed on from above, the second one from below.
+    commands.spawn((
+        Transform::from_xyz(0.0, 2.0, 30.0),
+        Collider::cuboid(9.0, 0.5, 25.0),
+        ActiveHooks::MODIFY_SOLVER_CONTACTS,
+        OneWayPlatform {
+            allowed_normal: Vec3::Y,
+            surface_speed: -12.0,
+        },
+    ));
+    commands.spawn((
+        Transform::from_xyz(0.0, -2.0, -30.0),
+        Collider::cuboid(9.0, 0.5, 25.0),
+        ActiveHooks::MODIFY_SOLVER_CONTACTS,
+        OneWayPlatform {
+            allowed_normal: -Vec3::Y,
+            surface_speed: 12.0,
+        },
+    ));
+}
+
+fn spawn_cubes(
+    mut commands: Commands,
+    time: Res<Time>,
+    mut timer: Local<Option<Timer>>,
+    cubes: Query<(), With<Cube>>,
+) {
+    let timer = timer.get_or_insert_with(|| Timer::from_seconds(3.0, TimerMode::Repeating));
+    timer.tick(time.delta());
+
+    if timer.just_finished() && cubes.iter().count() < MAX_CUBES {
+        commands.spawn((
+            Transform::from_xyz(0.0, 6.0, 20.0),
+            RigidBody::Dynamic,
+            Collider::cuboid(1.0, 2.0, 1.5),
+            GravityScale(1.0),
+            Cube,
+        ));
+    }
+}
+
+/// Bodies above the platforms fall down, and bodies below them fall up.
+fn flip_gravity(mut cubes: Query<(&Transform, &mut GravityScale), With<Cube>>) {
+    for (transform, mut gravity_scale) in &mut cubes {
+        let y = transform.translation.y;
+        if y > 1.0 && gravity_scale.0 != 1.0 {
+            gravity_scale.0 = 1.0;
+        } else if y < -1.0 && gravity_scale.0 != -1.0 {
+            gravity_scale.0 = -1.0;
+        }
+    }
+}
diff --git a/bindings/bevy_rapier/bevy_rapier3d/examples/picking3.rs b/bindings/bevy_rapier/bevy_rapier3d/examples/picking3.rs
new file mode 100644
index 000000000..9c287294b
--- /dev/null
+++ b/bindings/bevy_rapier/bevy_rapier3d/examples/picking3.rs
@@ -0,0 +1,92 @@
+//! A simple scene to demonstrate picking events for rapier [`Collider`] entities.
+
+use bevy::prelude::*;
+use bevy_rapier3d::prelude::*;
+
+fn main() {
+    App::new()
+        .add_plugins((
+            DefaultPlugins,
+            RapierPhysicsPlugin::<NoUserData>::default(),
+            RapierDebugRenderPlugin::default(),
+            RapierPickingPlugin,
+        ))
+        .insert_resource(RapierPickingSettings {
+            // Optional: only needed when you want fine-grained control
+            // over which cameras and entities should be used with the rapier picking backend.
+            // This is disabled by default, and no marker components are required on cameras or colliders.
+            // This resource is inserted by default,
+            // you only need to add it if you want to override the default settings.
+            require_markers: true,
+            ..Default::default()
+        })
+        .add_systems(Startup, (setup_graphics, setup_physics))
+        .run();
+}
+
+pub fn setup_graphics(mut commands: Commands) {
+    // Camera
+    commands.spawn((
+        Camera3d::default(),
+        Transform::from_xyz(-2.5, 4.5, 9.0).looking_at(Vec3::ZERO, Vec3::Y),
+        RapierPickable,
+    ));
+}
+
+pub fn setup_physics(mut commands: Commands) {
+    commands
+        .spawn((
+            Text::new("Click Me to get a box\nDrag cubes to rotate"),
+            Node {
+                position_type: PositionType::Absolute,
+                top: Val::Percent(12.0),
+                left: Val::Percent(12.0),
+                ..default()
+            },
+        ))
+        .observe(on_click_spawn_cube)
+        .observe(|out: On<PointerOut>, mut texts: Query<&mut TextColor>| {
+            let mut text_color = texts.get_mut(out.event().entity).unwrap();
+            text_color.0 = Color::WHITE;
+        })
+        .observe(|over: On<PointerOver>, mut texts: Query<&mut TextColor>| {
+            let mut color = texts.get_mut(over.event().entity).unwrap();
+            color.0 = bevy::color::palettes::tailwind::CYAN_400.into();
+        });
+    // Base
+    let ground_size = 3.1;
+    let ground_height = 0.1;
+    commands.spawn((
+        Transform::from_xyz(0.0, -ground_height / 2.0, 0.0),
+        Collider::cuboid(ground_size, ground_height, ground_size),
+        ColliderDebugColor(Hsla::BLACK),
+    ));
+}
+
+fn on_click_spawn_cube(_click: On<PointerClick>, mut commands: Commands, mut num: Local<usize>) {
+    let rad = 0.25;
+    let colors = [
+        Hsla::hsl(220.0, 1.0, 0.3),
+        Hsla::hsl(180.0, 1.0, 0.3),
+        Hsla::hsl(260.0, 1.0, 0.7),
+    ];
+    commands
+        .spawn((
+            Transform::from_xyz(0.0, 0.25 + 0.55 * *num as f32, 0.0),
+            Visibility::default(),
+            RigidBody::Dynamic,
+            Collider::cuboid(rad, rad, rad),
+            ColliderDebugColor(colors[*num % 3]),
+            RapierPickable,
+        ))
+        // With the RapierPickingPlugin added, you can add pointer event observers to colliders:
+        .observe(on_drag_rotate);
+    *num += 1;
+}
+
+fn on_drag_rotate(drag: On<PointerDrag>, mut transforms: Query<&mut Transform>) {
+    if let Ok(mut transform) = transforms.get_mut(drag.event().entity) {
+        transform.rotate_y(drag.delta.x * 0.02);
+        transform.rotate_x(drag.delta.y * 0.02);
+    }
+}
diff --git a/bindings/bevy_rapier/bevy_rapier3d/examples/pid_controller3.rs b/bindings/bevy_rapier/bevy_rapier3d/examples/pid_controller3.rs
new file mode 100644
index 000000000..e747f2cc2
--- /dev/null
+++ b/bindings/bevy_rapier/bevy_rapier3d/examples/pid_controller3.rs
@@ -0,0 +1,136 @@
+//! A dynamic body driven by the `PidController` component toward a target pose moved with the
+//! keyboard.
+//!
+//! Controls: WASD/arrows move the target horizontally, Q/E move it down/up, Z/X rotate it, and
+//! Space toggles the control of the vertical axis (letting gravity take over).
+
+use bevy::prelude::*;
+use bevy_rapier3d::prelude::*;
+
+const TARGET_SPEED: f32 = 5.0;
+const TARGET_ANGULAR_SPEED: f32 = 1.5;
+
+#[derive(Resource)]
+struct Target(Transform);
+
+fn main() {
+    App::new()
+        .insert_resource(ClearColor(Color::srgb(
+            0xF9 as f32 / 255.0,
+            0xF9 as f32 / 255.0,
+            0xFF as f32 / 255.0,
+        )))
+        .insert_resource(Target(Transform::from_xyz(0.0, 3.0, 0.0)))
+        .add_plugins((
+            DefaultPlugins,
+            RapierPhysicsPlugin::<NoUserData>::default(),
+            RapierDebugRenderPlugin::default(),
+        ))
+        .add_systems(Startup, (setup_graphics, setup_physics))
+        .add_systems(
+            Update,
+            (move_target, update_controller, draw_target).chain(),
+        )
+        .run();
+}
+
+fn setup_graphics(mut commands: Commands) {
+    commands.spawn((
+        Camera3d::default(),
+        Transform::from_xyz(0.0, 12.0, 20.0).looking_at(Vec3::new(0.0, 1.0, 0.0), Vec3::Y),
+    ));
+}
+
+fn setup_physics(mut commands: Commands) {
+    /*
+     * Ground
+     */
+    commands.spawn((
+        Transform::from_xyz(0.0, -0.1, 0.0),
+        Collider::cuboid(20.0, 0.1, 20.0),
+    ));
+
+    /*
+     * Some boxes to push around.
+     */
+    for i in 0..5 {
+        for j in 0..2 {
+            commands.spawn((
+                Transform::from_xyz(i as f32 * 2.0 - 4.0, 0.5 + j as f32, -4.0),
+                RigidBody::Dynamic,
+                Collider::cuboid(0.5, 0.5, 0.5),
+            ));
+        }
+    }
+
+    /*
+     * The controlled body, using the same default gains as Rapier's PID controller.
+     */
+    commands.spawn((
+        Transform::from_xyz(0.0, 1.0, 4.0),
+        RigidBody::Dynamic,
+        Collider::cuboid(1.0, 0.25, 0.5),
+        PidController::default(),
+        ColliderDebugColor(Hsla::hsl(20.0, 1.0, 0.5)),
+    ));
+}
+
+fn move_target(keyboard: Res<ButtonInput<KeyCode>>, time: Res<Time>, mut target: ResMut<Target>) {
+    let axis = |neg: &[KeyCode], pos: &[KeyCode]| {
+        let pressed = |keys: &[KeyCode]| keyboard.any_pressed(keys.iter().copied()) as i32;
+        (pressed(pos) - pressed(neg)) as f32
+    };
+    let direction = Vec3::new(
+        axis(
+            &[KeyCode::KeyA, KeyCode::ArrowLeft],
+            &[KeyCode::KeyD, KeyCode::ArrowRight],
+        ),
+        axis(&[KeyCode::KeyQ], &[KeyCode::KeyE]),
+        axis(
+            &[KeyCode::KeyW, KeyCode::ArrowUp],
+            &[KeyCode::KeyS, KeyCode::ArrowDown],
+        ),
+    );
+    let yaw = axis(&[KeyCode::KeyX], &[KeyCode::KeyZ]);
+
+    let dt = time.delta_secs();
+    let target = &mut target.0;
+    target.translation += direction.normalize_or_zero() * TARGET_SPEED * dt;
+    target.translation.y = target.translation.y.max(0.5);
+    target.rotate_y(yaw * TARGET_ANGULAR_SPEED * dt);
+}
+
+fn update_controller(
+    keyboard: Res<ButtonInput<KeyCode>>,
+    target: Res<Target>,
+    mut controllers: Query<&mut PidController>,
+) {
+    for mut controller in &mut controllers {
+        controller.target = PidTarget::new(target.0.translation, target.0.rotation);
+
+        if keyboard.just_pressed(KeyCode::Space) {
+            controller.axes.toggle(AxesMask::LIN_Y);
+            // Forget the error accumulated while fighting gravity.
+            controller.reset_integrals();
+            info!(
+                "Vertical axis control: {}",
+                controller.axes.contains(AxesMask::LIN_Y)
+            );
+        }
+    }
+}
+
+fn draw_target(
+    mut gizmos: Gizmos,
+    target: Res<Target>,
+    controlled: Query<&GlobalTransform, With<PidController>>,
+) {
+    gizmos.axes(target.0, 1.5);
+    for transform in &controlled {
+        gizmos.line(
+            transform.translation(),
+            target.0.translation,
+            Color::srgb(0.9, 0.2, 0.2),
+        );
+    }
+}
diff --git a/bindings/bevy_rapier/bevy_rapier3d/examples/rapier_context_component.rs b/bindings/bevy_rapier/bevy_rapier3d/examples/rapier_context_component.rs
new file mode 100644
index 000000000..452632167
--- /dev/null
+++ b/bindings/bevy_rapier/bevy_rapier3d/examples/rapier_context_component.rs
@@ -0,0 +1,64 @@
+use bevy::prelude::*;
+use bevy_rapier3d::prelude::*;
+
+fn main() {
+    App::new()
+        .add_plugins((
+            DefaultPlugins,
+            RapierPhysicsPlugin::<NoUserData>::default(),
+            RapierDebugRenderPlugin::default(),
+        ))
+        .add_systems(Startup, (setup_physics, setup_graphics))
+        .add_systems(
+            PostUpdate,
+            display_nb_colliders.after(PhysicsSet::SyncBackend),
+        )
+        .run();
+}
+
+/// Demonstrates how to access a more specific component of [`RapierContext`]
+fn display_nb_colliders(
+    query_context: Query<&RapierContextColliders, With<DefaultRapierContext>>,
+    mut exit: MessageWriter<AppExit>,
+) -> Result<()> {
+    let nb_colliders = query_context.single()?.colliders.len();
+    println!("There are {nb_colliders} colliders.");
+    assert!(nb_colliders > 0);
+    exit.write(AppExit::Success);
+
+    Ok(())
+}
+
+pub fn setup_physics(mut commands: Commands) {
+    /*
+     * Ground
+     */
+    let ground_size = 5.1;
+    let ground_height = 0.1;
+
+    let starting_y = -0.5 - ground_height;
+
+    commands.spawn((
+        Transform::from_xyz(0.0, starting_y, 0.0),
+        Collider::cuboid(ground_size, ground_height, ground_size),
+    ));
+
+    for _ in 0..3 {
+        /*
+         * Create the cubes
+         */
+
+        commands.spawn((
+            Transform::default(),
+            RigidBody::Dynamic,
+            Collider::cuboid(0.5, 0.5, 0.5),
+        ));
+    }
+}
+
+fn setup_graphics(mut commands: Commands) {
+    commands.spawn((
+        Camera3d::default(),
+        Transform::from_xyz(0.0, 3.0, -10.0).looking_at(Vec3::new(0.0, 0.0, 0.0), Vec3::Y),
+    ));
+}
diff --git a/bindings/bevy_rapier/bevy_rapier3d/examples/rapier_to_bevy_mesh.rs b/bindings/bevy_rapier/bevy_rapier3d/examples/rapier_to_bevy_mesh.rs
new file mode 100644
index 000000000..f41e95922
--- /dev/null
+++ b/bindings/bevy_rapier/bevy_rapier3d/examples/rapier_to_bevy_mesh.rs
@@ -0,0 +1,189 @@
+use bevy::{
+    pbr::wireframe::{WireframeConfig, WireframePlugin},
+    prelude::*,
+};
+use bevy_rapier3d::geometry::to_bevy_mesh::ToMeshBuilder;
+use bevy_rapier3d::prelude::*;
+
+fn main() {
+    App::new()
+        .insert_resource(ClearColor::default())
+        .add_plugins((
+            DefaultPlugins,
+            RapierPhysicsPlugin::<NoUserData>::default(),
+            RapierDebugRenderPlugin::default(),
+            WireframePlugin::default(),
+        ))
+        .add_systems(Startup, (setup_graphics, setup_physics))
+        .add_systems(Update, (toggle_wireframe, toggle_dynamic, rotate))
+        .run();
+}
+
+pub fn setup_graphics(mut commands: Commands) {
+    commands.spawn((
+        Camera3d::default(),
+        Transform::from_xyz(0.0, 5.0, 20.0).looking_at(Vec3::new(0.0, 5.0, 0.0), Vec3::Y),
+    ));
+}
+
+pub fn setup_physics(
+    mut commands: Commands,
+    mut assets_meshes: ResMut<Assets<Mesh>>,
+    mut materials: ResMut<Assets<StandardMaterial>>,
+) {
+    /*
+     * Ground
+     */
+    let ground_size = 200.1;
+    let ground_height = 0.1;
+
+    commands.spawn((
+        Transform::from_xyz(0.0, -ground_height, 0.0),
+        Collider::cuboid(ground_size, ground_height, ground_size),
+    ));
+    // light
+    commands.spawn((
+        PointLight {
+            shadow_maps_enabled: true,
+            ..default()
+        },
+        Transform::from_xyz(4.0, 8.0, 8.0),
+    ));
+    /*
+     * Create the shapes
+     */
+    let rad = 0.5;
+
+    let colors = [
+        Hsla::hsl(220.0, 1.0, 0.3),
+        Hsla::hsl(180.0, 1.0, 0.3),
+        Hsla::hsl(260.0, 1.0, 0.7),
+    ];
+
+    let colliders: Vec<Collider> = vec![
+        Collider::cuboid(rad, rad, rad),
+        Collider::ball(rad),
+        Collider::capsule_y(rad, rad),
+        Collider::cone(rad, rad),
+        Collider::cylinder(rad, rad),
+        Collider::trimesh(
+            vec![
+                [-0.5, -0.5, -0.5].into(), // Vertex 0
+                [0.5, -0.5, -0.5].into(),  // Vertex 1
+                [0.5, 0.5, -0.5].into(),   // Vertex 2
+                [-0.5, 0.5, -0.5].into(),  // Vertex 3
+                [-0.5, -0.5, 0.5].into(),  // Vertex 4
+                [0.5, -0.5, 0.5].into(),   // Vertex 5
+                [0.5, 0.5, 0.5].into(),    // Vertex 6
+                [-0.5, 0.5, 0.5].into(),   // Vertex 7
+            ],
+            vec![
+                // Back face
+                [0, 2, 1],
+                [0, 3, 2],
+                // Front face
+                [4, 5, 6],
+                [4, 6, 7],
+                // Left face
+                [0, 4, 7],
+                [0, 7, 3],
+                // Right face
+                [1, 6, 5],
+                [1, 2, 6],
+                // Bottom face
+                [0, 1, 5],
+                [0, 5, 4],
+                // Top face
+                [3, 6, 2],
+                [3, 7, 6],
+            ],
+        )
+        .unwrap(),
+        // Unsupported shapes
+        Collider::round_cylinder(rad, rad, rad / 10.0),
+        Collider::segment(Vec3::new(-rad, 0.0, 0.0), Vec3::new(rad, 0.0, 0.0)),
+        Collider::triangle(
+            Vec3::new(-rad, -rad, 0.0),
+            Vec3::new(rad, -rad, 0.0),
+            Vec3::new(0.0, rad, 0.0),
+        ),
+        Collider::heightfield(
+            vec![0.0, 0.0, 0.0, rad, rad, rad, 0.0, 0.0, 0.0],
+            3,
+            3,
+            Vec3::new(rad, rad, rad),
+        ),
+    ];
+    let material = MeshMaterial3d(materials.add(Color::WHITE));
+    let colliders_count = colliders.len();
+    for (i, collider) in colliders.iter().enumerate() {
+        fn get_coordinates(id: usize, column_size: usize) -> Vec3 {
+            let x = id / column_size;
+            let y = id % column_size;
+            let z = 0;
+            Vec3::new(x as f32, y as f32, z as f32)
+        }
+        let column_height = 3;
+        // Get int coordinates from index
+        let coordinates = get_coordinates(i, column_height);
+        // Center the coordinates in x
+        let columns = colliders_count / column_height;
+        let coordinates = coordinates - Vec3::new(columns as f32 / 2.0, 0.0, 0.0);
+        // more space between shapes
+        let coordinates = coordinates * (1.0 + rad);
+        // Shift up
+        let coordinates = coordinates + Vec3::new(0.0, rad + 5.0, 0.0);
+
+        let mut entity = commands.spawn((
+            Transform::from_translation(coordinates),
+            RigidBody::Fixed,
+            collider.clone(),
+            ColliderDebugColor(colors[i % 3]),
+        ));
+        // Transform the parry shape into a bevy mesh.
+        let mesh = Mesh::try_from(collider);
+        if let Ok(mut mesh) = mesh {
+            mesh.compute_normals();
+            entity.insert((Mesh3d(assets_meshes.add(mesh)), material.clone()));
+        }
+    }
+    // Alternatively, you can call [`Collider::as_typed_shape`] of `Collider::as_[specificShape]`
+    // to retrieve a specialized builder through [`ToMeshBuilder::mesh_builder`]
+    let mut mesh = colliders[1].as_ball().unwrap().raw.mesh_builder().build();
+    let mut entity = commands.spawn((
+        Transform::from_translation(Vec3::new(0.0, 1.0 + rad, 0.0)),
+        RigidBody::Fixed,
+        colliders[1].clone(),
+        ColliderDebugColor(colors[42 % 3]),
+    ));
+    mesh.compute_normals();
+    entity.insert((Mesh3d(assets_meshes.add(mesh)), material.clone()));
+}
+
+fn toggle_wireframe(
+    mut wireframe_config: ResMut<WireframeConfig>,
+    keyboard: Res<ButtonInput<KeyCode>>,
+) {
+    if keyboard.just_pressed(KeyCode::Space) {
+        wireframe_config.global = !wireframe_config.global;
+    }
+}
+
+fn toggle_dynamic(mut bodies: Query<&mut RigidBody>, keyboard: Res<ButtonInput<KeyCode>>) {
+    if keyboard.just_pressed(KeyCode::KeyD) {
+        for mut body in &mut bodies.iter_mut() {
+            if body.is_dynamic() {
+                *body = RigidBody::Fixed;
+            } else {
+                *body = RigidBody::Dynamic;
+            }
+        }
+    }
+}
+
+fn rotate(mut query: Query<&mut Transform, With<RigidBody>>, time: Res<Time>) {
+    for mut transform in &mut query {
+        transform.rotate_y(time.delta_secs() / 2.);
+        transform.rotate_x(time.delta_secs() / 2.6);
+    }
+}
diff --git a/bindings/bevy_rapier/bevy_rapier3d/examples/ray_casting3.rs b/bindings/bevy_rapier/bevy_rapier3d/examples/ray_casting3.rs
new file mode 100644
index 000000000..ba935004f
--- /dev/null
+++ b/bindings/bevy_rapier/bevy_rapier3d/examples/ray_casting3.rs
@@ -0,0 +1,109 @@
+use bevy::color::palettes::basic;
+use bevy::prelude::*;
+use bevy::window::PrimaryWindow;
+use bevy_rapier3d::prelude::*;
+
+fn main() {
+    App::new()
+        .insert_resource(ClearColor(Color::srgb(
+            0xF9 as f32 / 255.0,
+            0xF9 as f32 / 255.0,
+            0xFF as f32 / 255.0,
+        )))
+        .add_plugins((
+            DefaultPlugins,
+            RapierPhysicsPlugin::<NoUserData>::default(),
+            RapierDebugRenderPlugin::default(),
+        ))
+        .add_systems(Startup, (setup_graphics, setup_physics))
+        .add_systems(Update, cast_ray)
+        .run();
+}
+
+pub fn setup_graphics(mut commands: Commands) {
+    commands.spawn((
+        Camera3d::default(),
+        Transform::from_xyz(-30.0, 30.0, 100.0).looking_at(Vec3::new(0.0, 10.0, 0.0), Vec3::Y),
+    ));
+}
+
+pub fn setup_physics(mut commands: Commands) {
+    /*
+     * Ground
+     */
+    let ground_size = 200.1;
+    let ground_height = 0.1;
+
+    commands.spawn((
+        Transform::from_xyz(0.0, -ground_height, 0.0),
+        Collider::cuboid(ground_size, ground_height, ground_size),
+    ));
+
+    /*
+     * Create the cubes
+     */
+    let num = 8;
+    let rad = 1.0;
+
+    let shift = rad * 2.0 + rad;
+    let centerx = shift * (num / 2) as f32;
+    let centery = shift / 2.0;
+    let centerz = shift * (num / 2) as f32;
+
+    let mut offset = -(num as f32) * (rad * 2.0 + rad) * 0.5;
+
+    for j in 0usize..20 {
+        for i in 0..num {
+            for k in 0usize..num {
+                let x = i as f32 * shift - centerx + offset;
+                let y = j as f32 * shift + centery + 3.0;
+                let z = k as f32 * shift - centerz + offset;
+
+                // Build the rigid body.
+                commands.spawn((
+                    Transform::from_xyz(x, y, z),
+                    RigidBody::Dynamic,
+                    Collider::cuboid(rad, rad, rad),
+                ));
+            }
+        }
+
+        offset -= 0.05 * rad * (num as f32 - 1.0);
+    }
+}
+
+pub fn cast_ray(
+    mut commands: Commands,
+    window: Single<&Window, With<PrimaryWindow>>,
+    rapier_context: ReadRapierContext,
+    cameras: Query<(&Camera, &GlobalTransform)>,
+) -> Result<()> {
+    let Some(cursor_position) = window.cursor_position() else {
+        log::warn!("Cursor is outside the window area");
+        return Ok(());
+    };
+
+    // We will color in read the colliders hovered by the mouse.
+    for (camera, camera_transform) in &cameras {
+        // First, compute a ray from the mouse position.
+        let Ok(ray) = camera.viewport_to_world(camera_transform, cursor_position) else {
+            log::warn!("Unable to compute ray from mouse position");
+            return Ok(());
+        };
+        let context = rapier_context.single()?;
+        context.with_query_pipeline(QueryFilter::only_dynamic(), |query_pipeline| {
+            // Then cast the ray.
+            let hit = query_pipeline.cast_ray(ray.origin, ray.direction.into(), f32::MAX, true);
+
+            if let Some((entity, _toi)) = hit {
+                // Color in blue the entity we just hit.
+                // Because of the query filter, only colliders attached to a dynamic body
+                // will get an event.
+                let color = basic::BLUE.into();
+                commands.entity(entity).insert(ColliderDebugColor(color));
+            }
+        });
+    }
+
+    Ok(())
+}
diff --git a/bindings/bevy_rapier/bevy_rapier3d/examples/scene_queries3.rs b/bindings/bevy_rapier/bevy_rapier3d/examples/scene_queries3.rs
new file mode 100644
index 000000000..01cccbdfa
--- /dev/null
+++ b/bindings/bevy_rapier/bevy_rapier3d/examples/scene_queries3.rs
@@ -0,0 +1,270 @@
+//! Scene queries drawn with gizmos: `cast_shape_nonlinear` (a tumbling stick),
+//! `closest_points_to_shape` (an orbiting ball), and `contact_with_shape` (a cube moving between
+//! the legs of a table), with the part of the compound table hit by each query highlighted from
+//! its sub-shape id.
+
+use bevy::prelude::*;
+use bevy_rapier3d::prelude::*;
+
+const HIT_COLOR: Color = Color::srgb(0.9, 0.1, 0.1);
+const MISS_COLOR: Color = Color::srgb(0.2, 0.6, 0.2);
+const PATH_COLOR: Color = Color::srgb(0.6, 0.6, 0.6);
+const PART_COLOR: Color = Color::srgb(1.0, 0.7, 0.0);
+
+#[derive(Component)]
+struct Ground;
+
+#[derive(Component)]
+struct ResultsText;
+
+fn main() {
+    App::new()
+        .insert_resource(ClearColor(Color::srgb(
+            0xF9 as f32 / 255.0,
+            0xF9 as f32 / 255.0,
+            0xFF as f32 / 255.0,
+        )))
+        .add_plugins((
+            DefaultPlugins,
+            RapierPhysicsPlugin::<NoUserData>::default(),
+            RapierDebugRenderPlugin::default(),
+        ))
+        .add_systems(Startup, (setup_graphics, setup_physics))
+        .add_systems(Update, run_queries)
+        .run();
+}
+
+fn setup_graphics(mut commands: Commands) {
+    commands.spawn((
+        Camera3d::default(),
+        Transform::from_xyz(8.0, 9.0, 14.0).looking_at(Vec3::new(0.0, 1.5, 0.0), Vec3::Y),
+    ));
+    commands.spawn((
+        Text::new(""),
+        TextColor(Color::BLACK),
+        Node {
+            position_type: PositionType::Absolute,
+            top: Val::Px(12.0),
+            left: Val::Px(12.0),
+            ..default()
+        },
+        ResultsText,
+    ));
+}
+
+fn setup_physics(mut commands: Commands) {
+    commands.spawn((
+        Transform::from_xyz(0.0, -0.1, 0.0),
+        Collider::cuboid(20.0, 0.1, 20.0),
+        Ground,
+    ));
+
+    // A table made of a single compound collider: part 0 is the top, parts 1 to 4 are the legs.
+    let mut parts = vec![(
+        Vec3::new(0.0, 2.0, 0.0),
+        Quat::IDENTITY,
+        Collider::cuboid(3.0, 0.2, 2.0),
+    )];
+    for (x, z) in [(-2.6, -1.6), (2.6, -1.6), (-2.6, 1.6), (2.6, 1.6)] {
+        parts.push((
+            Vec3::new(x, 0.9, z),
+            Quat::IDENTITY,
+            Collider::cuboid(0.2, 0.9, 0.2),
+        ));
+    }
+    commands.spawn((Transform::default(), Collider::compound(parts)));
+
+    // A few more obstacles.
+    commands.spawn((Transform::from_xyz(-6.0, 1.0, 0.0), Collider::ball(1.0)));
+    commands.spawn((
+        Transform::from_xyz(6.0, 1.0, 0.0).with_rotation(Quat::from_rotation_y(0.5)),
+        Collider::cuboid(1.0, 1.0, 1.0),
+    ));
+}
+
+fn run_queries(
+    time: Res<Time>,
+    rapier_context: ReadRapierContext,
+    ground: Single<Entity, With<Ground>>,
+    colliders: Query<(&Collider, &GlobalTransform)>,
+    mut text: Single<&mut Text, With<ResultsText>>,
+    mut gizmos: Gizmos,
+) -> Result<()> {
+    let context = rapier_context.single()?;
+    let t = time.elapsed_secs();
+    let filter = QueryFilter::new().exclude_collider(*ground);
+    let mut report = String::new();
+
+    /*
+     * Nonlinear shape-cast: a stick tumbling toward the table.
+     */
+    let stick = Collider::cuboid(0.8, 0.1, 0.1);
+    let motion = NonlinearMotion {
+        translation: Vec3::new(4.0 * (t * 0.4).sin(), 5.0, 8.0),
+        rotation: Quat::IDENTITY,
+        local_center: Vec3::ZERO,
+        linear_velocity: Vec3::new(0.0, -3.0, -10.0),
+        angular_velocity: Vec3::new(0.0, 2.0, 6.0),
+    };
+    let hit = context.cast_shape_nonlinear(&motion, &stick, 0.0, 1.0, true, filter);
+    let end_time = hit.map_or(1.0, |(_, hit)| hit.time_of_impact);
+
+    let raw_motion = motion.into_rapier();
+    for k in 0..=10 {
+        let pose = raw_motion.position_at_time(end_time * k as f32 / 10.0);
+        let color = if k == 10 && hit.is_some() {
+            HIT_COLOR
+        } else {
+            PATH_COLOR
+        };
+        draw_cuboid(
+            &mut gizmos,
+            pose.translation,
+            pose.rotation,
+            Vec3::new(0.8, 0.1, 0.1),
+            color,
+        );
+    }
+
+    match hit {
+        Some((entity, hit)) => {
+            if let Some(details) = hit.details {
+                gizmos.sphere(
+                    Isometry3d::from_translation(details.witness1),
+                    0.08,
+                    HIT_COLOR,
+                );
+            }
+            highlight_part(&mut gizmos, &colliders, entity, hit.subshape1);
+            report += &format!(
+                "cast_shape_nonlinear: hit {entity} (part {}) at t = {:.2}\n",
+                hit.subshape1, hit.time_of_impact
+            );
+        }
+        None => report += "cast_shape_nonlinear: no hit\n",
+    }
+
+    /*
+     * Closest points: a ball orbiting around the table.
+     */
+    let ball_radius = 0.4;
+    let ball = Collider::ball(ball_radius);
+    let ball_pos = Vec3::new(
+        4.5 * (t * 0.5).cos(),
+        1.5 + 1.2 * (t * 1.3).sin(),
+        3.2 * (t * 0.5).sin(),
+    );
+    let max_dist = 2.0;
+
+    match context.closest_points_to_shape(ball_pos, Quat::IDENTITY, &ball, max_dist, filter) {
+        Some((entity, ShapeClosestPoints::WithinMargin(p1, p2))) => {
+            gizmos.sphere(
+                Isometry3d::from_translation(ball_pos),
+                ball_radius,
+                MISS_COLOR,
+            );
+            gizmos.line(p1, p2, MISS_COLOR);
+            report += &format!(
+                "closest_points_to_shape: {entity} is {:.2} away\n",
+                p1.distance(p2)
+            );
+        }
+        Some((entity, _)) => {
+            gizmos.sphere(
+                Isometry3d::from_translation(ball_pos),
+                ball_radius,
+                HIT_COLOR,
+            );
+            report += &format!("closest_points_to_shape: intersecting {entity}\n");
+        }
+        None => {
+            gizmos.sphere(
+                Isometry3d::from_translation(ball_pos),
+                ball_radius,
+                PATH_COLOR,
+            );
+            report += &format!("closest_points_to_shape: nothing within {max_dist}\n");
+        }
+    }
+
+    /*
+     * Contact: a cube moving under the table top, between its legs.
+     */
+    let cube_half_extents = Vec3::splat(0.4);
+    let cube = Collider::cuboid(
+        cube_half_extents.x,
+        cube_half_extents.y,
+        cube_half_extents.z,
+    );
+    let cube_pos = Vec3::new(2.8 * (t * 0.6).sin(), 1.0, 1.8 * (t * 0.6).cos());
+    let cube_rot = Quat::from_rotation_y(t);
+    let prediction = 0.5;
+
+    match context.contact_with_shape(cube_pos, cube_rot, &cube, prediction, filter) {
+        Some((entity, contact)) => {
+            let color = if contact.distance < 0.0 {
+                HIT_COLOR
+            } else {
+                MISS_COLOR
+            };
+            draw_cuboid(&mut gizmos, cube_pos, cube_rot, cube_half_extents, color);
+            gizmos.sphere(Isometry3d::from_translation(contact.point1), 0.05, color);
+            gizmos.sphere(Isometry3d::from_translation(contact.point2), 0.05, color);
+            gizmos.arrow(contact.point1, contact.point1 + contact.normal1, color);
+            highlight_part(&mut gizmos, &colliders, entity, contact.subshape1);
+            report += &format!(
+                "contact_with_shape: {entity} (part {}) at distance {:.2}\n",
+                contact.subshape1, contact.distance
+            );
+        }
+        None => {
+            draw_cuboid(
+                &mut gizmos,
+                cube_pos,
+                cube_rot,
+                cube_half_extents,
+                PATH_COLOR,
+            );
+            report += &format!("contact_with_shape: nothing within {prediction}\n");
+        }
+    }
+
+    text.0 = report;
+    Ok(())
+}
+
+fn draw_cuboid(gizmos: &mut Gizmos, pos: Vec3, rot: Quat, half_extents: Vec3, color: Color) {
+    gizmos.cube(
+        Transform::from_translation(pos)
+            .with_rotation(rot)
+            .with_scale(half_extents * 2.0),
+        color,
+    );
+}
+
+/// Draws the part `subshape` of the collider attached to `entity`, if it is a compound of cuboids.
+fn highlight_part(
+    gizmos: &mut Gizmos,
+    colliders: &Query<(&Collider, &GlobalTransform)>,
+    entity: Entity,
+    subshape: u32,
+) {
+    let Ok((collider, transform)) = colliders.get(entity) else {
+        return;
+    };
+    let Some(compound) = collider.as_compound() else {
+        return;
+    };
+    let Some((pos, rot, ColliderView::Cuboid(cuboid))) = compound.shapes().nth(subshape as usize)
+    else {
+        return;
+    };
+    let (_, body_rot, body_pos) = transform.to_scale_rotation_translation();
+    draw_cuboid(
+        gizmos,
+        body_pos + body_rot * pos,
+        body_rot * rot,
+        cuboid.half_extents() + Vec3::splat(0.02),
+        PART_COLOR,
+    );
+}
diff --git a/bindings/bevy_rapier/bevy_rapier3d/examples/soft_bodies3.rs b/bindings/bevy_rapier/bevy_rapier3d/examples/soft_bodies3.rs
new file mode 100644
index 000000000..aa992d2da
--- /dev/null
+++ b/bindings/bevy_rapier/bevy_rapier3d/examples/soft_bodies3.rs
@@ -0,0 +1,150 @@
+//! Soft bodies: a cloth pinned at two corners draping over a box, and a soft cube and a soft
+//! ball falling on the ground, rendered with meshes kept in sync with their particles.
+//!
+//! Press space to cut the cloth in two.
+
+use bevy::prelude::*;
+use bevy_rapier3d::prelude::*;
+
+/// Marks the cloth entity.
+#[derive(Component)]
+pub struct Cloth;
+
+fn main() {
+    App::new()
+        .insert_resource(ClearColor(Color::srgb(
+            0xF9 as f32 / 255.0,
+            0xF9 as f32 / 255.0,
+            0xFF as f32 / 255.0,
+        )))
+        .add_plugins((
+            DefaultPlugins,
+            RapierPhysicsPlugin::<NoUserData>::default(),
+            RapierDebugRenderPlugin::default(),
+        ))
+        .add_systems(Startup, (setup_graphics, setup_physics))
+        .add_systems(Update, (cut_cloth, log_tears))
+        .run();
+}
+
+pub fn setup_graphics(mut commands: Commands) {
+    commands.spawn((
+        Camera3d::default(),
+        Transform::from_xyz(-4.0, 5.0, 9.0).looking_at(Vec3::new(0.0, 1.0, 0.0), Vec3::Y),
+    ));
+    commands.spawn((
+        DirectionalLight {
+            shadow_maps_enabled: true,
+            ..default()
+        },
+        Transform::from_xyz(5.0, 10.0, 5.0).looking_at(Vec3::ZERO, Vec3::Y),
+    ));
+}
+
+pub fn setup_physics(
+    mut commands: Commands,
+    mut meshes: ResMut<Assets<Mesh>>,
+    mut materials: ResMut<Assets<StandardMaterial>>,
+) {
+    /*
+     * Ground and a box for the cloth to drape over.
+     */
+    commands.spawn((
+        Transform::from_xyz(0.0, -0.1, 0.0),
+        Collider::cuboid(10.0, 0.1, 10.0),
+    ));
+    commands.spawn((
+        Transform::from_xyz(0.0, 0.75, 0.0),
+        Collider::cuboid(0.75, 0.75, 0.75),
+        Mesh3d(meshes.add(Cuboid::new(1.5, 1.5, 1.5))),
+        MeshMaterial3d(materials.add(Color::srgb(0.4, 0.4, 0.45))),
+    ));
+
+    /*
+     * A cloth, pinned at the two corners of its back edge. Particle `(i, j)` has the index
+     * `i * n + j`, at `origin + i * du + j * dv`.
+     */
+    let n = 30;
+    let spacing = 0.1;
+    let origin = Vec3::new(-1.5, 0.0, -1.5);
+    let pinned = [0, (n - 1) * n];
+    commands.spawn((
+        Cloth,
+        Transform::from_xyz(0.0, 2.2, 0.0),
+        SoftBody::cloth(
+            origin,
+            Vec3::X * spacing,
+            Vec3::Z * spacing,
+            n as usize,
+            n as usize,
+        )
+        .map(|b| {
+            b.particle_mass(0.02)
+                .material(RapierSoftBodyMaterial {
+                    bend_softness: SpringCoefficients::new(3.0, 1.0),
+                    ..RapierSoftBodyMaterial::uniform(SpringCoefficients::new(30.0, 1.0))
+                })
+                .pinned_particles(pinned)
+        }),
+        Friction::coefficient(0.8),
+        SoftBodyMeshSync::default(),
+        MeshMaterial3d(materials.add(StandardMaterial {
+            base_color: Color::srgb(0.8, 0.2, 0.2),
+            double_sided: true,
+            cull_mode: None,
+            ..default()
+        })),
+    ));
+
+    /*
+     * A soft cube and a soft ball, falling next to the box.
+     */
+    commands.spawn((
+        Transform::from_xyz(2.5, 3.0, 0.0).with_rotation(Quat::from_rotation_z(0.4)),
+        SoftBody::cuboid(Vec3::splat(0.5), 5, 5, 5).map(|b| b.particle_mass(0.05)),
+        SoftBodyMaterial::uniform(20.0, 1.0),
+        SoftBodyMeshSync::default(),
+        MeshMaterial3d(materials.add(Color::srgb(0.2, 0.6, 0.3))),
+    ));
+    commands.spawn((
+        Transform::from_xyz(-2.5, 3.0, 0.0),
+        SoftBody::sphere(0.6, 2).map(|b| b.particle_mass(0.05)),
+        SoftBodyVolumeFactor(1.1),
+        SoftBodyMeshSync::default(),
+        MeshMaterial3d(materials.add(Color::srgb(0.2, 0.4, 0.8))),
+    ));
+}
+
+/// Cuts the cloth along the plane `x = 0` when space is pressed.
+pub fn cut_cloth(
+    keys: Res<ButtonInput<KeyCode>>,
+    mut context: WriteRapierContext,
+    mut commands: Commands,
+    cloths: Query<Entity, With<Cloth>>,
+) {
+    if !keys.just_pressed(KeyCode::Space) {
+        return;
+    }
+    let Ok(mut context) = context.single_mut() else {
+        return;
+    };
+    for cloth in &cloths {
+        // A large triangle in the plane `x = 0`, crossing the whole cloth.
+        let blade = [
+            Vec3::new(0.0, -10.0, -10.0),
+            Vec3::new(0.0, 20.0, -10.0),
+            Vec3::new(0.0, -10.0, 20.0),
+        ];
+        if let Some(tear) = context.cut_soft_body(&mut commands, cloth, &blade) {
+            info!("The cut split the cloth into {:?}", tear.pieces);
+        }
+    }
+}
+
+/// Logs the pieces soft bodies tear into.
+pub fn log_tears(mut tears: MessageReader<SoftBodyTearEvent>) {
+    for tear in tears.read() {
+        let pieces: Vec<_> = tear.pieces.iter().map(|piece| piece.soft_body).collect();
+        info!("Soft body {} tore into {pieces:?}", tear.soft_body);
+    }
+}
diff --git a/bindings/bevy_rapier/bevy_rapier3d/examples/soft_cloth3.rs b/bindings/bevy_rapier/bevy_rapier3d/examples/soft_cloth3.rs
new file mode 100644
index 000000000..14f981f4e
--- /dev/null
+++ b/bindings/bevy_rapier/bevy_rapier3d/examples/soft_cloth3.rs
@@ -0,0 +1,115 @@
+//! Cloth: a sheet draped over a rigid ball and a rigid box, and a curtain pinned along its top
+//! edge pushed by a rolling ball. The cloths are rendered with meshes kept in sync with their
+//! particles.
+
+use bevy::prelude::*;
+use bevy_rapier3d::prelude::*;
+
+fn main() {
+    App::new()
+        .insert_resource(ClearColor(Color::srgb(
+            0xF9 as f32 / 255.0,
+            0xF9 as f32 / 255.0,
+            0xFF as f32 / 255.0,
+        )))
+        .add_plugins((
+            DefaultPlugins,
+            RapierPhysicsPlugin::<NoUserData>::default(),
+            RapierDebugRenderPlugin::default(),
+        ))
+        .add_systems(Startup, (setup_graphics, setup_physics))
+        .run();
+}
+
+fn setup_graphics(mut commands: Commands) {
+    commands.spawn((
+        Camera3d::default(),
+        Transform::from_xyz(8.0, 6.0, 14.0).looking_at(Vec3::new(0.0, 1.5, 2.0), Vec3::Y),
+    ));
+    commands.spawn((
+        DirectionalLight {
+            shadow_maps_enabled: true,
+            ..default()
+        },
+        Transform::from_xyz(5.0, 10.0, 5.0).looking_at(Vec3::ZERO, Vec3::Y),
+    ));
+}
+
+/// A double-sided material, for cloths.
+fn cloth_material(color: Color) -> StandardMaterial {
+    StandardMaterial {
+        base_color: color,
+        double_sided: true,
+        cull_mode: None,
+        ..default()
+    }
+}
+
+fn setup_physics(
+    mut commands: Commands,
+    mut meshes: ResMut<Assets<Mesh>>,
+    mut materials: ResMut<Assets<StandardMaterial>>,
+) {
+    let obstacle_color = materials.add(Color::srgb(0.4, 0.4, 0.45));
+
+    /*
+     * Ground.
+     */
+    commands.spawn((
+        Transform::from_xyz(0.0, -0.1, 0.0),
+        Collider::cuboid(12.0, 0.1, 12.0),
+    ));
+
+    /*
+     * A sheet dropped over a rigid ball and a rigid box. Particle `(i, j)` of a cloth is at
+     * `origin + i * du + j * dv`.
+     */
+    commands.spawn((
+        Transform::from_xyz(-1.0, 1.0, 0.0),
+        Collider::ball(1.0),
+        Mesh3d(meshes.add(Sphere::new(1.0))),
+        MeshMaterial3d(obstacle_color.clone()),
+    ));
+    commands.spawn((
+        Transform::from_xyz(1.5, 0.6, 0.0),
+        Collider::cuboid(0.6, 0.6, 0.6),
+        Mesh3d(meshes.add(Cuboid::new(1.2, 1.2, 1.2))),
+        MeshMaterial3d(obstacle_color.clone()),
+    ));
+    commands.spawn((
+        Transform::from_xyz(-3.0, 3.0, -2.0),
+        SoftBody::cloth(Vec3::ZERO, Vec3::X * 0.1, Vec3::Z * 0.1, 60, 40)
+            .map(|b| b.particle_mass(0.02)),
+        SoftBodyMaterial(RapierSoftBodyMaterial {
+            bend_softness: SpringCoefficients::new(3.0, 1.0),
+            ..RapierSoftBodyMaterial::uniform(SpringCoefficients::new(30.0, 1.0))
+        }),
+        Friction::coefficient(0.8),
+        SoftBodyMeshSync::default(),
+        MeshMaterial3d(materials.add(cloth_material(Color::srgb(0.8, 0.2, 0.2)))),
+    ));
+
+    /*
+     * A curtain pinned along its top edge (the particles `(i, 0)`, of index `i * 30`), with a
+     * heavy ball rolling into it.
+     */
+    commands.spawn((
+        Transform::from_xyz(-2.0, 4.0, 5.0),
+        SoftBody::cloth(Vec3::ZERO, Vec3::X * 0.1, Vec3::NEG_Y * 0.1, 40, 30).map(|b| {
+            b.pinned_particles((0..40).map(|i| i * 30))
+                .particle_mass(0.02)
+        }),
+        SoftBodyMaterial::uniform(30.0, 1.0),
+        SoftBodyMeshSync::default(),
+        MeshMaterial3d(materials.add(cloth_material(Color::srgb(0.2, 0.5, 0.8)))),
+    ));
+    commands.spawn((
+        Transform::from_xyz(0.0, 0.5, 9.0),
+        RigidBody::Dynamic,
+        Velocity::linear(Vec3::new(0.0, 0.0, -6.0)),
+        Collider::ball(0.5),
+        ColliderMassProperties::Density(3.0),
+        Mesh3d(meshes.add(Sphere::new(0.5))),
+        MeshMaterial3d(obstacle_color),
+    ));
+}
diff --git a/bindings/bevy_rapier/bevy_rapier3d/examples/soft_fem3.rs b/bindings/bevy_rapier/bevy_rapier3d/examples/soft_fem3.rs
new file mode 100644
index 000000000..3bac0e2c7
--- /dev/null
+++ b/bindings/bevy_rapier/bevy_rapier3d/examples/soft_fem3.rs
@@ -0,0 +1,150 @@
+//! The FEM soft-body solver side by side with the constraint solver: the same bodies twice,
+//! simulated by `SoftBodySolver::Fem` at the back (blue) and by the constraint solver at the front
+//! (orange). The FEM cantilever and plank hold their deflection; the constraint ones sag.
+//!
+//! Run with `--features fem`.
+
+use bevy::prelude::*;
+use bevy_rapier3d::prelude::*;
+
+/// Distance between the FEM column (at `-Z`) and the constraint-solver column (at `+Z`).
+const COLUMN: f32 = 3.5;
+
+fn main() {
+    App::new()
+        .insert_resource(ClearColor(Color::srgb(
+            0xF9 as f32 / 255.0,
+            0xF9 as f32 / 255.0,
+            0xFF as f32 / 255.0,
+        )))
+        .add_plugins((
+            DefaultPlugins,
+            RapierPhysicsPlugin::<NoUserData>::default(),
+            RapierDebugRenderPlugin::default(),
+        ))
+        .add_systems(Startup, (setup_graphics, setup_physics))
+        .run();
+}
+
+fn setup_graphics(mut commands: Commands) {
+    commands.spawn((
+        Camera3d::default(),
+        Transform::from_xyz(2.0, 8.0, 16.0).looking_at(Vec3::new(0.5, 2.0, 0.0), Vec3::Y),
+    ));
+    commands.spawn((
+        DirectionalLight {
+            shadow_maps_enabled: true,
+            ..default()
+        },
+        Transform::from_xyz(5.0, 10.0, 5.0).looking_at(Vec3::ZERO, Vec3::Y),
+    ));
+}
+
+/// A stiff, damped material.
+fn stiff(young_modulus: f32) -> SoftBodyMaterial {
+    SoftBodyMaterial(RapierSoftBodyMaterial {
+        young_modulus,
+        poisson_ratio: 0.3,
+        elastic_damping_ratio: 1.0,
+        ..default()
+    })
+}
+
+/// The indices of the particles of `body` whose local position satisfies `pinned`.
+fn pinned_particles(body: &SoftBody, pinned: impl Fn(Vec3) -> bool) -> Vec<u32> {
+    (0..)
+        .zip(body.builder.particle_positions())
+        .filter(|(_, p)| pinned(**p))
+        .map(|(i, _)| i)
+        .collect()
+}
+
+fn setup_physics(
+    mut commands: Commands,
+    mut meshes: ResMut<Assets<Mesh>>,
+    mut materials: ResMut<Assets<StandardMaterial>>,
+) {
+    commands.spawn((
+        Transform::from_xyz(0.0, -0.1, 0.0),
+        Collider::cuboid(20.0, 0.1, 20.0),
+    ));
+
+    let box_mesh = meshes.add(Cuboid::new(0.7, 0.7, 0.7));
+    let box_color = materials.add(Color::srgb(0.4, 0.4, 0.45));
+    let solvers = [
+        (SoftBodySolver::Fem, -COLUMN, Color::srgb(0.3, 0.55, 0.9)),
+        (
+            SoftBodySolver::Constraints,
+            COLUMN,
+            Color::srgb(0.95, 0.6, 0.3),
+        ),
+    ];
+
+    for (solver, z, color) in solvers {
+        let color = materials.add(color);
+
+        /*
+         * A stiff cantilever bolted to a wall: the deflection under its own weight.
+         */
+        let (length, thickness) = (3.0, 0.3);
+        let beam = SoftBody::cuboid(
+            Vec3::new(length * 0.5, thickness * 0.5, thickness * 0.5),
+            13,
+            3,
+            3,
+        )
+        .map(|b| b.cell_model(SoftBodyCellModel::Corotational).mass(12.0));
+        let pinned = pinned_particles(&beam, |p| p.x < -length * 0.5 + 1.0e-4);
+        commands.spawn((
+            Transform::from_xyz(length * 0.5 - 5.0, 3.0, z),
+            beam.map(|b| b.pinned_particles(pinned)),
+            stiff(2.0e6),
+            SoftBodyElasticitySolver(solver),
+            SoftBodyMeshSync::default(),
+            MeshMaterial3d(color.clone()),
+        ));
+
+        /*
+         * A plank pinned at both ends, loaded by a heavy box dropped in its middle.
+         */
+        let plank = SoftBody::cuboid(Vec3::new(2.0, 0.15, 0.6), 17, 3, 5)
+            .map(|b| b.cell_model(SoftBodyCellModel::Corotational).mass(20.0));
+        let pinned = pinned_particles(&plank, |p| p.x.abs() > 1.9);
+        commands.spawn((
+            Transform::from_xyz(1.0, 2.0, z),
+            plank.map(|b| b.pinned_particles(pinned)),
+            stiff(4.0e6),
+            SoftBodyElasticitySolver(solver),
+            SoftBodyMeshSync::default(),
+            MeshMaterial3d(color.clone()),
+        ));
+        commands.spawn((
+            Transform::from_xyz(1.0, 4.5, z),
+            RigidBody::Dynamic,
+            Collider::cuboid(0.35, 0.35, 0.35),
+            ColliderMassProperties::Density(30.0),
+            Mesh3d(box_mesh.clone()),
+            MeshMaterial3d(box_color.clone()),
+        ));
+
+        /*
+         * A Neo-Hookean jelly cube dropped on the ground: the two solvers agree here.
+         */
+        commands.spawn((
+            Transform::from_xyz(6.0, 2.0, z),
+            SoftBody::cuboid(Vec3::splat(0.7), 5, 5, 5).map(|b| {
+                b.cell_model(SoftBodyCellModel::NeoHookean)
+                    .particle_mass(0.1)
+            }),
+            SoftBodyMaterial(RapierSoftBodyMaterial {
+                young_modulus: 2.0e4,
+                poisson_ratio: 0.4,
+                elastic_damping_ratio: 0.5,
+                ..default()
+            }),
+            SoftBodyElasticitySolver(solver),
+            SoftBodyMeshSync::default(),
+            MeshMaterial3d(color),
+        ));
+    }
+}
diff --git a/bindings/bevy_rapier/bevy_rapier3d/examples/soft_jelly3.rs b/bindings/bevy_rapier/bevy_rapier3d/examples/soft_jelly3.rs
new file mode 100644
index 000000000..763f62a72
--- /dev/null
+++ b/bindings/bevy_rapier/bevy_rapier3d/examples/soft_jelly3.rs
@@ -0,0 +1,196 @@
+//! Jelly: a stack of tetrahedral cubes of increasing softness, balloons piled in a box, a
+//! shape-matched cube driven toward an animated pose, and a ball and a capsule filled with
+//! tetrahedral cells from their boundary meshes.
+
+use bevy::prelude::*;
+use bevy_rapier3d::parry::shape::{Ball, Capsule};
+use bevy_rapier3d::prelude::*;
+
+/// Marks the shape-matched cube driven toward an animated pose.
+#[derive(Component)]
+struct Driven;
+
+fn main() {
+    App::new()
+        .insert_resource(ClearColor(Color::srgb(
+            0xF9 as f32 / 255.0,
+            0xF9 as f32 / 255.0,
+            0xFF as f32 / 255.0,
+        )))
+        .add_plugins((
+            DefaultPlugins,
+            RapierPhysicsPlugin::<NoUserData>::default(),
+            RapierDebugRenderPlugin::default(),
+        ))
+        .add_systems(Startup, (setup_graphics, setup_physics))
+        .add_systems(Update, drive_cube)
+        .run();
+}
+
+fn setup_graphics(mut commands: Commands) {
+    commands.spawn((
+        Camera3d::default(),
+        Transform::from_xyz(8.0, 7.0, 14.0).looking_at(Vec3::new(0.0, 1.5, 1.0), Vec3::Y),
+    ));
+    commands.spawn((
+        DirectionalLight {
+            shadow_maps_enabled: true,
+            ..default()
+        },
+        Transform::from_xyz(5.0, 10.0, 5.0).looking_at(Vec3::ZERO, Vec3::Y),
+    ));
+}
+
+/// A corotational jelly material.
+fn jelly(young_modulus: f32, poisson_ratio: f32) -> SoftBodyMaterial {
+    SoftBodyMaterial(RapierSoftBodyMaterial {
+        young_modulus,
+        poisson_ratio,
+        elastic_damping_ratio: 0.5,
+        ..default()
+    })
+}
+
+fn setup_physics(
+    mut commands: Commands,
+    mut meshes: ResMut<Assets<Mesh>>,
+    mut materials: ResMut<Assets<StandardMaterial>>,
+) {
+    let rigid_color = materials.add(Color::srgb(0.4, 0.4, 0.45));
+
+    /*
+     * Ground and a container for the balloons.
+     */
+    commands.spawn((
+        Transform::from_xyz(0.0, -0.1, 0.0),
+        Collider::cuboid(12.0, 0.1, 12.0),
+    ));
+    for (dx, dz, hx, hz) in [
+        (-2.5, 0.0, 0.1, 2.5),
+        (2.5, 0.0, 0.1, 2.5),
+        (0.0, -2.5, 2.5, 0.1),
+        (0.0, 2.5, 2.5, 0.1),
+    ] {
+        commands.spawn((
+            Transform::from_xyz(dx + 5.0, 1.0, dz),
+            Collider::cuboid(hx, 1.0, hz),
+        ));
+    }
+
+    /*
+     * A stack of elastic cubes, softer at the top.
+     */
+    for (i, young_modulus) in [1.0e4, 4.0e3, 1.5e3].into_iter().enumerate() {
+        commands.spawn((
+            Transform::from_xyz(-4.0, 0.7 + 1.5 * i as f32, 0.0),
+            SoftBody::cuboid(Vec3::splat(0.6), 5, 5, 5).map(|b| {
+                b.cell_model(SoftBodyCellModel::Corotational)
+                    .particle_mass(0.1)
+            }),
+            jelly(young_modulus, 0.4),
+            SoftBodyMeshSync::default(),
+            MeshMaterial3d(materials.add(Color::srgb(0.3, 0.5 + 0.15 * i as f32, 0.4))),
+        ));
+    }
+
+    /*
+     * Balloons dropped in the container.
+     */
+    let balloon_color = materials.add(Color::srgb(0.9, 0.35, 0.35));
+    for i in 0..6 {
+        let x = 5.0 + ((i % 3) as f32 - 1.0) * 1.2;
+        let z = ((i / 3) as f32 - 0.5) * 1.2;
+        commands.spawn((
+            Transform::from_xyz(x, 2.0 + i as f32 * 1.5, z),
+            SoftBody::sphere(0.6, 2).map(|b| b.particle_mass(0.03)),
+            SoftBodyMaterial::uniform(15.0, 1.0),
+            SoftBodyVolumeFactor(1.1),
+            SoftBodyMeshSync::default(),
+            MeshMaterial3d(balloon_color.clone()),
+        ));
+    }
+
+    /*
+     * A shape-matched particle cube driven toward an animated pose: it behaves like a squishy
+     * kinematic body.
+     */
+    commands.spawn((
+        Driven,
+        Transform::from_xyz(0.45, 0.45, 0.45),
+        SoftBody::cuboid(Vec3::splat(0.45), 4, 4, 4).map(|b| {
+            b.shape_matching(true)
+                .particle_radius(0.1)
+                .particle_mass(0.2)
+                .gravity_scale(0.0)
+                .can_sleep(false)
+        }),
+        SoftBodyMaterial::uniform(15.0, 1.0),
+        // Shape-matches the whole-body cluster toward a target pose, animated by `drive_cube`.
+        SoftBodyClusterShapeMatching::default(),
+        SoftBodyMeshSync::default(),
+        MeshMaterial3d(materials.add(Color::srgb(0.95, 0.75, 0.2))),
+    ));
+
+    /*
+     * Volumetric jelly: a ball and a capsule filled with tetrahedral cells from their boundary
+     * meshes, dropped behind the stack.
+     */
+    let volumetric_color = materials.add(Color::srgb(0.55, 0.4, 0.85));
+    let (vertices, indices) = Ball::new(0.7).to_trimesh(16, 16);
+    if let Some(ball) = SoftBody::volumetric(&vertices, &indices, 0.2) {
+        commands.spawn((
+            Transform::from_xyz(-4.0, 3.0, -4.0),
+            ball.map(|b| {
+                b.cell_model(SoftBodyCellModel::Corotational)
+                    .particle_mass(0.05)
+            }),
+            jelly(1.0e4, 0.35),
+            Friction::coefficient(0.7),
+            SoftBodyMeshSync::default(),
+            MeshMaterial3d(volumetric_color.clone()),
+        ));
+    }
+    let (vertices, indices) = Capsule::new_y(0.6, 0.45).to_trimesh(12, 12);
+    if let Some(capsule) = SoftBody::volumetric(&vertices, &indices, 0.2) {
+        commands.spawn((
+            // The capsule is tilted by the transform of its entity.
+            Transform::from_xyz(-4.0, 6.0, -4.0).with_rotation(Quat::from_rotation_z(1.2)),
+            capsule.map(|b| {
+                b.cell_model(SoftBodyCellModel::Corotational)
+                    .particle_mass(0.05)
+            }),
+            jelly(3.0e4, 0.35),
+            Friction::coefficient(0.7),
+            SoftBodyMeshSync::default(),
+            MeshMaterial3d(volumetric_color),
+        ));
+    }
+
+    /*
+     * Rigid boxes to be shoved around by the driven cube.
+     */
+    let box_mesh = meshes.add(Cuboid::new(0.4, 0.4, 0.4));
+    for i in 0..8 {
+        commands.spawn((
+            Transform::from_xyz(
+                -0.5 + (i % 4) as f32 * 0.5,
+                0.25,
+                4.0 + (i / 4) as f32 * 0.5,
+            ),
+            RigidBody::Dynamic,
+            Collider::cuboid(0.2, 0.2, 0.2),
+            Mesh3d(box_mesh.clone()),
+            MeshMaterial3d(rigid_color.clone()),
+        ));
+    }
+}
+
+/// Drives the shape-matched cube around the rigid boxes at height 0.6, spinning.
+fn drive_cube(time: Res<Time>, mut driven: Query<&mut SoftBodyClusterShapeMatching, With<Driven>>) {
+    let t = time.elapsed_secs();
+    let target = Transform::from_xyz(2.0 * t.cos(), 0.6, 4.0 + 2.0 * t.sin())
+        .with_rotation(Quat::from_rotation_y(2.0 * t));
+    for mut shape_matching in &mut driven {
+        shape_matching.target = Some(target);
+    }
+}
diff --git a/bindings/bevy_rapier/bevy_rapier3d/examples/soft_joints3.rs b/bindings/bevy_rapier/bevy_rapier3d/examples/soft_joints3.rs
new file mode 100644
index 000000000..4a1292bab
--- /dev/null
+++ b/bindings/bevy_rapier/bevy_rapier3d/examples/soft_joints3.rs
@@ -0,0 +1,486 @@
+//! Impulse joints attached to soft bodies, through the soft body entities (for the whole body) or
+//! `SoftBodyCluster` entities: revolute, spherical, fixed, prismatic, rope, spring and generic
+//! joints between jellies, cloths and rigid or kinematic bodies, plus a hinge between two
+//! clusters of one soft bar, a jelly hanging from a multibody arm, and a kinematic cluster waving
+//! a banner.
+
+use bevy::prelude::*;
+use bevy_rapier3d::prelude::*;
+
+/// Marks the joint of the jelly shuttled along its rail.
+#[derive(Component)]
+struct RailJoint;
+
+/// Marks the hinge between the two halves of the soft bar.
+#[derive(Component)]
+struct FlapJoint;
+
+/// The kinematic body the cloth's corner is attached to, circling around `home`.
+#[derive(Component)]
+struct Mover {
+    home: Vec3,
+}
+
+/// The cluster of the banner's top edge, waved kinematically from its initial position.
+#[derive(Component)]
+struct Grip {
+    /// The initial position of the cluster's center.
+    home: Vec3,
+}
+
+fn main() {
+    App::new()
+        .insert_resource(ClearColor(Color::srgb(
+            0xF9 as f32 / 255.0,
+            0xF9 as f32 / 255.0,
+            0xFF as f32 / 255.0,
+        )))
+        .add_plugins((
+            DefaultPlugins,
+            RapierPhysicsPlugin::<NoUserData>::default(),
+            RapierDebugRenderPlugin::default(),
+        ))
+        .add_systems(Startup, (setup_graphics, setup_physics))
+        .add_systems(Update, (animate_motors, move_mover, wave_grip))
+        .run();
+}
+
+fn setup_graphics(mut commands: Commands) {
+    commands.spawn((
+        Camera3d::default(),
+        Transform::from_xyz(13.0, 9.0, 15.0).looking_at(Vec3::new(0.0, 1.5, 0.0), Vec3::Y),
+    ));
+    commands.spawn((
+        DirectionalLight {
+            shadow_maps_enabled: true,
+            ..default()
+        },
+        Transform::from_xyz(5.0, 10.0, 5.0).looking_at(Vec3::ZERO, Vec3::Y),
+    ));
+}
+
+/// The components of a jelly cube of 4x4x4 particles centered at `center`.
+fn jelly(
+    center: Vec3,
+    half_extents: Vec3,
+    young_modulus: f32,
+    color: &Handle<StandardMaterial>,
+) -> impl Bundle {
+    (
+        Transform::from_translation(center),
+        SoftBody::cuboid(half_extents, 4, 4, 4).map(|b| {
+            b.cell_model(SoftBodyCellModel::Corotational)
+                .particle_mass(0.08)
+                .particle_radius(0.06)
+        }),
+        SoftBodyMaterial(RapierSoftBodyMaterial {
+            young_modulus,
+            poisson_ratio: 0.35,
+            elastic_damping_ratio: 0.8,
+            ..default()
+        }),
+        Friction::coefficient(0.6),
+        SoftBodyMeshSync::default(),
+        MeshMaterial3d(color.clone()),
+    )
+}
+
+/// The centroid of the given particle positions.
+fn centroid(positions: &[Vec3], particles: &[u32]) -> Vec3 {
+    particles
+        .iter()
+        .map(|i| positions[*i as usize])
+        .sum::<Vec3>()
+        / particles.len() as f32
+}
+
+fn setup_physics(
+    mut commands: Commands,
+    mut meshes: ResMut<Assets<Mesh>>,
+    mut materials: ResMut<Assets<StandardMaterial>>,
+) {
+    let color = materials.add(Color::srgb(0.55, 0.75, 0.95));
+    let cloth_color = materials.add(StandardMaterial {
+        base_color: Color::srgb(0.9, 0.4, 0.3),
+        double_sided: true,
+        cull_mode: None,
+        ..default()
+    });
+    let rigid_color = materials.add(Color::srgb(0.4, 0.4, 0.45));
+
+    /*
+     * Ground.
+     */
+    commands.spawn((
+        Transform::from_xyz(0.0, -0.1, 0.0),
+        Collider::cuboid(18.0, 0.1, 18.0),
+    ));
+
+    /*
+     * Revolute + velocity motor: a jelly spun about Y at its center.
+     */
+    let center = Vec3::new(-6.0, 1.6, -4.0);
+    let spinner = commands
+        .spawn(jelly(center, Vec3::splat(0.5), 8.0e3, &color))
+        .id();
+    let pivot = commands
+        .spawn((Transform::from_translation(center), RigidBody::Fixed))
+        .id();
+    // A joint on a soft body entity attaches the whole soft body.
+    commands.entity(spinner).insert(ImpulseJoint::new(
+        pivot,
+        RevoluteJointBuilder::new(Vec3::Y).motor_velocity(1.5, 60.0),
+    ));
+
+    /*
+     * Spherical: a cloth's corner cluster follows a circling kinematic mover (two-way: the joint
+     * feels the cloth's weight). Particle `(i, j)` of a cloth is at `origin + i * du + j * dv`,
+     * with the index `i * nv + j`.
+     */
+    let (du, dv) = (Vec3::X * 0.16, Vec3::Z * 0.16);
+    let cloth_origin = Vec3::new(0.0, 2.6, 2.5);
+    let cloth = commands
+        .spawn((
+            Transform::from_translation(cloth_origin),
+            SoftBody::cloth(Vec3::ZERO, du, dv, 12, 12),
+            SoftBodyMeshSync::default(),
+            MeshMaterial3d(cloth_color.clone()),
+        ))
+        .id();
+    // The particles `(0, 0)`, `(0, 1)` and `(1, 0)`.
+    let corner_pos = cloth_origin + (du + dv) / 3.0;
+    let mover = commands
+        .spawn((
+            Mover { home: corner_pos },
+            Transform::from_translation(corner_pos),
+            RigidBody::KinematicPositionBased,
+        ))
+        .id();
+    commands.spawn((
+        SoftBodyCluster::new(cloth, [0, 1, 12]),
+        ImpulseJoint::new(mover, SphericalJointBuilder::new()),
+    ));
+
+    /*
+     * Fixed: a rigid plate welded flat onto a jelly's top-face cluster; the full-rank face
+     * cluster lets the weld hold the plate's orientation as the jelly wobbles.
+     */
+    let center = Vec3::new(-2.5, 0.61, -4.0);
+    let wobbler = SoftBody::cuboid(Vec3::splat(0.6), 4, 4, 4);
+    let positions = wobbler.builder.particle_positions().to_vec();
+    let top_face: Vec<u32> = (0..positions.len() as u32)
+        .filter(|i| positions[*i as usize].y > 0.6 - 1.0e-3)
+        .collect();
+    let top_pos = center + centroid(&positions, &top_face);
+    let wobbler = commands
+        .spawn(jelly(center, Vec3::splat(0.6), 2.5e3, &color))
+        .id();
+    let plate = commands
+        .spawn((
+            Transform::from_translation(top_pos + Vec3::new(0.0, 0.12, 0.0)),
+            RigidBody::Dynamic,
+            Collider::cuboid(0.7, 0.06, 0.7),
+            ColliderMassProperties::Density(0.4),
+            Mesh3d(meshes.add(Cuboid::new(1.4, 0.12, 1.4))),
+            MeshMaterial3d(rigid_color.clone()),
+        ))
+        .id();
+    commands.spawn((
+        SoftBodyCluster::new(wobbler, top_face),
+        ImpulseJoint::new(
+            plate,
+            FixedJointBuilder::new().local_anchor1(Vec3::new(0.0, -0.12, 0.0)),
+        ),
+    ));
+    // A small crate dropped on the plate to make it wobble.
+    commands.spawn((
+        Transform::from_translation(top_pos + Vec3::new(0.3, 1.4, 0.2)),
+        RigidBody::Dynamic,
+        Collider::cuboid(0.15, 0.15, 0.15),
+        ColliderMassProperties::Density(1.5),
+        Mesh3d(meshes.add(Cuboid::new(0.3, 0.3, 0.3))),
+        MeshMaterial3d(rigid_color.clone()),
+    ));
+
+    /*
+     * Prismatic + limits + position motor: a jelly shuttled along a rail between two stops.
+     */
+    let center = Vec3::new(2.0, 0.85, -4.0);
+    let shuttle = commands
+        .spawn(jelly(center, Vec3::splat(0.4), 6.0e3, &color))
+        .id();
+    let rail = commands
+        .spawn((Transform::from_translation(center), RigidBody::Fixed))
+        .id();
+    commands.entity(shuttle).insert((
+        RailJoint,
+        ImpulseJoint::new(
+            rail,
+            PrismaticJointBuilder::new(Vec3::X)
+                .limits([-1.8, 1.8])
+                .motor_position(0.0, 40.0, 8.0),
+        ),
+    ));
+
+    /*
+     * Rope: two jellies chained over a ledge, one dragging the other.
+     */
+    commands.spawn((
+        Transform::from_xyz(-1.0, 1.0, -9.0),
+        Collider::cuboid(1.6, 1.0, 1.2),
+        Mesh3d(meshes.add(Cuboid::new(3.2, 2.0, 2.4))),
+        MeshMaterial3d(rigid_color.clone()),
+    ));
+    let anchor_jelly = commands
+        .spawn(jelly(
+            Vec3::new(-1.0, 2.6, -9.0),
+            Vec3::splat(0.5),
+            1.2e4,
+            &color,
+        ))
+        .id();
+    let hanging_jelly = commands
+        .spawn(jelly(
+            Vec3::new(1.6, 2.6, -9.0),
+            Vec3::splat(0.5),
+            1.2e4,
+            &color,
+        ))
+        .id();
+    commands
+        .entity(hanging_jelly)
+        .insert(ImpulseJoint::new(anchor_jelly, RopeJointBuilder::new(2.2)));
+
+    /*
+     * Spring: a bungee jelly bouncing under a gantry.
+     */
+    let bungee = commands
+        .spawn(jelly(
+            Vec3::new(5.5, 3.2, 2.5),
+            Vec3::splat(0.45),
+            6.0e3,
+            &color,
+        ))
+        .id();
+    let gantry = commands
+        .spawn((Transform::from_xyz(5.5, 5.5, 2.5), RigidBody::Fixed))
+        .id();
+    commands.entity(bungee).insert(ImpulseJoint::new(
+        gantry,
+        SpringJointBuilder::new(1.2, 25.0, 1.5),
+    ));
+
+    /*
+     * Generic: a jelly bead on a pole, translations locked to the pole's Y axis (limited along
+     * it) and every rotation free: a 3D pin-slot joint spelled as a generic joint. The pole
+     * collides with nothing: the bead's particles would otherwise rest on it.
+     */
+    let pole_base = Vec3::new(8.5, 0.0, -4.0);
+    let pole = commands
+        .spawn((
+            Transform::from_translation(pole_base + Vec3::new(0.0, 2.5, 0.0)),
+            RigidBody::Fixed,
+            Collider::cylinder(2.5, 0.05),
+            CollisionGroups::new(Group::NONE, Group::NONE),
+        ))
+        .id();
+    let bead = commands
+        .spawn(jelly(
+            pole_base + Vec3::new(0.0, 4.2, 0.0),
+            Vec3::splat(0.35),
+            8.0e3,
+            &color,
+        ))
+        .id();
+    commands.entity(bead).insert(ImpulseJoint::new(
+        pole,
+        GenericJointBuilder::new(JointAxesMask::LIN_X | JointAxesMask::LIN_Z)
+            .local_axis1(Vec3::Y)
+            .local_axis2(Vec3::Y)
+            .limits(JointAxis::LinY, [-1.8, 1.8]),
+    ));
+
+    /*
+     * Same-soft-body joint: one soft bar whose two disjoint half clusters are hinged by a
+     * motorized revolute at its middle, so the body folds and flaps at its own hinge.
+     */
+    let bar_center = Vec3::new(2.5, 2.2, 5.5);
+    let bar = SoftBody::cuboid(Vec3::new(1.0, 0.22, 0.4), 7, 3, 3).map(|b| {
+        b.cell_model(SoftBodyCellModel::Corotational)
+            .particle_mass(0.08)
+            .particle_radius(0.06)
+    });
+    let positions: Vec<Vec3> = bar
+        .builder
+        .particle_positions()
+        .iter()
+        .map(|p| bar_center + *p)
+        .collect();
+    let left_half: Vec<u32> = (0..positions.len() as u32)
+        .filter(|i| positions[*i as usize].x < bar_center.x - 1.0e-3)
+        .collect();
+    let right_half: Vec<u32> = (0..positions.len() as u32)
+        .filter(|i| positions[*i as usize].x > bar_center.x + 1.0e-3)
+        .collect();
+    let left_pos = centroid(&positions, &left_half);
+    let right_pos = centroid(&positions, &right_half);
+    let bar = commands
+        .spawn((
+            Transform::from_translation(bar_center),
+            bar,
+            SoftBodyMaterial(RapierSoftBodyMaterial {
+                young_modulus: 2.0e4,
+                poisson_ratio: 0.35,
+                elastic_damping_ratio: 1.0,
+                ..default()
+            }),
+            SoftBodyMeshSync::default(),
+            MeshMaterial3d(color.clone()),
+        ))
+        .id();
+    // Hold the bar's left half in the air, then flap the right half about the middle hinge.
+    let bar_anchor = commands
+        .spawn((Transform::from_translation(left_pos), RigidBody::Fixed))
+        .id();
+    let left_cluster = commands
+        .spawn((
+            SoftBodyCluster::new(bar, left_half),
+            ImpulseJoint::new(bar_anchor, FixedJointBuilder::new()),
+        ))
+        .id();
+    commands.spawn((
+        FlapJoint,
+        SoftBodyCluster::new(bar, right_half),
+        ImpulseJoint::new(
+            left_cluster,
+            RevoluteJointBuilder::new(Vec3::Z)
+                .local_anchor1(bar_center - left_pos)
+                .local_anchor2(bar_center - right_pos)
+                .motor_position(0.0, 80.0, 10.0),
+        ),
+    ));
+
+    /*
+     * Multibody + rigid on one soft body: a jelly hanging from a two-link multibody arm while a
+     * rope joint ties the same jelly to a rigid crate on the ground.
+     */
+    let arm_root = commands
+        .spawn((Transform::from_xyz(7.0, 5.0, 6.0), RigidBody::Fixed))
+        .id();
+    let link1 = commands
+        .spawn((
+            Transform::from_xyz(8.2, 5.0, 6.0),
+            RigidBody::Dynamic,
+            Collider::capsule_x(0.5, 0.08),
+            ColliderMassProperties::Density(2.0),
+            MultibodyJoint::new(
+                arm_root,
+                RevoluteJointBuilder::new(Vec3::Z).local_anchor2(Vec3::new(-1.2, 0.0, 0.0)),
+            ),
+        ))
+        .id();
+    let link2 = commands
+        .spawn((
+            Transform::from_xyz(9.4, 5.0, 6.0),
+            RigidBody::Dynamic,
+            Collider::capsule_x(0.5, 0.08),
+            ColliderMassProperties::Density(2.0),
+            MultibodyJoint::new(
+                link1,
+                RevoluteJointBuilder::new(Vec3::Z)
+                    .local_anchor1(Vec3::new(0.6, 0.0, 0.0))
+                    .local_anchor2(Vec3::new(-0.6, 0.0, 0.0)),
+            ),
+        ))
+        .id();
+    let pendulum = commands
+        .spawn(jelly(
+            Vec3::new(10.2, 4.2, 6.0),
+            Vec3::splat(0.5),
+            5.0e3,
+            &color,
+        ))
+        .id();
+    commands.entity(pendulum).insert(ImpulseJoint::new(
+        link2,
+        SphericalJointBuilder::new()
+            .local_anchor1(Vec3::new(0.7, 0.0, 0.0))
+            .local_anchor2(Vec3::new(0.0, 0.6, 0.0)),
+    ));
+    commands.spawn((
+        Transform::from_xyz(10.2, 0.3, 6.0),
+        RigidBody::Dynamic,
+        Collider::cuboid(0.3, 0.3, 0.3),
+        ColliderMassProperties::Density(0.5),
+        ImpulseJoint::new(pendulum, RopeJointBuilder::new(3.2)),
+        Mesh3d(meshes.add(Cuboid::new(0.6, 0.6, 0.6))),
+        MeshMaterial3d(rigid_color),
+    ));
+
+    /*
+     * Kinematic cluster (no joint): a banner whose pinned top-edge cluster (the particles
+     * `(i, 0)`) is waved rigidly.
+     */
+    let (du, dv) = (Vec3::X * 0.18, Vec3::NEG_Y * 0.18);
+    let banner_origin = Vec3::new(-8.0, 3.2, 4.0);
+    let banner = commands
+        .spawn((
+            Transform::from_translation(banner_origin),
+            SoftBody::cloth(Vec3::ZERO, du, dv, 14, 10),
+            SoftBodyMeshSync::default(),
+            MeshMaterial3d(cloth_color),
+        ))
+        .id();
+    let home = banner_origin + du * 6.5;
+    commands.spawn((
+        SoftBodyCluster::new(banner, (0..14).map(|i| i * 10)),
+        Grip { home },
+        // Pins the cluster, and moves it to this pose.
+        SoftBodyClusterKinematicTarget(Transform::from_translation(home)),
+    ));
+}
+
+/// Moves the targets of the prismatic and flapping motors.
+fn animate_motors(
+    time: Res<Time>,
+    mut rail_joints: Query<&mut ImpulseJoint, (With<RailJoint>, Without<FlapJoint>)>,
+    mut flap_joints: Query<&mut ImpulseJoint, With<FlapJoint>>,
+) {
+    let t = time.elapsed_secs();
+    for mut joint in &mut rail_joints {
+        joint
+            .data
+            .as_mut()
+            .set_motor_position(JointAxis::LinX, 1.5 * (0.6 * t).sin(), 40.0, 8.0);
+    }
+    // The free axis of a revolute joint is its local `AngX`.
+    for mut joint in &mut flap_joints {
+        joint
+            .data
+            .as_mut()
+            .set_motor_position(JointAxis::AngX, 0.8 * (1.4 * t).sin(), 80.0, 10.0);
+    }
+}
+
+/// Circles the kinematic body the cloth's corner is attached to.
+fn move_mover(time: Res<Time>, mut movers: Query<(&Mover, &mut Transform)>) {
+    let t = time.elapsed_secs();
+    for (mover, mut transform) in &mut movers {
+        transform.translation = mover.home
+            + Vec3::new(
+                1.2 * (0.8 * t).sin(),
+                0.4 * (1.3 * t).sin(),
+                1.2 * (0.8 * t).cos() - 1.2,
+            );
+    }
+}
+
+/// Waves the grip cluster along a kinematic path.
+fn wave_grip(time: Res<Time>, mut grips: Query<(&Grip, &mut SoftBodyClusterKinematicTarget)>) {
+    let t = time.elapsed_secs();
+    for (grip, mut target) in &mut grips {
+        let position = grip.home + Vec3::new(1.5 * (0.7 * t).sin(), 0.2 * (1.9 * t).sin(), 0.0);
+        target.0 = Transform::from_translation(position)
+            .with_rotation(Quat::from_axis_angle(Vec3::X, 0.35 * (1.1 * t).sin()));
+    }
+}
diff --git a/bindings/bevy_rapier/bevy_rapier3d/examples/soft_meshes3.rs b/bindings/bevy_rapier/bevy_rapier3d/examples/soft_meshes3.rs
new file mode 100644
index 000000000..427b0a79d
--- /dev/null
+++ b/bindings/bevy_rapier/bevy_rapier3d/examples/soft_meshes3.rs
@@ -0,0 +1,222 @@
+//! Collision meshes owned by clusters: a jelly wearing a fine skinned sensor over its coarse
+//! cells, a jelly whose top cluster carries a rigid plate, and a jelly split into two clusters
+//! whose own deformable meshes collide with each other.
+
+use std::collections::HashMap;
+
+use bevy::prelude::*;
+use bevy_rapier3d::parry::shape::Ball;
+use bevy_rapier3d::prelude::*;
+
+fn main() {
+    App::new()
+        .insert_resource(ClearColor(Color::srgb(
+            0xF9 as f32 / 255.0,
+            0xF9 as f32 / 255.0,
+            0xFF as f32 / 255.0,
+        )))
+        .add_plugins((
+            DefaultPlugins,
+            RapierPhysicsPlugin::<NoUserData>::default(),
+            RapierDebugRenderPlugin::default(),
+        ))
+        .add_systems(Startup, (setup_graphics, setup_physics))
+        .run();
+}
+
+fn setup_graphics(mut commands: Commands) {
+    commands.spawn((
+        Camera3d::default(),
+        Transform::from_xyz(-6.0, 4.0, 8.0).looking_at(Vec3::new(0.0, 1.0, 0.0), Vec3::Y),
+    ));
+    commands.spawn((
+        DirectionalLight {
+            shadow_maps_enabled: true,
+            ..default()
+        },
+        Transform::from_xyz(5.0, 10.0, 5.0).looking_at(Vec3::ZERO, Vec3::Y),
+    ));
+}
+
+/// A corotational jelly cube of 4x4x4 particles.
+fn jelly(young_modulus: f32) -> (SoftBody, SoftBodyMaterial, Friction) {
+    (
+        SoftBody::cuboid(Vec3::splat(0.6), 4, 4, 4).map(|b| {
+            b.cell_model(SoftBodyCellModel::Corotational)
+                .particle_mass(0.1)
+                .particle_radius(0.05)
+        }),
+        SoftBodyMaterial(RapierSoftBodyMaterial {
+            young_modulus,
+            poisson_ratio: 0.4,
+            elastic_damping_ratio: 0.5,
+            ..default()
+        }),
+        Friction::coefficient(0.7),
+    )
+}
+
+fn setup_physics(
+    mut commands: Commands,
+    mut meshes: ResMut<Assets<Mesh>>,
+    mut materials: ResMut<Assets<StandardMaterial>>,
+) {
+    let jelly_color = materials.add(Color::srgb(0.55, 0.75, 0.95));
+    let rigid_color = materials.add(Color::srgb(0.4, 0.4, 0.45));
+
+    commands.spawn((
+        Transform::from_xyz(0.0, -0.1, 0.0),
+        Collider::cuboid(12.0, 0.1, 12.0),
+    ));
+
+    /*
+     * A jelly wearing a second, skinned ball-shaped sensor, bound to the cells it lies in.
+     */
+    let center = Vec3::new(-3.0, 1.2, 0.0);
+    let skinned = commands
+        .spawn((
+            Transform::from_translation(center),
+            jelly(2.0e2),
+            SoftBodyMeshSync::default(),
+            MeshMaterial3d(jelly_color.clone()),
+        ))
+        .id();
+    // The vertices of a deformable collider are placed by its entity's transform.
+    let (vertices, indices) = Ball::new(1.2).to_trimesh(20, 20);
+    commands.spawn((
+        Transform::from_translation(center),
+        Collider::trimesh_with_flags(vertices, indices, TriMeshFlags::DEFORMABLE)
+            .expect("a valid ball mesh"),
+        Sensor,
+        DeformableCollider::new(skinned, SoftMeshBinding::skinned()),
+    ));
+
+    /*
+     * A jelly whose top cluster carries a rigid plate: the load on the plate reaches the
+     * particles through the cluster's frame.
+     */
+    let center = Vec3::new(0.0, 1.2, 0.0);
+    let (plated, material, friction) = jelly(4.0e2);
+    let top: Vec<u32> = (0..)
+        .zip(plated.builder.particle_positions())
+        .filter(|(_, p)| p.y > 0.3)
+        .map(|(i, _)| i)
+        .collect();
+    let plated = commands
+        .spawn((
+            Transform::from_translation(center),
+            plated,
+            material,
+            friction,
+            SoftBodyMeshSync::default(),
+            MeshMaterial3d(jelly_color.clone()),
+        ))
+        .id();
+    // A child of a cluster entity is attached to the cluster's proxy like to any rigid-body.
+    commands
+        .spawn(SoftBodyCluster::new(plated, top))
+        .with_child((
+            Transform::from_xyz(0.0, 0.65, 0.0),
+            Collider::cuboid(0.7, 0.05, 0.7),
+            Mesh3d(meshes.add(Cuboid::new(1.4, 0.1, 1.4))),
+            MeshMaterial3d(rigid_color.clone()),
+        ));
+
+    /*
+     * A jelly split into two clusters, each with a mesh of its own: they collide with each other
+     * (both opted into self contacts) because their clusters share no particle.
+     */
+    let center = Vec3::new(3.0, 1.2, 0.0);
+    let (split, material, friction) = jelly(4.0e2);
+    let split = split.map(|b| b.no_surface_collider());
+    let (left, right): (Vec<u32>, Vec<u32>) = (0..split.builder.particle_positions().len() as u32)
+        .partition(|i| split.builder.particle_positions()[*i as usize].x < 0.0);
+    let halves = [left, right].map(|half| {
+        let (vertices, indices) = cluster_surface(&split, &half);
+        (half, vertices, indices)
+    });
+    let split = commands
+        .spawn((
+            Transform::from_translation(center),
+            split,
+            material,
+            friction,
+            SoftBodyMeshSync::default(),
+            MeshMaterial3d(jelly_color),
+        ))
+        .id();
+    for (half, vertices, indices) in halves {
+        let cluster = commands
+            .spawn((SoftBodyCluster::new(split, half.iter().copied()),))
+            .id();
+        commands.spawn((
+            Transform::from_translation(center),
+            Collider::trimesh_with_flags(vertices, indices, TriMeshFlags::DEFORMABLE)
+                .expect("a valid half surface"),
+            Friction::coefficient(0.7),
+            // Both halves opt in: their clusters share no particle, so their meshes may meet.
+            DeformableCollider::new(cluster, SoftMeshBinding::direct(half).self_contacts(true)),
+        ));
+    }
+
+    /*
+     * Something to drop on all three.
+     */
+    let box_mesh = meshes.add(Cuboid::new(0.6, 0.6, 0.6));
+    for (i, x) in [-3.0, 0.0, 3.0].into_iter().enumerate() {
+        commands.spawn((
+            Transform::from_xyz(x, 4.0 + i as f32, 0.0),
+            RigidBody::Dynamic,
+            Collider::cuboid(0.3, 0.3, 0.3),
+            ColliderMassProperties::Density(4.0),
+            Mesh3d(box_mesh.clone()),
+            MeshMaterial3d(rigid_color.clone()),
+        ));
+    }
+}
+
+/// The closed surface of the cells a set of particles owns, in the soft body's local frame: every
+/// face no second owned cell shares, oriented outward. The vertex `i` is the particle
+/// `particles[i]`, so a half's surface caps the cut with particles from inside the body.
+fn cluster_surface(body: &SoftBody, particles: &[u32]) -> (Vec<Vec3>, Vec<[u32; 3]>) {
+    let positions = body.builder.particle_positions();
+    let mut vertex_of = vec![u32::MAX; positions.len()];
+    for (vertex, particle) in particles.iter().enumerate() {
+        vertex_of[*particle as usize] = vertex as u32;
+    }
+    let vertices = particles.iter().map(|i| positions[*i as usize]).collect();
+
+    // Every face of every owned cell, keyed by its sorted vertices: a face shared by two of them
+    // is interior to the half.
+    let mut faces: HashMap<[u32; 3], ([u32; 3], Vec3, usize)> = HashMap::new();
+    for cell in &body.builder.cells {
+        if cell.iter().any(|v| vertex_of[*v as usize] == u32::MAX) {
+            continue;
+        }
+        let centroid = cell.iter().map(|v| positions[*v as usize]).sum::<Vec3>() / 4.0;
+        for k in 0..4 {
+            let face = [cell[(k + 1) % 4], cell[(k + 2) % 4], cell[(k + 3) % 4]];
+            let mut key = face;
+            key.sort_unstable();
+            faces.entry(key).or_insert((face, centroid, 0)).2 += 1;
+        }
+    }
+
+    let indices = faces
+        .values()
+        .filter(|(_, _, count)| *count == 1)
+        .map(|(face, centroid, _)| {
+            let p = face.map(|v| positions[v as usize]);
+            // Outward winding: the face's normal points away from its cell.
+            let normal = (p[1] - p[0]).cross(p[2] - p[0]);
+            let face = if normal.dot((p[0] + p[1] + p[2]) / 3.0 - *centroid) < 0.0 {
+                [face[0], face[2], face[1]]
+            } else {
+                *face
+            };
+            face.map(|v| vertex_of[v as usize])
+        })
+        .collect();
+
+    (vertices, indices)
+}
diff --git a/bindings/bevy_rapier/bevy_rapier3d/examples/soft_tearing3.rs b/bindings/bevy_rapier/bevy_rapier3d/examples/soft_tearing3.rs
new file mode 100644
index 000000000..e901abce4
--- /dev/null
+++ b/bindings/bevy_rapier/bevy_rapier3d/examples/soft_tearing3.rs
@@ -0,0 +1,304 @@
+//! Tearing (`tear_strain`): a pinned sheet ripped by a dropped ball, a curtain shot through by a
+//! box, and a jelly bar pulled apart by its pinned ends. Cloth springs are stiff (100 Hz) so only
+//! impacts pass the tear strain. Torn-off pieces become soft body entities of their own.
+//!
+//! Every `SoftBodyTearEvent` is logged and its cracks flash red. Press the up/down arrows to set
+//! the smallest piece a tear may split off, and `D` to restore the default (10 triangles or 6
+//! cells).
+
+use bevy::prelude::*;
+use bevy_rapier3d::prelude::*;
+
+/// The smallest piece a tear may split off (`None` for Rapier's default), applied to every soft
+/// body.
+#[derive(Resource, Default)]
+struct MinPiece(Option<u32>);
+
+/// Marks the text showing [`MinPiece`].
+#[derive(Component)]
+struct MinPieceText;
+
+/// Where recent cracks opened, with their remaining display time.
+#[derive(Resource, Default)]
+struct TearMarks(Vec<(Vec3, f32)>);
+
+fn main() {
+    App::new()
+        .insert_resource(ClearColor(Color::srgb(
+            0xF9 as f32 / 255.0,
+            0xF9 as f32 / 255.0,
+            0xFF as f32 / 255.0,
+        )))
+        .init_resource::<MinPiece>()
+        .init_resource::<TearMarks>()
+        .add_plugins((
+            DefaultPlugins,
+            RapierPhysicsPlugin::<NoUserData>::default(),
+            RapierDebugRenderPlugin::default(),
+        ))
+        .add_systems(Startup, (setup_graphics, setup_physics))
+        .add_systems(
+            Update,
+            (
+                drive_bar,
+                (log_tears, draw_tear_marks).chain(),
+                update_min_piece,
+            ),
+        )
+        .run();
+}
+
+fn setup_graphics(mut commands: Commands) {
+    commands.spawn((
+        Camera3d::default(),
+        Transform::from_xyz(9.0, 8.0, 16.0).looking_at(Vec3::new(0.0, 1.5, 1.0), Vec3::Y),
+    ));
+    commands.spawn((
+        DirectionalLight {
+            shadow_maps_enabled: true,
+            ..default()
+        },
+        Transform::from_xyz(5.0, 10.0, 5.0).looking_at(Vec3::ZERO, Vec3::Y),
+    ));
+    commands.spawn((
+        MinPieceText,
+        Text::new(""),
+        TextColor(Color::BLACK),
+        Node {
+            position_type: PositionType::Absolute,
+            top: Val::Px(10.0),
+            left: Val::Px(10.0),
+            ..default()
+        },
+    ));
+}
+
+/// A cloth material with stiff springs, tearing past `tear_strain`.
+fn stiff_cloth(tear_strain: f32) -> SoftBodyMaterial {
+    SoftBodyMaterial(RapierSoftBodyMaterial {
+        bend_softness: SpringCoefficients::new(3.0, 1.0),
+        tear_strain: Some(tear_strain),
+        ..RapierSoftBodyMaterial::uniform(SpringCoefficients::new(100.0, 1.0))
+    })
+}
+
+/// A double-sided material, for cloths.
+fn cloth_material(color: Color) -> StandardMaterial {
+    StandardMaterial {
+        base_color: color,
+        double_sided: true,
+        cull_mode: None,
+        ..default()
+    }
+}
+
+fn setup_physics(
+    mut commands: Commands,
+    mut meshes: ResMut<Assets<Mesh>>,
+    mut materials: ResMut<Assets<StandardMaterial>>,
+) {
+    let projectile_color = materials.add(Color::srgb(0.3, 0.3, 0.35));
+
+    /*
+     * Ground.
+     */
+    commands.spawn((
+        Transform::from_xyz(0.0, -0.1, 0.0),
+        Collider::cuboid(30.0, 0.1, 30.0),
+    ));
+
+    /*
+     * A sheet pinned along its border: the heavy ball dropped on it rips through. Particle
+     * `(i, j)` of a cloth has the index `i * nv + j`.
+     */
+    let n = 40;
+    let border = (0..n * n).filter(move |k| {
+        let (i, j) = (k / n, k % n);
+        i == 0 || j == 0 || i == n - 1 || j == n - 1
+    });
+    commands.spawn((
+        Transform::from_xyz(-6.0, 3.0, -2.0),
+        SoftBody::cloth(
+            Vec3::ZERO,
+            Vec3::X * 0.1,
+            Vec3::Z * 0.1,
+            n as usize,
+            n as usize,
+        )
+        .map(|b| b.pinned_particles(border).particle_mass(0.02)),
+        stiff_cloth(0.4),
+        Friction::coefficient(0.8),
+        SoftBodyMeshSync::default(),
+        MeshMaterial3d(materials.add(cloth_material(Color::srgb(0.8, 0.2, 0.2)))),
+    ));
+    commands.spawn((
+        Transform::from_xyz(-4.0, 6.0, 0.0),
+        RigidBody::Dynamic,
+        Collider::ball(0.6),
+        ColliderMassProperties::Density(30.0),
+        Mesh3d(meshes.add(Sphere::new(0.6))),
+        MeshMaterial3d(projectile_color.clone()),
+    ));
+
+    /*
+     * A curtain pinned along its top edge, with a heavy box shot through it.
+     */
+    commands.spawn((
+        Transform::from_xyz(0.0, 4.5, 4.0),
+        SoftBody::cloth(Vec3::ZERO, Vec3::X * 0.1, Vec3::NEG_Y * 0.1, 50, 40).map(|b| {
+            b.pinned_particles((0..50).map(|i| i * 40))
+                .particle_mass(0.02)
+        }),
+        stiff_cloth(0.2),
+        SoftBodyMeshSync::default(),
+        MeshMaterial3d(materials.add(cloth_material(Color::srgb(0.2, 0.5, 0.8)))),
+    ));
+    commands.spawn((
+        Transform::from_xyz(2.5, 2.5, 12.0).with_rotation(Quat::from_scaled_axis(Vec3::splat(0.5))),
+        RigidBody::Dynamic,
+        Velocity::linear(Vec3::new(0.0, 0.0, -25.0)),
+        Collider::cuboid(0.3, 0.3, 0.3),
+        ColliderMassProperties::Density(20.0),
+        Mesh3d(meshes.add(Cuboid::new(0.6, 0.6, 0.6))),
+        MeshMaterial3d(projectile_color),
+    ));
+
+    /*
+     * A jelly bar pinned at both ends: the right end is pulled away until the bar snaps.
+     */
+    let bar_center = Vec3::new(3.0, 1.0, -4.0);
+    let bar = SoftBody::cuboid(Vec3::new(2.0, 0.4, 0.4), 21, 5, 5).map(|b| {
+        b.cell_model(SoftBodyCellModel::Corotational)
+            .particle_mass(0.05)
+    });
+    let positions = bar.builder.particle_positions().to_vec();
+    let left: Vec<u32> = (0..positions.len() as u32)
+        .filter(|i| positions[*i as usize].x < -1.99)
+        .collect();
+    let right: Vec<u32> = (0..positions.len() as u32)
+        .filter(|i| positions[*i as usize].x > 1.99)
+        .collect();
+    let pinned: Vec<u32> = left.iter().chain(&right).copied().collect();
+    commands.spawn((
+        Transform::from_translation(bar_center),
+        bar.map(|b| b.pinned_particles(pinned)),
+        // The right end is dragged by moving these targets (see `drive_bar`). A tear moves
+        // them to the pieces holding their particles.
+        SoftBodyKinematicTargets(
+            right
+                .iter()
+                .map(|i| (*i, bar_center + positions[*i as usize]))
+                .collect(),
+        ),
+        // Stiff enough not to tear from sagging between its pinned ends.
+        SoftBodyMaterial(RapierSoftBodyMaterial {
+            young_modulus: 5.0e4,
+            poisson_ratio: 0.3,
+            elastic_damping_ratio: 1.0,
+            tear_strain: Some(0.4),
+            ..default()
+        }),
+        Friction::coefficient(0.8),
+        SoftBodyMeshSync::default(),
+        MeshMaterial3d(materials.add(Color::srgb(0.55, 0.8, 0.6))),
+    ));
+}
+
+/// Drags the right end of the bar by moving its kinematic targets.
+fn drive_bar(
+    time: Res<Time>,
+    mut last_shift: Local<f32>,
+    mut targets: Query<&mut SoftBodyKinematicTargets>,
+) {
+    // The right end starts moving after a second, at half a meter per second, and stops once
+    // the bar has doubled its length.
+    let shift = ((time.elapsed_secs() - 1.0).max(0.0) * 0.5).min(4.0);
+    let delta = shift - std::mem::replace(&mut *last_shift, shift);
+    if delta == 0.0 {
+        return;
+    }
+    for mut targets in &mut targets {
+        for (_, target) in &mut targets.0 {
+            *target += Vec3::new(delta, 0.0, 0.0);
+        }
+    }
+}
+
+/// Logs the tears, and remembers where their cracks opened.
+fn log_tears(
+    context: ReadRapierContext,
+    mut tears: MessageReader<SoftBodyTearEvent>,
+    mut marks: ResMut<TearMarks>,
+) {
+    let Ok(context) = context.single() else {
+        return;
+    };
+    for tear in tears.read() {
+        let pieces: Vec<_> = tear.pieces.iter().map(|piece| piece.soft_body).collect();
+        info!(
+            "Soft body {} tore: {} edges and {} cells cracked, pieces: {pieces:?}",
+            tear.soft_body,
+            tear.raw.torn_edges.len(),
+            tear.raw.torn_cells.len(),
+        );
+
+        // The current position of a particle of the torn body (a post-tear index).
+        let position = |particle: u32| {
+            let (handle, i) = tear.raw.particle_destination(particle)?;
+            let sb = context.rigidbody_set.soft_bodies.get(handle)?;
+            (i < sb.num_particles() as u32).then(|| sb.particle_position(i as usize))
+        };
+        let edges = tear.raw.torn_edges.iter().map(|e| e.as_slice());
+        let cells = tear.raw.torn_cells.iter().map(|c| c.as_slice());
+        for element in edges.chain(cells) {
+            let points: Option<Vec<Vec3>> = element.iter().map(|v| position(*v)).collect();
+            if let Some(points) = points {
+                let center = points.iter().sum::<Vec3>() / points.len() as f32;
+                marks.0.push((center, 1.0));
+            }
+        }
+    }
+}
+
+/// Draws the recent cracks, fading out over a second.
+fn draw_tear_marks(time: Res<Time>, mut marks: ResMut<TearMarks>, mut gizmos: Gizmos) {
+    for (center, life) in &mut marks.0 {
+        gizmos.sphere(*center, 0.05, Color::srgba(0.9, 0.1, 0.1, *life));
+        *life -= time.delta_secs();
+    }
+    marks.0.retain(|(_, life)| *life > 0.0);
+}
+
+/// Changes the smallest piece a tear may split off with the keyboard.
+fn update_min_piece(
+    keys: Res<ButtonInput<KeyCode>>,
+    mut min_piece: ResMut<MinPiece>,
+    mut soft_bodies: Query<&mut SoftBodyMaterial>,
+    mut text: Query<&mut Text, With<MinPieceText>>,
+) {
+    if keys.just_pressed(KeyCode::ArrowUp) {
+        min_piece.0 = Some(min_piece.0.map_or(6, |n| (n + 1).min(40)));
+    }
+    if keys.just_pressed(KeyCode::ArrowDown) {
+        min_piece.0 = Some(min_piece.0.map_or(6, |n| n.saturating_sub(1).max(1)));
+    }
+    if keys.just_pressed(KeyCode::KeyD) {
+        min_piece.0 = None;
+    }
+    if !min_piece.is_changed() {
+        return;
+    }
+
+    // The pieces split off by a tear are clones of their soft body's entity, material included.
+    for mut material in &mut soft_bodies {
+        material.min_piece = min_piece.0;
+    }
+    for mut text in &mut text {
+        text.0 = match min_piece.0 {
+            Some(n) => format!("Minimum piece: {n} elements (up/down, D for default)"),
+            None => {
+                "Minimum piece: default, 10 triangles or 6 cells (up/down to change)".to_string()
+            }
+        };
+    }
+}
diff --git a/bindings/bevy_rapier/bevy_rapier3d/examples/spring_joints3.rs b/bindings/bevy_rapier/bevy_rapier3d/examples/spring_joints3.rs
new file mode 100644
index 000000000..a9e254b89
--- /dev/null
+++ b/bindings/bevy_rapier/bevy_rapier3d/examples/spring_joints3.rs
@@ -0,0 +1,73 @@
+//! Spring joints with increasing damping: each ball hangs above a fixed anchor point with a spring
+//! whose damping ratio goes from zero (left) to twice the critical damping (right), with the
+//! middle one critically damped. Heavy boxes fall on the balls to excite the springs.
+
+use bevy::prelude::*;
+use bevy_rapier3d::prelude::*;
+
+fn main() {
+    App::new()
+        .insert_resource(ClearColor(Color::srgb(
+            0xF9 as f32 / 255.0,
+            0xF9 as f32 / 255.0,
+            0xFF as f32 / 255.0,
+        )))
+        .add_plugins((
+            DefaultPlugins,
+            RapierPhysicsPlugin::<NoUserData>::default(),
+            RapierDebugRenderPlugin::default(),
+        ))
+        .add_systems(Startup, (setup_graphics, setup_physics))
+        .run();
+}
+
+pub fn setup_graphics(mut commands: Commands) {
+    commands.spawn((
+        Camera3d::default(),
+        Transform::from_xyz(15.0, 5.0, 42.0).looking_at(Vec3::new(13.0, 1.0, 1.0), Vec3::Y),
+    ));
+}
+
+pub fn setup_physics(mut commands: Commands) {
+    /*
+     * Fixed ground to attach one end of the joints.
+     */
+    let ground = commands
+        .spawn((Transform::default(), RigidBody::Fixed))
+        .id();
+
+    /*
+     * Spring joints with a variety of damping ratios.
+     */
+    let num = 30;
+    let radius = 0.5;
+    // The mass of a ball with a density of 1.
+    let mass = 4.0 / 3.0 * std::f32::consts::PI * radius * radius * radius;
+    let stiffness = 1.0e3;
+    let critical_damping = 2.0 * (stiffness * mass).sqrt();
+
+    for i in 0..=num {
+        let x_pos = -6.0 + 1.5 * i as f32;
+        let ball_pos = Vec3::new(x_pos, 4.5, 0.0);
+        let damping_ratio = i as f32 / (num as f32 / 2.0);
+        let damping = damping_ratio * critical_damping;
+        let joint = SpringJointBuilder::new(0.0, stiffness, damping)
+            .local_anchor1(ball_pos - Vec3::Y * 3.0);
+
+        commands.spawn((
+            Transform::from_translation(ball_pos),
+            RigidBody::Dynamic,
+            Sleeping::disabled(),
+            Collider::ball(radius),
+            ImpulseJoint::new(ground, joint),
+        ));
+
+        // A heavy box falling on top of the ball, to make the springs more interesting to watch.
+        commands.spawn((
+            Transform::from_translation(ball_pos + Vec3::Y * 5.0),
+            RigidBody::Dynamic,
+            Collider::cuboid(radius, radius, radius),
+            ColliderMassProperties::Density(100.0),
+        ));
+    }
+}
diff --git a/bindings/bevy_rapier/bevy_rapier3d/examples/static_trimesh3.rs b/bindings/bevy_rapier/bevy_rapier3d/examples/static_trimesh3.rs
new file mode 100644
index 000000000..fdff1780c
--- /dev/null
+++ b/bindings/bevy_rapier/bevy_rapier3d/examples/static_trimesh3.rs
@@ -0,0 +1,140 @@
+use std::f32::consts::TAU;
+
+use bevy::prelude::*;
+use bevy_rapier3d::prelude::*;
+
+fn main() {
+    App::new()
+        .insert_resource(ClearColor(Color::srgb(
+            0xF9 as f32 / 255.0,
+            0xF9 as f32 / 255.0,
+            0xFF as f32 / 255.0,
+        )))
+        .add_plugins((
+            DefaultPlugins,
+            RapierPhysicsPlugin::<NoUserData>::default(),
+            RapierDebugRenderPlugin::default(),
+        ))
+        .add_systems(Startup, (setup_graphics, setup_physics))
+        .insert_resource(BallState::default())
+        .add_systems(Update, ball_spawner)
+        .run();
+}
+
+pub fn setup_graphics(mut commands: Commands) {
+    commands.spawn((
+        Camera3d::default(),
+        Transform::from_xyz(-15.0, 8.0, 15.0).looking_at(Vec3::new(-5.0, 0.0, 5.0), Vec3::Y),
+    ));
+}
+
+fn ramp_size() -> Vec3 {
+    Vec3::new(10.0, 1.0, 1.0)
+}
+
+pub fn setup_physics(mut commands: Commands, mut ball_state: ResMut<BallState>) {
+    //reset
+    ball_state.balls_spawned = 0;
+
+    // Create the ramp.
+    let mut vertices: Vec<Vec3> = Vec::new();
+    let mut indices: Vec<[u32; 3]> = Vec::new();
+    let segments = 32;
+    let ramp_size = ramp_size();
+
+    for i in 0..=segments {
+        // Half cosine wave vertically (with middle of low point at origin)
+        let x = i as f32 / segments as f32 * ramp_size.x;
+        let y = (-(i as f32 / segments as f32 * TAU / 2.0).cos() + 1.0) * ramp_size.y / 2.0;
+        vertices.push(Vec3::new(x, y, -ramp_size.z / 2.0));
+        vertices.push(Vec3::new(x, y, ramp_size.z / 2.0));
+    }
+    for i in 0..segments {
+        // Two triangles making up a flat quad for each segment of the ramp.
+        indices.push([2 * i, 2 * i + 1, 2 * i + 2]);
+        indices.push([2 * i + 2, 2 * i + 1, 2 * i + 3]);
+    }
+
+    commands.spawn(Collider::trimesh(vertices, indices).unwrap());
+
+    // Create a bowl with a cosine cross-section,
+    // so that we can join the end of the ramp smoothly
+    // to the lip of the bowl.
+    let mut vertices: Vec<Vec3> = Vec::new();
+    let mut indices: Vec<[u32; 3]> = Vec::new();
+
+    let segments = 32;
+    let bowl_size = Vec3::new(10.0, 3.0, 10.0);
+
+    for ix in 0..=segments {
+        for iz in 0..=segments {
+            // Map x and y into range [-1.0, 1.0];
+            let shifted_z = (iz as f32 / segments as f32 - 0.5) * 2.0;
+            let shifted_x = (ix as f32 / segments as f32 - 0.5) * 2.0;
+            // Clamp radius at 1.0 or lower so the bowl has a flat lip near the corners.
+            let clamped_radius = (shifted_z.powi(2) + shifted_x.powi(2)).sqrt().min(1.0);
+            let x = shifted_x * bowl_size.x / 2.0;
+            let z = shifted_z * bowl_size.z / 2.0;
+            let y = ((clamped_radius - 0.5) * TAU / 2.0).sin() * bowl_size.y / 2.0;
+            vertices.push(Vec3::new(x, y, z));
+        }
+    }
+    for ix in 0..segments {
+        for iz in 0..segments {
+            // Start of the two relevant rows of vertices.
+            let row0 = ix * (segments + 1);
+            let row1 = (ix + 1) * (segments + 1);
+            // Two triangles making up a not-very-flat quad for each segment of the bowl.
+            indices.push([row0 + iz, row0 + iz + 1, row1 + iz]);
+            indices.push([row1 + iz, row0 + iz + 1, row1 + iz + 1]);
+        }
+    }
+    // Position so ramp connects smoothly
+    // to one edge of the lip of the bowl.
+    commands.spawn((
+        Transform::from_xyz(
+            -bowl_size.x / 2.0,
+            -bowl_size.y / 2.0,
+            bowl_size.z / 2.0 - ramp_size.z / 2.0,
+        ),
+        Collider::trimesh(vertices, indices).unwrap(),
+    ));
+}
+
+#[derive(Resource)]
+pub struct BallState {
+    balls_spawned: usize,
+    max_balls: usize,
+    timer: Timer,
+}
+
+impl Default for BallState {
+    fn default() -> Self {
+        Self {
+            balls_spawned: 0,
+            max_balls: 10,
+            timer: Timer::from_seconds(2.0, TimerMode::Repeating),
+        }
+    }
+}
+
+pub fn ball_spawner(mut commands: Commands, time: Res<Time>, mut ball_state: ResMut<BallState>) {
+    if ball_state.balls_spawned >= ball_state.max_balls {
+        return;
+    }
+
+    if ball_state.timer.tick(time.delta()).is_finished() {
+        // Spawn a ball near the top of the ramp.
+        let ramp_size = ramp_size();
+        let rad = 0.3;
+
+        commands.spawn((
+            Transform::from_xyz(ramp_size.x * 0.9, ramp_size.y / 2.0 + rad * 3.0, 0.0),
+            RigidBody::Dynamic,
+            Collider::ball(rad),
+            Restitution::new(0.5),
+        ));
+
+        ball_state.balls_spawned += 1;
+    }
+}
diff --git a/bindings/bevy_rapier/bevy_rapier3d/examples/testbed3.rs b/bindings/bevy_rapier/bevy_rapier3d/examples/testbed3.rs
new file mode 100644
index 000000000..f5f41591d
--- /dev/null
+++ b/bindings/bevy_rapier/bevy_rapier3d/examples/testbed3.rs
@@ -0,0 +1,346 @@
+#![allow(dead_code)]
+
+mod boxes3;
+mod debug_toggle3;
+mod despawn3;
+mod events3;
+mod joints3;
+mod joints_despawn3;
+mod locked_rotations3;
+mod multiple_colliders3;
+mod picking3;
+mod ray_casting3;
+mod soft_bodies3;
+mod static_trimesh3;
+mod voxels3;
+
+use bevy::{
+    camera::visibility::RenderLayers,
+    ecs::{resource::IsResource, world::error::EntityDespawnError},
+    prelude::*,
+};
+use bevy_rapier3d::prelude::*;
+
+#[derive(Debug, Reflect, Clone, Copy, Eq, PartialEq, Default, Hash, States)]
+pub enum Examples {
+    #[default]
+    None,
+    Boxes3,
+    Voxels3,
+    DebugToggle3,
+    Despawn3,
+    Events3,
+    Joints3,
+    JointsDespawn3,
+    LockedRotations3,
+    MultipleColliders3,
+    Picking3,
+    Raycasting3,
+    StaticTrimesh3,
+    SoftBodies3,
+}
+
+#[derive(Resource, Default, Reflect)]
+struct ExamplesRes {
+    entities_before: Vec<Entity>,
+}
+
+#[derive(Resource, Debug, Default, Reflect)]
+struct ExampleSelected(pub usize);
+
+#[derive(Debug, Reflect)]
+struct ExampleDefinition {
+    pub state: Examples,
+    pub name: &'static str,
+}
+
+impl From<(Examples, &'static str)> for ExampleDefinition {
+    fn from((state, name): (Examples, &'static str)) -> Self {
+        Self { state, name }
+    }
+}
+
+#[derive(Resource, Debug, Reflect)]
+struct ExampleSet(pub Vec<ExampleDefinition>);
+
+fn main() {
+    let mut app = App::new();
+    app.init_resource::<ExamplesRes>()
+        .add_plugins((
+            DefaultPlugins,
+            RapierPhysicsPlugin::<NoUserData>::default(),
+            RapierDebugRenderPlugin::default(),
+        ))
+        .add_plugins(RapierPickingPlugin)
+        .register_type::<Examples>()
+        .register_type::<ExamplesRes>()
+        .register_type::<ExampleSelected>()
+        .init_state::<Examples>()
+        .insert_resource(ExampleSet(vec![
+            (Examples::Boxes3, "Boxes3").into(),
+            (Examples::Voxels3, "Voxels3").into(),
+            (Examples::DebugToggle3, "DebugToggle3").into(),
+            (Examples::Despawn3, "Despawn3").into(),
+            (Examples::Events3, "Events3").into(),
+            (Examples::Joints3, "Joints3").into(),
+            (Examples::JointsDespawn3, "JointsDespawn3").into(),
+            (Examples::LockedRotations3, "LockedRotations3").into(),
+            (Examples::MultipleColliders3, "MultipleColliders3").into(),
+            (Examples::Picking3, "Picking3").into(),
+            (Examples::Raycasting3, "Raycasting3").into(),
+            (Examples::StaticTrimesh3, "StaticTrimesh3").into(),
+            (Examples::SoftBodies3, "SoftBodies3").into(),
+        ]))
+        .init_resource::<ExampleSelected>()
+        //
+        // boxes3
+        .add_systems(
+            OnEnter(Examples::Boxes3),
+            (boxes3::setup_graphics, boxes3::setup_physics),
+        )
+        .add_systems(OnExit(Examples::Boxes3), cleanup)
+        //
+        // voxels3
+        .add_systems(
+            OnEnter(Examples::Voxels3),
+            (voxels3::setup_graphics, voxels3::setup_physics),
+        )
+        .add_systems(OnExit(Examples::Voxels3), cleanup)
+        //
+        // Debug toggle
+        .add_systems(
+            OnEnter(Examples::DebugToggle3),
+            (debug_toggle3::setup_graphics, debug_toggle3::setup_physics),
+        )
+        .add_systems(
+            Update,
+            (
+                debug_toggle3::toggle_debug,
+                (|mut debug_render_context: ResMut<DebugRenderContext>| {
+                    debug_render_context.enabled = !debug_render_context.enabled;
+                })
+                .run_if(debug_toggle3::input_just_pressed(KeyCode::KeyV)),
+            )
+                .run_if(in_state(Examples::DebugToggle3)),
+        )
+        .add_systems(OnExit(Examples::DebugToggle3), cleanup)
+        //
+        // despawn
+        .init_resource::<despawn3::DespawnResource>()
+        .add_systems(PreStartup, |mut commands: Commands| {
+            commands.spawn((
+                Camera2d,
+                IsDefaultUiCamera,
+                Camera {
+                    order: 999,
+                    ..Default::default()
+                },
+                RenderLayers::none(),
+            ));
+            commands.spawn((
+                ExampleLabel,
+                Text::default(),
+                Node {
+                    position_type: PositionType::Absolute,
+                    top: px(8),
+                    left: px(8),
+                    ..default()
+                },
+            ));
+        })
+        .add_systems(
+            OnEnter(Examples::Despawn3),
+            (despawn3::setup_graphics, despawn3::setup_physics),
+        )
+        .add_systems(
+            Update,
+            despawn3::despawn.run_if(in_state(Examples::Despawn3)),
+        )
+        .add_systems(OnExit(Examples::Despawn3), cleanup)
+        //
+        // events
+        .add_systems(
+            OnEnter(Examples::Events3),
+            (events3::setup_graphics, events3::setup_physics),
+        )
+        .add_systems(
+            Update,
+            events3::display_events.run_if(in_state(Examples::Events3)),
+        )
+        .add_systems(OnExit(Examples::Events3), cleanup)
+        //
+        // joints
+        .add_systems(
+            OnEnter(Examples::Joints3),
+            (joints3::setup_graphics, joints3::setup_physics),
+        )
+        .add_systems(OnExit(Examples::Joints3), cleanup)
+        //
+        // joints despawn
+        .init_resource::<joints_despawn3::DespawnResource>()
+        .add_systems(
+            OnEnter(Examples::JointsDespawn3),
+            (
+                joints_despawn3::setup_graphics,
+                joints_despawn3::setup_physics,
+            ),
+        )
+        .add_systems(
+            Update,
+            joints_despawn3::despawn.run_if(in_state(Examples::JointsDespawn3)),
+        )
+        .add_systems(OnExit(Examples::JointsDespawn3), cleanup)
+        //
+        // locked rotations
+        .add_systems(
+            OnEnter(Examples::LockedRotations3),
+            (
+                locked_rotations3::setup_graphics,
+                locked_rotations3::setup_physics,
+            ),
+        )
+        .add_systems(OnExit(Examples::LockedRotations3), cleanup)
+        //
+        // multiple colliders
+        .add_systems(
+            OnEnter(Examples::MultipleColliders3),
+            (
+                multiple_colliders3::setup_graphics,
+                multiple_colliders3::setup_physics,
+            ),
+        )
+        .add_systems(OnExit(Examples::MultipleColliders3), cleanup)
+        //
+        // picking
+        .add_systems(
+            OnEnter(Examples::Picking3),
+            (picking3::setup_graphics, picking3::setup_physics),
+        )
+        .add_systems(OnExit(Examples::Picking3), cleanup)
+        //
+        // raycasting
+        .add_systems(
+            OnEnter(Examples::Raycasting3),
+            (ray_casting3::setup_graphics, ray_casting3::setup_physics),
+        )
+        .add_systems(
+            Update,
+            ray_casting3::cast_ray.run_if(in_state(Examples::Raycasting3)),
+        )
+        .add_systems(OnExit(Examples::Raycasting3), cleanup)
+        //
+        // static trimesh
+        .init_resource::<static_trimesh3::BallState>()
+        .add_systems(
+            OnEnter(Examples::StaticTrimesh3),
+            (
+                static_trimesh3::setup_graphics,
+                static_trimesh3::setup_physics,
+            ),
+        )
+        .add_systems(
+            Update,
+            static_trimesh3::ball_spawner.run_if(in_state(Examples::StaticTrimesh3)),
+        )
+        .add_systems(OnExit(Examples::StaticTrimesh3), cleanup)
+        //
+        // soft bodies
+        .add_systems(
+            OnEnter(Examples::SoftBodies3),
+            (soft_bodies3::setup_graphics, soft_bodies3::setup_physics),
+        )
+        .add_systems(
+            Update,
+            (soft_bodies3::cut_cloth, soft_bodies3::log_tears)
+                .run_if(in_state(Examples::SoftBodies3)),
+        )
+        .add_systems(OnExit(Examples::SoftBodies3), cleanup)
+        //
+        //testbed
+        .add_systems(
+            OnEnter(Examples::None),
+            |mut next_state: ResMut<NextState<Examples>>| {
+                next_state.set(Examples::Boxes3);
+            },
+        )
+        .add_systems(OnExit(Examples::None), init)
+        .add_systems(
+            Update,
+            (
+                select_example,
+                (change_example, update_example_label).run_if(resource_changed::<ExampleSelected>),
+            )
+                .chain(),
+        );
+
+    app.run();
+}
+
+fn init(world: &mut World) {
+    // save all entities that are in the world before setting up any example
+    // to be able to always return to this state when switching from one example to the other.
+    // Resource-backed entities (carrying `IsResource`) are excluded: in Bevy 0.19 resources are
+    // stored as entities, and despawning them in `cleanup` panics.
+    world.resource_mut::<ExamplesRes>().entities_before = world
+        .query_filtered::<Entity, Without<IsResource>>()
+        .iter(world)
+        .collect::<Vec<_>>();
+}
+
+fn cleanup(world: &mut World) {
+    let keep_alive = world.resource::<ExamplesRes>().entities_before.clone();
+
+    let remove = world
+        .query_filtered::<Entity, Without<IsResource>>()
+        .iter(world)
+        .filter(|e| !keep_alive.contains(e))
+        .collect::<Vec<_>>();
+    for r in remove {
+        // The entity may already have been despawned as part of a parent's despawn cascade;
+        // skip it in that case to avoid a flood of spurious "invalid entity" warnings.
+        if !world.entities().contains(r) {
+            continue;
+        }
+        if let Err(error @ EntityDespawnError(_)) = world.try_despawn(r) {
+            warn!("Cleanup error: {error:?}");
+        }
+    }
+}
+
+fn change_example(
+    example_selected: Res<ExampleSelected>,
+    examples_available: Res<ExampleSet>,
+    mut next_state: ResMut<NextState<Examples>>,
+) {
+    next_state.set(examples_available.0[example_selected.0].state);
+}
+
+/// Marks the text node displaying the current example's name.
+#[derive(Component)]
+struct ExampleLabel;
+
+fn select_example(
+    keys: Res<ButtonInput<KeyCode>>,
+    mut current_example: ResMut<ExampleSelected>,
+    examples_available: Res<ExampleSet>,
+) {
+    let len = examples_available.0.len();
+    if keys.just_pressed(KeyCode::PageDown) {
+        current_example.0 = (current_example.0 + 1) % len;
+    } else if keys.just_pressed(KeyCode::PageUp) {
+        current_example.0 = (current_example.0 + len - 1) % len;
+    }
+}
+
+fn update_example_label(
+    current_example: Res<ExampleSelected>,
+    examples_available: Res<ExampleSet>,
+    mut label: Query<&mut Text, With<ExampleLabel>>,
+) {
+    for mut text in &mut label {
+        text.0 = format!(
+            "Example: {} (PageUp/PageDown to switch)",
+            examples_available.0[current_example.0].name
+        );
+    }
+}
diff --git a/bindings/bevy_rapier/bevy_rapier3d/examples/urdf3.rs b/bindings/bevy_rapier/bevy_rapier3d/examples/urdf3.rs
new file mode 100644
index 000000000..880ca61aa
--- /dev/null
+++ b/bindings/bevy_rapier/bevy_rapier3d/examples/urdf3.rs
@@ -0,0 +1,116 @@
+//! Spawns the same URDF robot twice, with impulse joints and with multibody joints, and drives
+//! their joints with motors.
+
+use std::f32::consts::FRAC_PI_2;
+
+use bevy::prelude::*;
+use bevy_rapier3d::loaders::urdf::{
+    spawn_urdf_robot, UrdfLoaderOptions, UrdfModel, UrdfMultibodyOptions, UrdfSpawnOptions,
+};
+use bevy_rapier3d::prelude::*;
+
+fn main() {
+    App::new()
+        .insert_resource(ClearColor(Color::srgb(
+            0xF9 as f32 / 255.0,
+            0xF9 as f32 / 255.0,
+            0xFF as f32 / 255.0,
+        )))
+        .add_plugins((
+            DefaultPlugins,
+            RapierPhysicsPlugin::<NoUserData>::default(),
+            RapierDebugRenderPlugin::default(),
+        ))
+        .add_systems(Startup, (setup_graphics, setup_physics))
+        .add_systems(Update, drive_arms)
+        .run();
+}
+
+/// The joints of a spawned arm driven by [`drive_arms`].
+#[derive(Component)]
+struct DrivenArm {
+    base_yaw: Entity,
+    shoulder: Entity,
+    elbow: Entity,
+    finger: Entity,
+}
+
+fn setup_graphics(mut commands: Commands) {
+    commands.spawn((
+        Camera3d::default(),
+        Transform::from_xyz(0.0, 2.0, 4.0).looking_at(Vec3::new(0.0, 0.6, 0.0), Vec3::Y),
+    ));
+}
+
+fn setup_physics(mut commands: Commands) {
+    commands.spawn((
+        Transform::from_xyz(0.0, -0.1, 0.0),
+        Collider::cuboid(5.0, 0.1, 5.0),
+    ));
+
+    let path = concat!(env!("CARGO_MANIFEST_DIR"), "/assets/robots/arm.urdf");
+    let model = UrdfModel::from_file(path, UrdfLoaderOptions::default(), None)
+        .expect("Failed to load the URDF file.");
+
+    for (x, multibody) in [(-0.8, false), (0.8, true)] {
+        let robot = spawn_urdf_robot(
+            &mut commands,
+            &model,
+            &UrdfSpawnOptions {
+                multibody,
+                multibody_options: UrdfMultibodyOptions::DISABLE_SELF_CONTACTS,
+                // URDF files are Z-up.
+                root_transform: Transform::from_xyz(x, 0.0, 0.0)
+                    .with_rotation(Quat::from_rotation_x(-FRAC_PI_2)),
+                ..default()
+            },
+        );
+        info!(
+            "Spawned `{}` with {} links and {} joints ({}).",
+            model.urdf.name,
+            robot.links.len(),
+            robot.joints.len(),
+            if multibody { "multibody" } else { "impulse" }
+        );
+        commands.spawn(DrivenArm {
+            base_yaw: robot.joints_by_name["base_yaw"],
+            shoulder: robot.joints_by_name["shoulder"],
+            elbow: robot.joints_by_name["elbow"],
+            finger: robot.joints_by_name["left_finger_joint"],
+        });
+    }
+}
+
+/// Moves the joints of the arms with position motors.
+fn drive_arms(
+    time: Res<Time>,
+    arms: Query<&DrivenArm>,
+    mut impulse_joints: Query<&mut ImpulseJoint>,
+    mut multibody_joints: Query<&mut MultibodyJoint>,
+) {
+    let t = time.elapsed_secs();
+    for arm in arms.iter() {
+        let targets = [
+            (arm.base_yaw, JointAxis::AngX, t * 0.5, 30.0),
+            (arm.shoulder, JointAxis::AngX, 0.6 * (t * 0.8).sin(), 100.0),
+            (
+                arm.elbow,
+                JointAxis::AngX,
+                1.0 + 0.6 * (t * 1.3).sin(),
+                100.0,
+            ),
+            (arm.finger, JointAxis::LinX, 0.03 * (t * 2.0).sin(), 100.0),
+        ];
+        for (entity, axis, target, stiffness) in targets {
+            let data = if let Ok(joint) = impulse_joints.get_mut(entity) {
+                &mut joint.into_inner().data
+            } else if let Ok(joint) = multibody_joints.get_mut(entity) {
+                &mut joint.into_inner().data
+            } else {
+                continue;
+            };
+            data.as_mut()
+                .set_motor_position(axis, target, stiffness, 0.2 * stiffness);
+        }
+    }
+}
diff --git a/bindings/bevy_rapier/bevy_rapier3d/examples/vehicle_controller3.rs b/bindings/bevy_rapier/bevy_rapier3d/examples/vehicle_controller3.rs
new file mode 100644
index 000000000..65625dd9a
--- /dev/null
+++ b/bindings/bevy_rapier/bevy_rapier3d/examples/vehicle_controller3.rs
@@ -0,0 +1,196 @@
+//! A ray-cast vehicle: use the up/down arrows to accelerate forward/backward, the left/right
+//! arrows to steer, and space to brake.
+
+use bevy::{prelude::*, transform::TransformSystems};
+use bevy_rapier3d::prelude::*;
+
+const HALF_EXTENTS: Vec3 = Vec3::new(2.0, 0.4, 1.0);
+const WHEEL_RADIUS: f32 = 0.4;
+const WHEEL_WIDTH: f32 = 0.3;
+const ENGINE_FORCE: f32 = 300.0;
+const BRAKE: f32 = 20.0;
+const MAX_STEERING: f32 = 0.5;
+
+/// Marks the entity rendering the wheel with the given index.
+#[derive(Component)]
+struct WheelVisual(usize);
+
+fn main() {
+    App::new()
+        .insert_resource(ClearColor(Color::srgb(
+            0xF9 as f32 / 255.0,
+            0xF9 as f32 / 255.0,
+            0xFF as f32 / 255.0,
+        )))
+        .add_plugins((
+            DefaultPlugins,
+            RapierPhysicsPlugin::<NoUserData>::default(),
+            RapierDebugRenderPlugin::default(),
+        ))
+        .add_systems(Startup, (setup_graphics, setup_physics))
+        .add_systems(Update, drive_vehicle)
+        .add_systems(
+            PostUpdate,
+            (update_wheel_visuals, follow_vehicle)
+                .after(PhysicsSet::Writeback)
+                .before(TransformSystems::Propagate),
+        )
+        .run();
+}
+
+fn setup_graphics(mut commands: Commands) {
+    commands.spawn((
+        Camera3d::default(),
+        Transform::from_xyz(-15.0, 8.0, 0.0).looking_at(Vec3::ZERO, Vec3::Y),
+    ));
+    commands.spawn((
+        DirectionalLight::default(),
+        Transform::from_xyz(10.0, 20.0, 10.0).looking_at(Vec3::ZERO, Vec3::Y),
+    ));
+}
+
+fn setup_physics(
+    mut commands: Commands,
+    mut meshes: ResMut<Assets<Mesh>>,
+    mut materials: ResMut<Assets<StandardMaterial>>,
+) {
+    /*
+     * Ground
+     */
+    let ground_size = 100.0;
+    let ground_height = 0.1;
+    commands.spawn((
+        Transform::from_xyz(0.0, -ground_height, 0.0),
+        Collider::cuboid(ground_size, ground_height, ground_size),
+    ));
+
+    /*
+     * A few boxes to push around.
+     */
+    for i in 0..5 {
+        commands.spawn((
+            Transform::from_xyz(15.0 + i as f32 * 1.2, 0.5, (i as f32 - 2.0) * 1.2),
+            RigidBody::Dynamic,
+            Collider::cuboid(0.5, 0.5, 0.5),
+        ));
+    }
+
+    /*
+     * The vehicle, moving forward along its local +X axis.
+     */
+    let tuning = WheelTuning {
+        suspension_stiffness: 100.0,
+        suspension_damping: 10.0,
+        ..WheelTuning::default()
+    };
+    let suspension_rest_length = 0.4;
+    let wheel_positions = [
+        Vec3::new(HALF_EXTENTS.x * 0.75, -HALF_EXTENTS.y, HALF_EXTENTS.z),
+        Vec3::new(HALF_EXTENTS.x * 0.75, -HALF_EXTENTS.y, -HALF_EXTENTS.z),
+        Vec3::new(-HALF_EXTENTS.x * 0.75, -HALF_EXTENTS.y, HALF_EXTENTS.z),
+        Vec3::new(-HALF_EXTENTS.x * 0.75, -HALF_EXTENTS.y, -HALF_EXTENTS.z),
+    ];
+    let wheels = wheel_positions
+        .iter()
+        .map(|pos| {
+            VehicleWheel::new(
+                *pos,
+                -Vec3::Y,
+                Vec3::Z,
+                suspension_rest_length,
+                WHEEL_RADIUS,
+                tuning,
+            )
+        })
+        .collect();
+
+    let wheel_mesh = meshes.add(Cylinder::new(WHEEL_RADIUS, WHEEL_WIDTH));
+    let wheel_material = materials.add(Color::srgb(0.2, 0.2, 0.2));
+
+    commands
+        .spawn((
+            Transform::from_xyz(0.0, 2.0, 0.0),
+            RigidBody::Dynamic,
+            Collider::cuboid(HALF_EXTENTS.x, HALF_EXTENTS.y, HALF_EXTENTS.z),
+            ColliderMassProperties::Density(10.0),
+            RayCastVehicleController::new(wheels),
+        ))
+        .with_children(|chassis| {
+            for (i, pos) in wheel_positions.iter().enumerate() {
+                chassis
+                    .spawn((WheelVisual(i), Transform::from_translation(*pos)))
+                    .with_children(|wheel| {
+                        // Cylinders are aligned with Y; align them with the wheel axle (Z).
+                        wheel.spawn((
+                            Mesh3d(wheel_mesh.clone()),
+                            MeshMaterial3d(wheel_material.clone()),
+                            Transform::from_rotation(Quat::from_rotation_x(
+                                std::f32::consts::FRAC_PI_2,
+                            )),
+                        ));
+                    });
+            }
+        });
+}
+
+fn drive_vehicle(
+    keyboard: Res<ButtonInput<KeyCode>>,
+    mut vehicles: Query<&mut RayCastVehicleController>,
+) {
+    let mut engine_force = 0.0;
+    let mut steering = 0.0;
+    let mut brake = 0.0;
+
+    if keyboard.pressed(KeyCode::ArrowUp) {
+        engine_force += ENGINE_FORCE;
+    }
+    if keyboard.pressed(KeyCode::ArrowDown) {
+        engine_force -= ENGINE_FORCE;
+    }
+    if keyboard.pressed(KeyCode::ArrowLeft) {
+        steering += MAX_STEERING;
+    }
+    if keyboard.pressed(KeyCode::ArrowRight) {
+        steering -= MAX_STEERING;
+    }
+    if keyboard.pressed(KeyCode::Space) {
+        brake = BRAKE;
+    }
+
+    for mut vehicle in vehicles.iter_mut() {
+        for (i, wheel) in vehicle.wheels.iter_mut().enumerate() {
+            let is_front = i < 2;
+            wheel.engine_force = if is_front { engine_force } else { 0.0 };
+            wheel.steering = if is_front { steering } else { 0.0 };
+            wheel.brake = brake;
+        }
+    }
+}
+
+fn update_wheel_visuals(
+    vehicles: Query<&RayCastVehicleController>,
+    mut wheels: Query<(&WheelVisual, &ChildOf, &mut Transform)>,
+) {
+    for (visual, child_of, mut transform) in wheels.iter_mut() {
+        if let Some(wheel) = vehicles
+            .get(child_of.parent())
+            .ok()
+            .and_then(|vehicle| vehicle.wheels.get(visual.0))
+        {
+            *transform = wheel.local_transform();
+        }
+    }
+}
+
+fn follow_vehicle(
+    vehicles: Query<&Transform, With<RayCastVehicleController>>,
+    mut cameras: Query<&mut Transform, (With<Camera3d>, Without<RayCastVehicleController>)>,
+) {
+    let (Ok(vehicle), Ok(mut camera)) = (vehicles.single(), cameras.single_mut()) else {
+        return;
+    };
+    let back = vehicle.rotation * -Vec3::X;
+    let back = Vec3::new(back.x, 0.0, back.z).normalize_or(-Vec3::X);
+    let eye = vehicle.translation + back * 12.0 + Vec3::Y * 6.0;
+    *camera = Transform::from_translation(eye).looking_at(vehicle.translation, Vec3::Y);
+}
diff --git a/bindings/bevy_rapier/bevy_rapier3d/examples/voxels3.rs b/bindings/bevy_rapier/bevy_rapier3d/examples/voxels3.rs
new file mode 100644
index 000000000..0c09291fe
--- /dev/null
+++ b/bindings/bevy_rapier/bevy_rapier3d/examples/voxels3.rs
@@ -0,0 +1,96 @@
+use bevy::prelude::*;
+use bevy_rapier3d::prelude::*;
+use rapier3d::math::Pose;
+
+fn main() {
+    App::new()
+        .insert_resource(ClearColor(Color::srgb(
+            0xF9 as f32 / 255.0,
+            0xF9 as f32 / 255.0,
+            0xFF as f32 / 255.0,
+        )))
+        .add_plugins((
+            DefaultPlugins,
+            RapierPhysicsPlugin::<NoUserData>::default(),
+            RapierDebugRenderPlugin::default(),
+        ))
+        .add_systems(Startup, (setup_graphics, setup_physics))
+        .run();
+}
+
+pub fn setup_graphics(mut commands: Commands) {
+    commands.spawn((
+        Camera3d::default(),
+        Transform::from_xyz(-100.0, 100.0, -100.0).looking_at(Vec3::new(0.0, 0.0, 0.0), Vec3::Y),
+    ));
+}
+
+pub fn setup_physics(mut commands: Commands) {
+    /*
+     * Create a voxelized wavy floor.
+     */
+    let voxel_size = Vec3::new(1f32, 1f32, 1f32);
+    let mut samples = vec![];
+    let n = 200;
+    for i in 0..n {
+        for j in 0..n {
+            let y = (i as f32 / n as f32 * 10.0).sin().clamp(-0.8, 0.8)
+                * (j as f32 / n as f32 * 10.0).cos().clamp(-0.8, 0.8)
+                * 16.0;
+
+            samples.push(Vec3::new(
+                i as f32 * voxel_size.x,
+                y * voxel_size.y,
+                j as f32 * voxel_size.z,
+            ));
+
+            if i == 0 || i == n - 1 || j == 0 || j == n - 1 {
+                // Create walls so the object at the edge don’t fall into the infinite void.
+                for k in 0..4 {
+                    samples.push(Vec3::new(
+                        i as f32 * voxel_size.x,
+                        (y + k as f32) * voxel_size.y,
+                        j as f32 * voxel_size.z,
+                    ));
+                }
+            }
+        }
+    }
+    let collider = Collider::voxels_from_points(voxel_size, &samples);
+    let ground_position = Vec3::new(voxel_size.x / 2f32, 0.0, voxel_size.z / 2f32);
+    let floor_aabb = collider.raw.compute_aabb(&Pose::IDENTITY);
+    commands.spawn((Transform::from_translation(ground_position), collider));
+
+    /*
+     * Create dynamic objects to fall on voxels.
+     */
+    let extents = floor_aabb.extents() * 0.75;
+    let margin = (floor_aabb.extents() - extents) / 2.0;
+    let nik = 30;
+    for i in 0..nik {
+        for j in 0..5 {
+            for k in 0..nik {
+                let falling_objects = (j + i + k) % 3;
+
+                let ball_radius = 0.5;
+                let co = match falling_objects {
+                    0 => Collider::ball(ball_radius),
+                    1 => Collider::cuboid(ball_radius, ball_radius, ball_radius),
+                    2 => Collider::capsule_y(ball_radius, ball_radius),
+                    _ => unreachable!(),
+                };
+                commands.spawn((
+                    Transform::from_xyz(
+                        floor_aabb.mins.x + margin.x + i as f32 * extents.x / nik as f32
+                            - ground_position.x,
+                        floor_aabb.maxs.y + j as f32 * 2.0 - ground_position.y,
+                        floor_aabb.mins.z + margin.z + k as f32 * extents.z / nik as f32
+                            - -ground_position.z,
+                    ),
+                    RigidBody::Dynamic,
+                    co,
+                ));
+            }
+        }
+    }
+}
diff --git a/bindings/bevy_rapier/bevy_rapier_benches3d/Cargo.toml b/bindings/bevy_rapier/bevy_rapier_benches3d/Cargo.toml
new file mode 100644
index 000000000..484c9b668
--- /dev/null
+++ b/bindings/bevy_rapier/bevy_rapier_benches3d/Cargo.toml
@@ -0,0 +1,26 @@
+[package]
+name = "bevy_rapier_benches3d"
+version = "0.1.0"
+description = "Custom benchmarks for bevy_rapier."
+readme = "./README.md"
+license = "Apache-2.0"
+edition = "2021"
+publish = false
+
+# See more keys and their definitions at https://doc.rust-lang.org/cargo/reference/manifest.html
+
+[dependencies]
+rapier3d = { workspace = true }
+bevy_rapier3d = { version = "0.36", path = "../bevy_rapier3d" }
+bevy = { git = "https://github.com/bevyengine/bevy", branch = "main", default-features = false }
+
+[dev-dependencies]
+divan = "0.1"
+
+[[bench]]
+name = "cubes"
+harness = false
+
+[[bench]]
+name = "many_pyramids3"
+harness = false
diff --git a/bindings/bevy_rapier/bevy_rapier_benches3d/README.md b/bindings/bevy_rapier/bevy_rapier_benches3d/README.md
new file mode 100644
index 000000000..170918ce4
--- /dev/null
+++ b/bindings/bevy_rapier/bevy_rapier_benches3d/README.md
@@ -0,0 +1,24 @@
+# bevy_rapier custom benches
+
+`bevy_rapier_benches3d` 's objective is to measure timings with detailed information
+without spending too much time running multiple times expensive benchmarks.
+
+It is implemented as a standalone binary, running different scenes setup, gathering information
+and outputs them at the end.
+
+```sh
+cargo run --release --bin bench
+```
+
+## cargo bench
+
+For short-lived benchmarks based on statistical analysis,
+benchmarks can be run through the [divan](https://github.com/nvzqz/divan) bench harness.
+
+```sh
+cargo bench -p bevy_rapier_benches3d
+```
+
+## Other resources
+
+- [Bevy profiling](https://github.com/bevyengine/bevy/blob/main/docs/profiling.md)
diff --git a/bindings/bevy_rapier/bevy_rapier_benches3d/benches/common.rs b/bindings/bevy_rapier/bevy_rapier_benches3d/benches/common.rs
new file mode 100644
index 000000000..86229fc4f
--- /dev/null
+++ b/bindings/bevy_rapier/bevy_rapier_benches3d/benches/common.rs
@@ -0,0 +1,12 @@
+use bevy::app::App;
+use bevy_rapier_benches3d::common::{default_app, wait_app_start};
+
+pub fn bench_app_updates(bencher: divan::Bencher, setup: impl Fn(&mut App)) {
+    let mut app = default_app();
+    setup(&mut app);
+    wait_app_start(&mut app);
+
+    bencher.bench_local(|| {
+        app.update();
+    });
+}
diff --git a/bindings/bevy_rapier/bevy_rapier_benches3d/benches/cubes.rs b/bindings/bevy_rapier/bevy_rapier_benches3d/benches/cubes.rs
new file mode 100644
index 000000000..6095783fa
--- /dev/null
+++ b/bindings/bevy_rapier/bevy_rapier_benches3d/benches/cubes.rs
@@ -0,0 +1,52 @@
+//! Translated from avian benchmark.
+//!
+//! <https://github.com/Jondolf/avian/blob/81290423e146264120cf9711af716f6faf669717/crates/avian3d/benches/cubes.rs>
+
+mod common;
+
+use common::bench_app_updates;
+
+use bevy::prelude::*;
+use bevy_rapier3d::math::*;
+use bevy_rapier3d::prelude::*;
+
+fn setup_cubes(app: &mut App, size: u32) {
+    app.add_systems(Startup, move |mut commands: Commands| {
+        commands.spawn((
+            RigidBody::Fixed,
+            Transform::from_translation(-2.0 * Vect::Z),
+            Collider::cuboid(100.0, 1.0, 100.0),
+        ));
+        for x in 0..size {
+            for z in 0..size {
+                commands.spawn((
+                    RigidBody::Dynamic,
+                    Transform::from_translation(Vec3::new(x as f32, 2.0, z as f32)),
+                    Collider::cuboid(1.0, 1.0, 1.0),
+                ));
+            }
+        }
+    });
+}
+
+#[divan::bench(sample_count = 60, sample_size = 1)]
+fn cubes_3x3(bencher: divan::Bencher) {
+    bench_app_updates(bencher, |app| setup_cubes(app, 3))
+}
+#[divan::bench(sample_count = 60, sample_size = 1)]
+fn cubes_5x5(bencher: divan::Bencher) {
+    bench_app_updates(bencher, |app| setup_cubes(app, 5))
+}
+#[divan::bench(sample_count = 60, sample_size = 1)]
+fn cubes_10x10(bencher: divan::Bencher) {
+    bench_app_updates(bencher, |app| setup_cubes(app, 10))
+}
+#[divan::bench(sample_count = 60, sample_size = 1)]
+fn cubes_20x20(bencher: divan::Bencher) {
+    bench_app_updates(bencher, |app| setup_cubes(app, 20))
+}
+
+fn main() {
+    // Run registered benchmarks.
+    divan::main();
+}
diff --git a/bindings/bevy_rapier/bevy_rapier_benches3d/benches/many_pyramids3.rs b/bindings/bevy_rapier/bevy_rapier_benches3d/benches/many_pyramids3.rs
new file mode 100644
index 000000000..e4ca49a4e
--- /dev/null
+++ b/bindings/bevy_rapier/bevy_rapier_benches3d/benches/many_pyramids3.rs
@@ -0,0 +1,28 @@
+//! Translated from rapier benchmark.
+//!
+//! <https://github.com/dimforge/rapier/blob/87ada34008f4a1a313ccf8c3040040bab4f10e69/benchmarks3d/many_pyramids3.rs>
+
+mod common;
+
+use bevy_rapier_benches3d::pyramids::setup_pyramids;
+use common::bench_app_updates;
+
+#[divan::bench(sample_count = 60, sample_size = 1)]
+fn pyramid_1_with_height_2(bencher: divan::Bencher) {
+    bench_app_updates(bencher, |app| setup_pyramids(app, 1, 2));
+}
+
+#[divan::bench(sample_count = 60, sample_size = 1)]
+fn pyramid_1_with_height_20(bencher: divan::Bencher) {
+    bench_app_updates(bencher, |app| setup_pyramids(app, 1, 20));
+}
+
+#[divan::bench(sample_count = 60, sample_size = 1)]
+fn pyramid_2_with_height_20(bencher: divan::Bencher) {
+    bench_app_updates(bencher, |app| setup_pyramids(app, 2, 20));
+}
+
+fn main() {
+    // Run registered benchmarks.
+    divan::main();
+}
diff --git a/bindings/bevy_rapier/bevy_rapier_benches3d/src/bin/bench.rs b/bindings/bevy_rapier/bevy_rapier_benches3d/src/bin/bench.rs
new file mode 100644
index 000000000..e864541b7
--- /dev/null
+++ b/bindings/bevy_rapier/bevy_rapier_benches3d/src/bin/bench.rs
@@ -0,0 +1,14 @@
+use bevy_rapier_benches3d::{custom_bencher, pyramids::setup_pyramids};
+
+fn pyramid_1_with_height_2() {
+    custom_bencher(1000, |app| setup_pyramids(app, 1, 2));
+}
+
+fn pyramid_2_with_height_20() {
+    custom_bencher(100, |app| setup_pyramids(app, 3, 20));
+}
+
+fn main() {
+    pyramid_1_with_height_2();
+    pyramid_2_with_height_20();
+}
diff --git a/bindings/bevy_rapier/bevy_rapier_benches3d/src/common.rs b/bindings/bevy_rapier/bevy_rapier_benches3d/src/common.rs
new file mode 100644
index 000000000..e4775a4cd
--- /dev/null
+++ b/bindings/bevy_rapier/bevy_rapier_benches3d/src/common.rs
@@ -0,0 +1,27 @@
+use bevy::{app::PluginsState, prelude::*, time::TimeUpdateStrategy};
+use bevy_rapier3d::prelude::*;
+
+pub fn default_app() -> App {
+    let mut app = App::new();
+
+    app.add_plugins((
+        MinimalPlugins,
+        TransformPlugin,
+        RapierPhysicsPlugin::<()>::default(),
+    ));
+
+    // 60 physics
+    app.insert_resource(TimeUpdateStrategy::ManualDuration(
+        std::time::Duration::from_secs_f32(1f32 / 60f32),
+    ));
+    app
+}
+
+pub fn wait_app_start(app: &mut App) {
+    while app.plugins_state() != PluginsState::Ready {
+        bevy::tasks::tick_global_task_pools_on_main_thread();
+    }
+
+    app.finish();
+    app.cleanup();
+}
diff --git a/bindings/bevy_rapier/bevy_rapier_benches3d/src/lib.rs b/bindings/bevy_rapier/bevy_rapier_benches3d/src/lib.rs
new file mode 100644
index 000000000..5519e4e4c
--- /dev/null
+++ b/bindings/bevy_rapier/bevy_rapier_benches3d/src/lib.rs
@@ -0,0 +1,49 @@
+//! Translated from rapier benchmark.
+//!
+//! <https://github.com/dimforge/rapier/blob/87ada34008f4a1a313ccf8c3040040bab4f10e69/benchmarks3d/many_pyramids3.rs>
+
+pub mod common;
+pub mod pyramids;
+
+use common::default_app;
+use common::wait_app_start;
+
+use bevy::prelude::*;
+use bevy_rapier3d::plugin::context::RapierContextSimulation;
+
+pub fn custom_bencher(steps: usize, setup: impl Fn(&mut App)) {
+    let mut app = default_app();
+    setup(&mut app);
+    wait_app_start(&mut app);
+
+    let mut timer_total = rapier3d::counters::Timer::new();
+    let mut timer_full_update = rapier3d::counters::Timer::new();
+    let mut rapier_step_times = vec![];
+    let mut total_update_times = vec![];
+    timer_total.start();
+    for _ in 0..steps {
+        timer_full_update.start();
+        app.update();
+        timer_full_update.pause();
+        let elapsed_time = timer_full_update.time().as_millis();
+        let rc = app
+            .world_mut()
+            .query::<&RapierContextSimulation>()
+            .single(app.world());
+        rapier_step_times.push(rc.unwrap().pipeline.counters.step_time.time().as_millis() as f32);
+        total_update_times.push(elapsed_time);
+    }
+    timer_total.pause();
+    let average_total = total_update_times
+        .iter()
+        .map(|time| *time as f32)
+        .sum::<f32>()
+        / total_update_times.len() as f32;
+    println!("average total time: {average_total} ms");
+    let average_rapier_step =
+        rapier_step_times.iter().sum::<f32>() / rapier_step_times.len() as f32;
+    println!("average rapier step time: {average_rapier_step} ms");
+    let average_rapier_overhead = average_total - average_rapier_step;
+    println!("average bevy overhead: {average_rapier_overhead} ms");
+    println!("total time: {} ms", timer_total.time().as_millis());
+}
diff --git a/bindings/bevy_rapier/bevy_rapier_benches3d/src/pyramids.rs b/bindings/bevy_rapier/bevy_rapier_benches3d/src/pyramids.rs
new file mode 100644
index 000000000..363538a9e
--- /dev/null
+++ b/bindings/bevy_rapier/bevy_rapier_benches3d/src/pyramids.rs
@@ -0,0 +1,64 @@
+use bevy::prelude::*;
+use bevy_rapier3d::dynamics::RigidBody;
+use bevy_rapier3d::geometry::Collider;
+use bevy_rapier3d::math::Vect;
+
+pub fn create_pyramid(commands: &mut Commands, offset: Vect, stack_height: usize, rad: f32) {
+    let shift = rad * 2.0;
+
+    for i in 0usize..stack_height {
+        for j in i..stack_height {
+            let fj = j as f32;
+            let fi = i as f32;
+            let x = (fi * shift / 2.0) + (fj - fi) * shift;
+            let y = fi * shift;
+
+            // Build the rigid body.
+            commands.spawn((
+                RigidBody::Dynamic,
+                Transform::from_translation(Vec3::new(x, y, 0.0) + offset),
+                Collider::cuboid(1.0, 1.0, 1.0),
+            ));
+        }
+    }
+}
+
+pub fn setup_pyramids(app: &mut App, pyramid_count: usize, stack_height: usize) {
+    app.add_systems(Startup, move |mut commands: Commands| {
+        let rad = 0.5;
+        let spacing = 4.0;
+
+        /*
+         * Ground
+         */
+        let ground_size = 50.0;
+        let ground_height = 0.1;
+
+        commands.spawn((
+            RigidBody::Fixed,
+            Transform::from_translation(Vect::new(0.0, -ground_height, 0.0)),
+            Collider::cuboid(
+                ground_size,
+                ground_height,
+                pyramid_count as f32 * spacing / 2.0 + ground_size,
+            ),
+        ));
+
+        /*
+         * Create the pyramids
+         */
+        for pyramid_index in 0..pyramid_count {
+            let bottomy = rad;
+            create_pyramid(
+                &mut commands,
+                Vect::new(
+                    0.0,
+                    bottomy,
+                    (pyramid_index as f32 - pyramid_count as f32 / 2.0) * spacing,
+                ),
+                stack_height,
+                rad,
+            );
+        }
+    });
+}
diff --git a/bindings/bevy_rapier/ci/Cargo.toml b/bindings/bevy_rapier/ci/Cargo.toml
new file mode 100644
index 000000000..eff20ea69
--- /dev/null
+++ b/bindings/bevy_rapier/ci/Cargo.toml
@@ -0,0 +1,15 @@
+[package]
+name = "ci"
+version = "0.1.0"
+edition = "2021"
+publish = false
+
+[dependencies]
+bevy = { git = "https://github.com/bevyengine/bevy", branch = "main" }
+bevy_rapier3d = { version = "0.36", path = "../bevy_rapier3d" }
+bevy_rapier2d = { version = "0.36", path = "../bevy_rapier2d" }
+
+[[bin]]
+name = "ambiguity_detection"
+test = false
+bench = false
diff --git a/bindings/bevy_rapier/ci/LICENSE b/bindings/bevy_rapier/ci/LICENSE
new file mode 100644
index 000000000..97f4383a3
--- /dev/null
+++ b/bindings/bevy_rapier/ci/LICENSE
@@ -0,0 +1,201 @@
+                                 Apache License
+                           Version 2.0, January 2004
+                        http://www.apache.org/licenses/
+
+   TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION
+
+   1. Definitions.
+
+      "License" shall mean the terms and conditions for use, reproduction,
+      and distribution as defined by Sections 1 through 9 of this document.
+
+      "Licensor" shall mean the copyright owner or entity authorized by
+      the copyright owner that is granting the License.
+
+      "Legal Entity" shall mean the union of the acting entity and all
+      other entities that control, are controlled by, or are under common
+      control with that entity. For the purposes of this definition,
+      "control" means (i) the power, direct or indirect, to cause the
+      direction or management of such entity, whether by contract or
+      otherwise, or (ii) ownership of fifty percent (50%) or more of the
+      outstanding shares, or (iii) beneficial ownership of such entity.
+
+      "You" (or "Your") shall mean an individual or Legal Entity
+      exercising permissions granted by this License.
+
+      "Source" form shall mean the preferred form for making modifications,
+      including but not limited to software source code, documentation
+      source, and configuration files.
+
+      "Object" form shall mean any form resulting from mechanical
+      transformation or translation of a Source form, including but
+      not limited to compiled object code, generated documentation,
+      and conversions to other media types.
+
+      "Work" shall mean the work of authorship, whether in Source or
+      Object form, made available under the License, as indicated by a
+      copyright notice that is included in or attached to the work
+      (an example is provided in the Appendix below).
+
+      "Derivative Works" shall mean any work, whether in Source or Object
+      form, that is based on (or derived from) the Work and for which the
+      editorial revisions, annotations, elaborations, or other modifications
+      represent, as a whole, an original work of authorship. For the purposes
+      of this License, Derivative Works shall not include works that remain
+      separable from, or merely link (or bind by name) to the interfaces of,
+      the Work and Derivative Works thereof.
+
+      "Contribution" shall mean any work of authorship, including
+      the original version of the Work and any modifications or additions
+      to that Work or Derivative Works thereof, that is intentionally
+      submitted to Licensor for inclusion in the Work by the copyright owner
+      or by an individual or Legal Entity authorized to submit on behalf of
+      the copyright owner. For the purposes of this definition, "submitted"
+      means any form of electronic, verbal, or written communication sent
+      to the Licensor or its representatives, including but not limited to
+      communication on electronic mailing lists, source code control systems,
+      and issue tracking systems that are managed by, or on behalf of, the
+      Licensor for the purpose of discussing and improving the Work, but
+      excluding communication that is conspicuously marked or otherwise
+      designated in writing by the copyright owner as "Not a Contribution."
+
+      "Contributor" shall mean Licensor and any individual or Legal Entity
+      on behalf of whom a Contribution has been received by Licensor and
+      subsequently incorporated within the Work.
+
+   2. Grant of Copyright License. Subject to the terms and conditions of
+      this License, each Contributor hereby grants to You a perpetual,
+      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+      copyright license to reproduce, prepare Derivative Works of,
+      publicly display, publicly perform, sublicense, and distribute the
+      Work and such Derivative Works in Source or Object form.
+
+   3. Grant of Patent License. Subject to the terms and conditions of
+      this License, each Contributor hereby grants to You a perpetual,
+      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+      (except as stated in this section) patent license to make, have made,
+      use, offer to sell, sell, import, and otherwise transfer the Work,
+      where such license applies only to those patent claims licensable
+      by such Contributor that are necessarily infringed by their
+      Contribution(s) alone or by combination of their Contribution(s)
+      with the Work to which such Contribution(s) was submitted. If You
+      institute patent litigation against any entity (including a
+      cross-claim or counterclaim in a lawsuit) alleging that the Work
+      or a Contribution incorporated within the Work constitutes direct
+      or contributory patent infringement, then any patent licenses
+      granted to You under this License for that Work shall terminate
+      as of the date such litigation is filed.
+
+   4. Redistribution. You may reproduce and distribute copies of the
+      Work or Derivative Works thereof in any medium, with or without
+      modifications, and in Source or Object form, provided that You
+      meet the following conditions:
+
+      (a) You must give any other recipients of the Work or
+          Derivative Works a copy of this License; and
+
+      (b) You must cause any modified files to carry prominent notices
+          stating that You changed the files; and
+
+      (c) You must retain, in the Source form of any Derivative Works
+          that You distribute, all copyright, patent, trademark, and
+          attribution notices from the Source form of the Work,
+          excluding those notices that do not pertain to any part of
+          the Derivative Works; and
+
+      (d) If the Work includes a "NOTICE" text file as part of its
+          distribution, then any Derivative Works that You distribute must
+          include a readable copy of the attribution notices contained
+          within such NOTICE file, excluding those notices that do not
+          pertain to any part of the Derivative Works, in at least one
+          of the following places: within a NOTICE text file distributed
+          as part of the Derivative Works; within the Source form or
+          documentation, if provided along with the Derivative Works; or,
+          within a display generated by the Derivative Works, if and
+          wherever such third-party notices normally appear. The contents
+          of the NOTICE file are for informational purposes only and
+          do not modify the License. You may add Your own attribution
+          notices within Derivative Works that You distribute, alongside
+          or as an addendum to the NOTICE text from the Work, provided
+          that such additional attribution notices cannot be construed
+          as modifying the License.
+
+      You may add Your own copyright statement to Your modifications and
+      may provide additional or different license terms and conditions
+      for use, reproduction, or distribution of Your modifications, or
+      for any such Derivative Works as a whole, provided Your use,
+      reproduction, and distribution of the Work otherwise complies with
+      the conditions stated in this License.
+
+   5. Submission of Contributions. Unless You explicitly state otherwise,
+      any Contribution intentionally submitted for inclusion in the Work
+      by You to the Licensor shall be under the terms and conditions of
+      this License, without any additional terms or conditions.
+      Notwithstanding the above, nothing herein shall supersede or modify
+      the terms of any separate license agreement you may have executed
+      with Licensor regarding such Contributions.
+
+   6. Trademarks. This License does not grant permission to use the trade
+      names, trademarks, service marks, or product names of the Licensor,
+      except as required for reasonable and customary use in describing the
+      origin of the Work and reproducing the content of the NOTICE file.
+
+   7. Disclaimer of Warranty. Unless required by applicable law or
+      agreed to in writing, Licensor provides the Work (and each
+      Contributor provides its Contributions) on an "AS IS" BASIS,
+      WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
+      implied, including, without limitation, any warranties or conditions
+      of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A
+      PARTICULAR PURPOSE. You are solely responsible for determining the
+      appropriateness of using or redistributing the Work and assume any
+      risks associated with Your exercise of permissions under this License.
+
+   8. Limitation of Liability. In no event and under no legal theory,
+      whether in tort (including negligence), contract, or otherwise,
+      unless required by applicable law (such as deliberate and grossly
+      negligent acts) or agreed to in writing, shall any Contributor be
+      liable to You for damages, including any direct, indirect, special,
+      incidental, or consequential damages of any character arising as a
+      result of this License or out of the use or inability to use the
+      Work (including but not limited to damages for loss of goodwill,
+      work stoppage, computer failure or malfunction, or any and all
+      other commercial damages or losses), even if such Contributor
+      has been advised of the possibility of such damages.
+
+   9. Accepting Warranty or Additional Liability. While redistributing
+      the Work or Derivative Works thereof, You may choose to offer,
+      and charge a fee for, acceptance of support, warranty, indemnity,
+      or other liability obligations and/or rights consistent with this
+      License. However, in accepting such obligations, You may act only
+      on Your own behalf and on Your sole responsibility, not on behalf
+      of any other Contributor, and only if You agree to indemnify,
+      defend, and hold each Contributor harmless for any liability
+      incurred by, or claims asserted against, such Contributor by reason
+      of your accepting any such warranty or additional liability.
+
+   END OF TERMS AND CONDITIONS
+
+   APPENDIX: How to apply the Apache License to your work.
+
+      To apply the Apache License to your work, attach the following
+      boilerplate notice, with the fields enclosed by brackets "[]"
+      replaced with your own identifying information. (Don't include
+      the brackets!)  The text should be enclosed in the appropriate
+      comment syntax for the file format. We also recommend that a
+      file or class name and description of purpose be included on the
+      same "printed page" as the copyright notice for easier
+      identification within third-party archives.
+
+   Copyright 2020 Sébastien Crozet
+
+   Licensed under the Apache License, Version 2.0 (the "License");
+   you may not use this file except in compliance with the License.
+   You may obtain a copy of the License at
+
+       http://www.apache.org/licenses/LICENSE-2.0
+
+   Unless required by applicable law or agreed to in writing, software
+   distributed under the License is distributed on an "AS IS" BASIS,
+   WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+   See the License for the specific language governing permissions and
+   limitations under the License.
diff --git a/bindings/bevy_rapier/ci/src/bin/ambiguity_detection.rs b/bindings/bevy_rapier/ci/src/bin/ambiguity_detection.rs
new file mode 100644
index 000000000..b9fc29101
--- /dev/null
+++ b/bindings/bevy_rapier/ci/src/bin/ambiguity_detection.rs
@@ -0,0 +1,116 @@
+//! A test to confirm that `bevy_rapier` doesn't regress its system ambiguities count when using [`DefaultPlugins`].
+//! This is run in CI.
+//!
+//! Note that because we want to test this in a more complete setup than examples, we're using a different project here.
+//! You can run this test using `cargo run --bin ambiguity_detection`.
+
+use bevy::{
+    app::Plugins,
+    ecs::schedule::{InternedScheduleLabel, LogLevel, ScheduleBuildSettings},
+    log::LogPlugin,
+    platform::collections::HashMap,
+    prelude::*,
+};
+
+fn main() {
+    check_ambiguities(
+        (
+            bevy_rapier3d::plugin::RapierPhysicsPlugin::<()>::default(),
+            bevy_rapier3d::prelude::RapierPickingPlugin,
+        ),
+        true,
+        // The Writeback systems run before `AssetEventSystems` (for the soft-body meshes), which
+        // orders the async-collider systems before the mesh change detection of `MeshPlugin` (see
+        // https://github.com/dimforge/bevy_rapier/issues/650).
+        0,
+    );
+    check_ambiguities(
+        (
+            bevy_rapier3d::plugin::RapierPhysicsPlugin::<()>::default().in_fixed_schedule(),
+            bevy_rapier3d::prelude::RapierPickingPlugin,
+        ),
+        false,
+        0,
+    );
+    check_ambiguities(
+        (
+            bevy_rapier2d::plugin::RapierPhysicsPlugin::<()>::default(),
+            bevy_rapier3d::prelude::RapierPickingPlugin,
+        ),
+        false,
+        0,
+    );
+    check_ambiguities(
+        (
+            bevy_rapier2d::plugin::RapierPhysicsPlugin::<()>::default().in_fixed_schedule(),
+            bevy_rapier3d::prelude::RapierPickingPlugin,
+        ),
+        false,
+        0,
+    );
+}
+
+fn check_ambiguities<M>(plugin: impl Plugins<M>, set_logger: bool, ambiguities_expected: usize) {
+    let mut app = App::new();
+    app.add_plugins((MinimalPlugins, TransformPlugin, AssetPlugin::default()));
+    if set_logger {
+        app.add_plugins(LogPlugin::default());
+    }
+    app.add_plugins(plugin);
+
+    let main_app = app.main_mut();
+    configure_ambiguity_detection(main_app);
+
+    app.finish();
+    app.cleanup();
+    app.update();
+
+    let main_app_ambiguities = count_ambiguities(app.main());
+    assert_eq!(
+        main_app_ambiguities.total(),
+        // FIXME: We should find those ambiguity and fix it, this should be 0
+        ambiguities_expected,
+        "Main app has unexpected ambiguities among the following schedules: \n{main_app_ambiguities:#?}.",
+    );
+}
+
+/// Contains the number of conflicting systems per schedule.
+#[derive(Debug, Deref, DerefMut)]
+struct AmbiguitiesCount(pub HashMap<InternedScheduleLabel, usize>);
+
+impl AmbiguitiesCount {
+    fn total(&self) -> usize {
+        self.values().sum()
+    }
+}
+
+fn configure_ambiguity_detection(sub_app: &mut SubApp) {
+    let mut schedules = sub_app.world_mut().resource_mut::<Schedules>();
+    for (_, schedule) in schedules.iter_mut() {
+        schedule.set_build_settings(ScheduleBuildSettings {
+            ambiguity_detection: LogLevel::Ignore,
+            use_shortnames: false,
+            ..default()
+        });
+    }
+}
+
+/// Returns the number of conflicting systems per schedule.
+fn count_ambiguities(sub_app: &SubApp) -> AmbiguitiesCount {
+    let schedules = sub_app.world().resource::<Schedules>();
+    let mut ambiguities = HashMap::default();
+    for (_, schedule) in schedules.iter() {
+        schedule.graph().conflicting_systems().iter().for_each(
+            |(system_a, system_b, components)| {
+                info!("Conflicting systems: {system_a:?} and {system_b:?} over components:");
+                for component in components {
+                    let component_info = sub_app.world().components().get_info(*component).unwrap();
+                    info!("{}", component_info.name());
+                }
+            },
+        );
+        let ambiguities_in_schedule = schedule.graph().conflicting_systems().len();
+        ambiguities.insert(schedule.label(), ambiguities_in_schedule);
+    }
+    AmbiguitiesCount(ambiguities)
+}
diff --git a/bindings/bevy_rapier/deny.toml b/bindings/bevy_rapier/deny.toml
new file mode 100644
index 000000000..c84331f76
--- /dev/null
+++ b/bindings/bevy_rapier/deny.toml
@@ -0,0 +1,50 @@
+[advisories]
+yanked = "deny"
+ignore = [
+    # paste was announced as unmaintained with no explanation or replacement
+    # See: 
+    # - https://rustsec.org/advisories/RUSTSEC-2024-0436
+    # - https://github.com/bevyengine/bevy/pull/18209
+    # Bevy relies on this in multiple indirect ways, so ignoring it is the only feasible current solution
+    "RUSTSEC-2024-0436",
+    # quick-xml advisories: pulled in transitively via bevy -> wayland-scanner, which
+    # pins quick-xml 0.39 and has no compatible upgrade to the patched >=0.41.0 yet.
+    # See: https://rustsec.org/advisories/RUSTSEC-2026-0194
+    "RUSTSEC-2026-0194",
+    # See: https://rustsec.org/advisories/RUSTSEC-2026-0195
+    "RUSTSEC-2026-0195",
+    # ttf-parser is unmaintained with no safe upgrade available; pulled in transitively
+    # via bevy -> ab_glyph -> owned_ttf_parser.
+    # See: https://rustsec.org/advisories/RUSTSEC-2026-0192
+    "RUSTSEC-2026-0192",
+]
+
+[licenses]
+allow = [
+    "MIT-0",
+    "MIT",
+    "Apache-2.0",
+    "Zlib",
+    "CC0-1.0",
+    "BSD-2-Clause",
+    "BSD-3-Clause",
+    "ISC",
+    "Unicode-3.0",
+    "NCSA",
+    "Apache-2.0 WITH LLVM-exception",
+]
+
+[[licenses.clarify]]
+name = "stretch"
+expression = "MIT"
+license-files = []
+
+[bans]
+multiple-versions = "allow"
+# Bevy is a git dependency on its main branch, which has no version requirement.
+wildcards = "allow"
+
+[sources]
+unknown-registry = "deny"
+unknown-git = "deny"
+allow-git = ["https://github.com/bevyengine/bevy"]
diff --git a/bindings/bevy_rapier/publish.sh b/bindings/bevy_rapier/publish.sh
new file mode 100755
index 000000000..b1422508d
--- /dev/null
+++ b/bindings/bevy_rapier/publish.sh
@@ -0,0 +1,87 @@
+#! /bin/bash
+#
+# Publishes both bevy_rapier crates to crates.io with a single
+# `cargo publish --workspace` invocation:
+#
+#   - bevy_rapier2d / bevy_rapier3d
+#
+# Cargo computes the dependency order itself and waits for each crate to become
+# available on the registry before publishing the ones that depend on it. The
+# `bevy_rapier_benches3d` and `ci` crates are marked `publish = false`, so
+# `--workspace` skips them.
+#
+# Why this script exists
+# ----------------------
+# Both crates share a single source tree at `<repo>/src`, referenced from each
+# manifest as `path = "../src/lib.rs"`. That path points outside the crate
+# directory, which `cargo publish` refuses to package.
+#
+# To work around it *only during publishing*, this script temporarily, for each
+# affected crate:
+#   1. rewrites the `[lib] path` to a crate-local one (i.e. `src/lib.rs`), and
+#   2. creates a symlink inside the crate pointing at the shared source tree.
+#
+# Cargo follows the symlink and bundles the real source into each `.crate`. A
+# trap restores the manifests and removes the symlinks on exit (including on
+# error or Ctrl-C), leaving the tree exactly as it was.
+#
+# Extra arguments are forwarded to `cargo publish`, e.g.:
+#   ./publish.sh --dry-run
+#   ./publish.sh --token "$CARGO_TOKEN"
+#
+# Requires cargo >= 1.90 (for `cargo publish --workspace`).
+
+set -euo pipefail
+
+ROOT="$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd)"
+cd "$ROOT"
+
+# Crates sharing `src/lib.rs`.
+SRC_CRATES=(bevy_rapier2d bevy_rapier3d)
+
+# Refuse to run on a dirty tree: the only diff during publishing must be our own
+# temporary edits, so the restore at the end is guaranteed to be correct.
+if [ -n "$(git status --porcelain)" ]; then
+    echo "error: working tree is not clean. Commit or stash changes before publishing." >&2
+    exit 1
+fi
+
+backup_dir="$(mktemp -d)"
+
+cleanup() {
+    for crate in "${SRC_CRATES[@]}"; do
+        # Remove the symlink we created (only if it is in fact a symlink).
+        [ -L "$crate/src" ] && rm -f "$crate/src"
+        # Restore the original manifest.
+        if [ -f "$backup_dir/$crate.Cargo.toml" ]; then
+            cp "$backup_dir/$crate.Cargo.toml" "$crate/Cargo.toml"
+        fi
+    done
+    rm -rf "$backup_dir"
+}
+trap cleanup EXIT INT TERM
+
+# Apply the temporary symlink layout: the shared `src` dir lives at the repo
+# root and is linked into each crate, while the manifest's `[lib] path` is made
+# crate-local.
+link_shared() {
+    local crate="$1"
+    local manifest="$crate/Cargo.toml"
+
+    cp "$manifest" "$backup_dir/$crate.Cargo.toml"
+
+    local tmp
+    tmp="$(mktemp)"
+    sed 's#path = "\.\./src/lib.rs"#path = "src/lib.rs"#' "$manifest" > "$tmp"
+    mv "$tmp" "$manifest"
+
+    ln -s ../src "$crate/src"
+}
+
+for crate in "${SRC_CRATES[@]}"; do
+    link_shared "$crate"
+done
+
+# Publish the whole workspace. `--allow-dirty` is required because our temporary
+# edits make the tree dirty; the clean-tree check above keeps that safe.
+cargo publish --workspace --allow-dirty "$@"
diff --git a/python/examples/.gitkeep b/bindings/bevy_rapier/rustfmt.toml
similarity index 100%
rename from python/examples/.gitkeep
rename to bindings/bevy_rapier/rustfmt.toml
diff --git a/bindings/bevy_rapier/src/control/character_controller.rs b/bindings/bevy_rapier/src/control/character_controller.rs
new file mode 100644
index 000000000..f402ae2c4
--- /dev/null
+++ b/bindings/bevy_rapier/src/control/character_controller.rs
@@ -0,0 +1,262 @@
+use crate::control::ControllerFilterPredicate;
+use crate::geometry::{Collider, CollisionGroups, ShapeCastHit};
+use crate::math::{Real, Rot, Vect};
+use bevy::ecs::entity::EntityHashSet;
+use bevy::prelude::*;
+
+use crate::plugin::context::RapierContextColliders;
+pub use rapier::control::CharacterAutostep;
+pub use rapier::control::CharacterLength;
+use rapier::prelude::{ColliderSet, QueryFilterFlags};
+
+/// A collision between the character and its environment during its movement.
+#[derive(Copy, Clone, PartialEq, Debug)]
+pub struct CharacterCollision {
+    /// The entity hit by the character.
+    pub entity: Entity,
+    /// The position of the character when the collider was hit.
+    pub character_translation: Vect,
+    /// The rotation of the character when the collider was hit.
+    pub character_rotation: Rot,
+    /// The translation that was already applied to the character when the hit happens.
+    pub translation_applied: Vect,
+    /// The translations that was still waiting to be applied to the character when the hit happens.
+    pub translation_remaining: Vect,
+    /// Geometric information about the hit: the first shape is the obstacle (world-space witness
+    /// and normal), the second one the character (local-space witness and normal).
+    pub hit: ShapeCastHit,
+}
+
+impl CharacterCollision {
+    pub(crate) fn from_raw(
+        ctxt: &RapierContextColliders,
+        c: &rapier::control::CharacterCollision,
+    ) -> Option<Self> {
+        Self::from_raw_with_set(&ctxt.colliders, c, true)
+    }
+
+    pub(crate) fn from_raw_with_set(
+        colliders: &ColliderSet,
+        c: &rapier::control::CharacterCollision,
+        details_always_computed: bool,
+    ) -> Option<Self> {
+        RapierContextColliders::collider_entity_with_set(colliders, c.handle).map(|entity| {
+            CharacterCollision {
+                entity,
+                character_translation: c.character_pos.translation,
+                #[cfg(feature = "dim2")]
+                character_rotation: c.character_pos.rotation.angle(),
+                #[cfg(feature = "dim3")]
+                character_rotation: c.character_pos.rotation,
+                translation_applied: c.translation_applied,
+                translation_remaining: c.translation_remaining,
+                hit: ShapeCastHit::from_rapier(c.hit, details_always_computed),
+            }
+        })
+    }
+}
+
+/// Options for moving a shape using `RapierContext::move_shape`.
+#[derive(Clone, Debug, Copy, PartialEq)]
+pub struct MoveShapeOptions {
+    /// The direction that goes "up". Used to determine where the floor is, and the floor’s angle.
+    pub up: Vect,
+    /// A small gap to preserve between the character and its surroundings.
+    ///
+    /// This value should not be too large to avoid visual artifacts, but shouldn’t be too small
+    /// (must not be zero) to improve numerical stability of the character controller.
+    pub offset: CharacterLength,
+    /// Should the character try to slide against the floor if it hits it?
+    pub slide: bool,
+    /// Should the character automatically step over small obstacles?
+    pub autostep: Option<CharacterAutostep>,
+    /// The maximum angle (radians) between the floor’s normal and the `up` vector that the
+    /// character is able to climb.
+    pub max_slope_climb_angle: Real,
+    /// The minimum angle (radians) between the floor’s normal and the `up` vector before the
+    /// character starts to slide down automatically.
+    pub min_slope_slide_angle: Real,
+    /// Should the character apply forces to dynamic bodies in its path?
+    pub apply_impulse_to_dynamic_bodies: bool,
+    /// Should the character be automatically snapped to the ground if the distance between
+    /// the ground and its feet are smaller than the specified threshold?
+    pub snap_to_ground: Option<CharacterLength>,
+    /// Increase this number if your character appears to get stuck when sliding against surfaces.
+    ///
+    /// This is a small distance applied to the movement toward the contact normals of shapes hit
+    /// by the character controller. This helps shape-casting not getting stuck in an always-penetrating
+    /// state during the sliding calculation.
+    ///
+    /// This value should remain fairly small since it can introduce artificial "bumps" when sliding
+    /// along a flat surface.
+    pub normal_nudge_factor: Real,
+}
+
+impl Default for MoveShapeOptions {
+    fn default() -> Self {
+        let def = rapier::control::KinematicCharacterController::default();
+        Self {
+            up: def.up,
+            offset: def.offset,
+            slide: def.slide,
+            autostep: def.autostep,
+            max_slope_climb_angle: def.max_slope_climb_angle,
+            min_slope_slide_angle: def.min_slope_slide_angle,
+            apply_impulse_to_dynamic_bodies: true,
+            snap_to_ground: def.snap_to_ground,
+            normal_nudge_factor: def.normal_nudge_factor,
+        }
+    }
+}
+
+/// A character controller for kinematic bodies and free-standing colliders.
+///
+/// The controller only computes translations: Rapier's character controller does not handle
+/// rotations, so the character's orientation must be updated separately (e.g. through its
+/// `Transform`).
+///
+/// The collider (or rigid-body) of the character itself is always excluded from the
+/// environment seen by the controller. Additional colliders can be excluded with
+/// [`Self::exclude_colliders`], [`Self::exclude_rigid_bodies`] and [`Self::filter_predicate`], or
+/// from every controller with the [`ControllerIgnored`](crate::control::ControllerIgnored)
+/// component.
+#[derive(Clone, Debug, Component)] // TODO: Reflect
+pub struct KinematicCharacterController {
+    /// The translations we desire the character to move by if it doesn’t meet any obstacle.
+    pub translation: Option<Vect>,
+    /// The shape, and its position, to be used instead of the shape of the collider attached to
+    /// the same entity is this `KinematicCharacterController`.
+    pub custom_shape: Option<(Collider, Vect, Rot)>,
+    /// The mass to be used for impulse of dynamic bodies. This replaces the mass of the rigid-body
+    /// potentially associated to the collider attached to the same entity as this
+    /// `KinematicCharacterController`.
+    ///
+    /// This field isn’t used if `Self::apply_impulse_to_dynamic_bodies` is set to `false`.
+    pub custom_mass: Option<Real>,
+    /// The direction that goes "up". Used to determine where the floor is, and the floor’s angle.
+    pub up: Vect,
+    /// A small gap to preserve between the character and its surroundings.
+    ///
+    /// This value should not be too large to avoid visual artifacts, but shouldn’t be too small
+    /// (must not be zero) to improve numerical stability of the character controller.
+    pub offset: CharacterLength,
+    /// Should the character try to slide against the floor if it hits it?
+    pub slide: bool,
+    /// Should the character automatically step over small obstacles?
+    pub autostep: Option<CharacterAutostep>,
+    /// The maximum angle (radians) between the floor’s normal and the `up` vector that the
+    /// character is able to climb.
+    pub max_slope_climb_angle: Real,
+    /// The minimum angle (radians) between the floor’s normal and the `up` vector before the
+    /// character starts to slide down automatically.
+    pub min_slope_slide_angle: Real,
+    /// Should the character apply forces to dynamic bodies in its path?
+    pub apply_impulse_to_dynamic_bodies: bool,
+    /// Should the character be automatically snapped to the ground if the distance between
+    /// the ground and its feet are smaller than the specified threshold?
+    pub snap_to_ground: Option<CharacterLength>,
+    /// Flags for filtering-out some categories of entities from the environment seen by the
+    /// character controller.
+    pub filter_flags: QueryFilterFlags,
+    /// Groups for filtering-out some colliders from the environment seen by the character
+    /// controller.
+    pub filter_groups: Option<CollisionGroups>,
+    /// Colliders (identified by their entity) ignored by the character controller.
+    pub exclude_colliders: EntityHashSet,
+    /// Rigid-bodies (identified by their entity) whose colliders are all ignored by the
+    /// character controller.
+    pub exclude_rigid_bodies: EntityHashSet,
+    /// If set, any collider for which this predicate returns `false` is ignored by the
+    /// character controller. It can't read ECS data: use the
+    /// [`ControllerIgnored`](crate::control::ControllerIgnored) component for exclusions decided
+    /// by systems.
+    pub filter_predicate: Option<ControllerFilterPredicate>,
+    /// Increase this number if your character appears to get stuck when sliding against surfaces.
+    ///
+    /// This is a small distance applied to the movement toward the contact normals of shapes hit
+    /// by the character controller. This helps shape-casting not getting stuck in an always-penetrating
+    /// state during the sliding calculation.
+    ///
+    /// This value should remain fairly small since it can introduce artificial "bumps" when sliding
+    /// along a flat surface.
+    pub normal_nudge_factor: Real,
+}
+
+impl KinematicCharacterController {
+    pub(crate) fn to_raw(&self) -> Option<rapier::control::KinematicCharacterController> {
+        let autostep = self.autostep.map(|autostep| CharacterAutostep {
+            max_height: autostep.max_height,
+            min_width: autostep.min_width,
+            include_dynamic_bodies: autostep.include_dynamic_bodies,
+        });
+
+        if self.up.length_squared() < 1.0e-12 {
+            return None;
+        }
+
+        Some(rapier::control::KinematicCharacterController {
+            up: self.up.normalize(),
+            offset: self.offset,
+            slide: self.slide,
+            autostep,
+            max_slope_climb_angle: self.max_slope_climb_angle,
+            min_slope_slide_angle: self.min_slope_slide_angle,
+            snap_to_ground: self.snap_to_ground,
+            normal_nudge_factor: self.normal_nudge_factor,
+        })
+    }
+}
+
+impl Default for KinematicCharacterController {
+    fn default() -> Self {
+        let def = rapier::control::KinematicCharacterController::default();
+        Self {
+            translation: None,
+            custom_shape: None,
+            custom_mass: None,
+            up: def.up,
+            offset: def.offset,
+            slide: def.slide,
+            autostep: def.autostep,
+            max_slope_climb_angle: def.max_slope_climb_angle,
+            min_slope_slide_angle: def.min_slope_slide_angle,
+            apply_impulse_to_dynamic_bodies: true,
+            snap_to_ground: def.snap_to_ground,
+            filter_flags: QueryFilterFlags::default() | QueryFilterFlags::EXCLUDE_SENSORS,
+            filter_groups: None,
+            exclude_colliders: EntityHashSet::default(),
+            exclude_rigid_bodies: EntityHashSet::default(),
+            filter_predicate: None,
+            normal_nudge_factor: def.normal_nudge_factor,
+        }
+    }
+}
+
+/// The output of a character control.
+///
+/// This component is automatically added after the first execution of a character control
+/// based on the `KinematicCharacterController` component with its
+/// `KinematicCharacterController::translation` set to a value other than `None`.
+#[derive(Clone, PartialEq, Debug, Default, Component)]
+pub struct KinematicCharacterControllerOutput {
+    /// Indicates whether the shape is grounded after its kinematic movement.
+    pub grounded: bool,
+    /// The initial desired movement of the character if there were no obstacle.
+    pub desired_translation: Vect,
+    /// The translation calculated by the last character control step taking obstacles into account.
+    pub effective_translation: Vect,
+    /// Collisions between the character and obstacles found in its path.
+    pub collisions: Vec<CharacterCollision>,
+    /// Indicates whether the shape is sliding down a slope after its kinematic movement.
+    pub is_sliding_down_slope: bool,
+}
+
+/// The allowed movement computed by `RapierContext::move_shape`.
+pub struct MoveShapeOutput {
+    /// Indicates whether the shape is grounded after its kinematic movement.
+    pub grounded: bool,
+    /// The translation calculated by the last character control step taking obstacles into account.
+    pub effective_translation: Vect,
+    /// Indicates whether the shape is sliding down a slope after its kinematic movement.
+    pub is_sliding_down_slope: bool,
+}
diff --git a/bindings/bevy_rapier/src/control/controller_filter.rs b/bindings/bevy_rapier/src/control/controller_filter.rs
new file mode 100644
index 000000000..fc0f08ddb
--- /dev/null
+++ b/bindings/bevy_rapier/src/control/controller_filter.rs
@@ -0,0 +1,104 @@
+use bevy::ecs::entity::EntityHashSet;
+use bevy::prelude::{Component, Entity, Reflect, ReflectComponent, ReflectDefault};
+use rapier::dynamics::RigidBodyHandle;
+use rapier::geometry::Collider as RapierCollider;
+use std::fmt;
+use std::sync::Arc;
+
+use crate::plugin::context::{RapierContextColliders, RapierRigidBodySet};
+
+/// Marker component excluding a collider from the environment seen by every controller (the
+/// [`KinematicCharacterController`]s, and the wheels of the `RayCastVehicleController`s in 3D).
+///
+/// Insert it on a collider entity to ignore that collider, or on a rigid-body entity to ignore
+/// all its colliders. Unlike [`ControllerFilterPredicate`], it can be inserted and removed by
+/// systems reading any ECS data (e.g. to let characters walk through the doors they own).
+///
+/// [`KinematicCharacterController`]: crate::control::KinematicCharacterController
+#[derive(Copy, Clone, Debug, Default, PartialEq, Eq, Component, Reflect)]
+#[reflect(Component, Default, PartialEq)]
+pub struct ControllerIgnored;
+
+/// A user-defined predicate deciding which colliders are seen by a controller.
+///
+/// The predicate is given the entity and Rapier collider of each candidate collider and must
+/// return `false` to exclude it. Since components cannot hold borrowed closures, the closure is
+/// reference-counted, and it can't read ECS data: see [`ControllerIgnored`] for exclusions
+/// computed by systems.
+#[derive(Clone)]
+#[allow(clippy::type_complexity)]
+pub struct ControllerFilterPredicate(
+    pub Arc<dyn Fn(Entity, &RapierCollider) -> bool + Send + Sync>,
+);
+
+impl ControllerFilterPredicate {
+    /// Wraps the given closure into a predicate usable by the controllers.
+    pub fn new(
+        predicate: impl Fn(Entity, &RapierCollider) -> bool + Send + Sync + 'static,
+    ) -> Self {
+        Self(Arc::new(predicate))
+    }
+
+    /// Evaluates the predicate for the given collider attached to `entity`.
+    pub fn test(&self, entity: Entity, collider: &RapierCollider) -> bool {
+        (self.0)(entity, collider)
+    }
+}
+
+impl fmt::Debug for ControllerFilterPredicate {
+    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+        f.write_str("ControllerFilterPredicate(..)")
+    }
+}
+
+/// Entity-based collider exclusions of a controller, resolved against the Rapier sets.
+pub(crate) struct ControllerExclusions<'a> {
+    colliders: &'a EntityHashSet,
+    /// The entities with a [`ControllerIgnored`] component.
+    ignored: &'a EntityHashSet,
+    rigid_bodies: Vec<RigidBodyHandle>,
+    predicate: Option<&'a ControllerFilterPredicate>,
+}
+
+impl<'a> ControllerExclusions<'a> {
+    /// Resolves the excluded rigid-body entities (and the rigid-bodies among the `ignored`
+    /// entities) into handles; entities without a rigid-body are ignored.
+    pub fn new(
+        colliders: &'a EntityHashSet,
+        rigid_bodies: &EntityHashSet,
+        ignored: &'a EntityHashSet,
+        predicate: Option<&'a ControllerFilterPredicate>,
+        rigidbody_set: &RapierRigidBodySet,
+    ) -> Self {
+        let rigid_bodies = rigid_bodies
+            .iter()
+            .chain(ignored.iter())
+            .filter_map(|e| rigidbody_set.entity2body.get(e).copied())
+            .collect();
+        Self {
+            colliders,
+            ignored,
+            rigid_bodies,
+            predicate,
+        }
+    }
+
+    /// Returns `true` if no collider can be excluded by `self`.
+    pub fn is_empty(&self) -> bool {
+        self.colliders.is_empty()
+            && self.ignored.is_empty()
+            && self.rigid_bodies.is_empty()
+            && self.predicate.is_none()
+    }
+
+    /// Returns `true` if the collider must be seen by the controller.
+    pub fn test(&self, collider: &RapierCollider) -> bool {
+        let entity = RapierContextColliders::entity_from_collider(collider);
+        !self.colliders.contains(&entity)
+            && !self.ignored.contains(&entity)
+            && collider
+                .parent()
+                .is_none_or(|parent| !self.rigid_bodies.contains(&parent))
+            && self.predicate.is_none_or(|p| p.test(entity, collider))
+    }
+}
diff --git a/bindings/bevy_rapier/src/control/mod.rs b/bindings/bevy_rapier/src/control/mod.rs
new file mode 100644
index 000000000..dc2749e06
--- /dev/null
+++ b/bindings/bevy_rapier/src/control/mod.rs
@@ -0,0 +1,16 @@
+pub use self::character_controller::{
+    CharacterAutostep, CharacterCollision, CharacterLength, KinematicCharacterController,
+    KinematicCharacterControllerOutput, MoveShapeOptions, MoveShapeOutput,
+};
+pub use self::controller_filter::{ControllerFilterPredicate, ControllerIgnored};
+pub use self::pid_controller::{AxesMask, PdController, PdErrors, PidController, PidTarget};
+#[cfg(feature = "dim3")]
+pub use self::vehicle_controller::{
+    RayCastVehicleController, VehicleWheel, VehicleWheelState, WheelTuning,
+};
+
+mod character_controller;
+pub(crate) mod controller_filter;
+mod pid_controller;
+#[cfg(feature = "dim3")]
+mod vehicle_controller;
diff --git a/bindings/bevy_rapier/src/control/pid_controller.rs b/bindings/bevy_rapier/src/control/pid_controller.rs
new file mode 100644
index 000000000..eca2ac3d2
--- /dev/null
+++ b/bindings/bevy_rapier/src/control/pid_controller.rs
@@ -0,0 +1,352 @@
+use crate::dynamics::Velocity;
+use crate::math::{AngVector, Real, Rot, Vect};
+use crate::utils;
+use bevy::prelude::*;
+use rapier::dynamics::{
+    AxesMask as RapierAxesMask, RigidBody as RapierRigidBody, RigidBodyVelocity,
+};
+
+pub use rapier::control::PdErrors;
+
+/// The axes affected by a [`PdController`] or a [`PidController`].
+///
+/// Only the axes with their flag set are taken into account when computing errors and
+/// corrections.
+#[derive(Copy, Clone, Debug, Default, PartialEq, Eq, Hash, Reflect)]
+#[cfg_attr(feature = "serde-serialize", derive(Serialize, Deserialize))]
+#[reflect(Default, PartialEq, Debug, Hash)]
+pub struct AxesMask(u8);
+
+bitflags::bitflags! {
+    impl AxesMask: u8 {
+        /// The translational X axis.
+        const LIN_X = 1 << 0;
+        /// The translational Y axis.
+        const LIN_Y = 1 << 1;
+        /// The translational Z axis.
+        #[cfg(feature = "dim3")]
+        const LIN_Z = 1 << 2;
+        /// The rotational X axis.
+        #[cfg(feature = "dim3")]
+        const ANG_X = 1 << 3;
+        /// The rotational Y axis.
+        #[cfg(feature = "dim3")]
+        const ANG_Y = 1 << 4;
+        /// The rotational Z axis.
+        const ANG_Z = 1 << 5;
+    }
+}
+
+impl AxesMask {
+    /// All the translational axes.
+    #[cfg(feature = "dim2")]
+    pub const LIN_AXES: Self = Self::LIN_X.union(Self::LIN_Y);
+    /// All the translational axes.
+    #[cfg(feature = "dim3")]
+    pub const LIN_AXES: Self = Self::LIN_X.union(Self::LIN_Y).union(Self::LIN_Z);
+    /// All the rotational axes.
+    #[cfg(feature = "dim2")]
+    pub const ANG_AXES: Self = Self::ANG_Z;
+    /// All the rotational axes.
+    #[cfg(feature = "dim3")]
+    pub const ANG_AXES: Self = Self::ANG_X.union(Self::ANG_Y).union(Self::ANG_Z);
+}
+
+impl From<AxesMask> for RapierAxesMask {
+    fn from(axes: AxesMask) -> RapierAxesMask {
+        RapierAxesMask::from_bits_truncate(axes.bits())
+    }
+}
+
+impl From<RapierAxesMask> for AxesMask {
+    fn from(axes: RapierAxesMask) -> AxesMask {
+        AxesMask::from_bits_truncate(axes.bits())
+    }
+}
+
+/// The world-space pose and velocities a [`PdController`] or [`PidController`] drives its
+/// rigid-body toward.
+///
+/// The target pose is the pose of the rigid-body itself (i.e. its `GlobalTransform` translation
+/// and rotation), not the pose of its center of mass.
+#[derive(Copy, Clone, Debug, Default, PartialEq, Reflect)]
+#[cfg_attr(feature = "serde-serialize", derive(Serialize, Deserialize))]
+#[reflect(Default, PartialEq, Debug)]
+pub struct PidTarget {
+    /// The target world-space translation.
+    pub translation: Vect,
+    /// The target world-space rotation.
+    pub rotation: Rot,
+    /// The target linear velocity.
+    pub linvel: Vect,
+    /// The target angular velocity.
+    pub angvel: AngVector,
+}
+
+impl PidTarget {
+    /// A target with the given pose and zero velocities.
+    pub fn new(translation: Vect, rotation: Rot) -> Self {
+        Self {
+            translation,
+            rotation,
+            ..Default::default()
+        }
+    }
+
+    /// A target with the given translation, an identity rotation and zero velocities.
+    pub fn from_translation(translation: Vect) -> Self {
+        Self {
+            translation,
+            ..Default::default()
+        }
+    }
+
+    /// Sets the target velocities.
+    pub fn with_velocities(mut self, linvel: Vect, angvel: AngVector) -> Self {
+        self.linvel = linvel;
+        self.angvel = angvel;
+        self
+    }
+
+    fn to_rapier(self) -> (rapier::math::Pose, RigidBodyVelocity<Real>) {
+        (
+            utils::pose_from(self.translation, self.rotation),
+            RigidBodyVelocity {
+                linvel: self.linvel,
+                angvel: self.angvel,
+            },
+        )
+    }
+}
+
+fn to_velocity(vels: RigidBodyVelocity<Real>) -> Velocity {
+    Velocity {
+        linear: vels.linvel,
+        angular: vels.angvel,
+    }
+}
+
+#[cfg(feature = "dim2")]
+fn splat_ang(value: Real) -> AngVector {
+    value
+}
+
+#[cfg(feature = "dim3")]
+fn splat_ang(value: Real) -> AngVector {
+    AngVector::splat(value)
+}
+
+/// A Proportional-Derivative (PD) controller driving a rigid-body toward a [`PidTarget`].
+///
+/// When attached to an entity with a non-fixed rigid-body, the plugin computes a velocity
+/// correction before each simulation step and adds it to the rigid-body's velocity. This is
+/// the PID controller without its Integral part, which is generally sufficient for games.
+/// Use either this or a [`PidController`] on a given entity, not both.
+#[derive(Copy, Clone, Debug, PartialEq, Component, Reflect)]
+#[cfg_attr(feature = "serde-serialize", derive(Serialize, Deserialize))]
+#[reflect(Component, Default, PartialEq, Debug)]
+pub struct PdController {
+    /// The pose and velocities the rigid-body is driven toward.
+    pub target: PidTarget,
+    /// The Proportional gain applied to the instantaneous linear position errors.
+    ///
+    /// This is usually set to a multiple of the inverse of the simulation timestep
+    /// (e.g. `60` if the timestep is `1.0 / 60.0`).
+    pub lin_kp: Vect,
+    /// The Derivative gain applied to the instantaneous linear velocity errors.
+    ///
+    /// This is usually in `[0.0, 1.0]`, where `1.0` corrects velocity errors in a single step.
+    pub lin_kd: Vect,
+    /// The Proportional gain applied to the instantaneous angular position errors.
+    pub ang_kp: AngVector,
+    /// The Derivative gain applied to the instantaneous angular velocity errors.
+    pub ang_kd: AngVector,
+    /// The axes affected by this controller.
+    pub axes: AxesMask,
+}
+
+impl Default for PdController {
+    fn default() -> Self {
+        Self::from_raw(&rapier::control::PdController::default())
+    }
+}
+
+impl PdController {
+    /// Initializes a PD controller with the same gains on all axes, and a default target.
+    ///
+    /// Only the axes specified in `axes` are controlled.
+    pub fn new(kp: Real, kd: Real, axes: AxesMask) -> Self {
+        Self::from_raw(&rapier::control::PdController::new(kp, kd, axes.into()))
+    }
+
+    /// Sets the target of this controller.
+    pub fn with_target(mut self, target: PidTarget) -> Self {
+        self.target = target;
+        self
+    }
+
+    /// Converts a Rapier PD controller into this component, with a default target.
+    pub fn from_raw(raw: &rapier::control::PdController) -> Self {
+        Self {
+            target: PidTarget::default(),
+            lin_kp: raw.lin_kp,
+            lin_kd: raw.lin_kd,
+            ang_kp: raw.ang_kp,
+            ang_kd: raw.ang_kd,
+            axes: raw.axes.into(),
+        }
+    }
+
+    /// Converts this component into a Rapier PD controller (the target is not part of it).
+    pub fn to_raw(&self) -> rapier::control::PdController {
+        rapier::control::PdController {
+            lin_kp: self.lin_kp,
+            lin_kd: self.lin_kd,
+            ang_kp: self.ang_kp,
+            ang_kd: self.ang_kd,
+            axes: self.axes.into(),
+        }
+    }
+
+    /// Computes the velocity correction from the given position and velocity errors.
+    pub fn correction(&self, pose_errors: &PdErrors, vel_errors: &PdErrors) -> Velocity {
+        to_velocity(self.to_raw().correction(pose_errors, vel_errors))
+    }
+
+    /// Computes the velocity correction driving the given Rapier rigid-body toward [`Self::target`].
+    pub fn rigid_body_correction(&self, body: &RapierRigidBody) -> Velocity {
+        let (pose, vels) = self.target.to_rapier();
+        to_velocity(self.to_raw().rigid_body_correction(body, pose, vels))
+    }
+}
+
+/// A Proportional-Integral-Derivative (PID) controller driving a rigid-body toward a [`PidTarget`].
+///
+/// When attached to an entity with a non-fixed rigid-body, the plugin computes a velocity
+/// correction before each simulation step and adds it to the rigid-body's velocity. The
+/// accumulated errors of the Integral part are updated at each step. Use either this or a
+/// [`PdController`] on a given entity, not both.
+#[derive(Copy, Clone, Debug, PartialEq, Component, Reflect)]
+#[cfg_attr(feature = "serde-serialize", derive(Serialize, Deserialize))]
+#[reflect(Component, Default, PartialEq, Debug)]
+pub struct PidController {
+    /// The pose and velocities the rigid-body is driven toward.
+    pub target: PidTarget,
+    /// The Proportional gain applied to the instantaneous linear position errors.
+    ///
+    /// This is usually set to a multiple of the inverse of the simulation timestep
+    /// (e.g. `60` if the timestep is `1.0 / 60.0`).
+    pub lin_kp: Vect,
+    /// The Integral gain applied to the accumulated linear position errors.
+    pub lin_ki: Vect,
+    /// The Derivative gain applied to the instantaneous linear velocity errors.
+    ///
+    /// This is usually in `[0.0, 1.0]`, where `1.0` corrects velocity errors in a single step.
+    pub lin_kd: Vect,
+    /// The Proportional gain applied to the instantaneous angular position errors.
+    pub ang_kp: AngVector,
+    /// The Integral gain applied to the accumulated angular position errors.
+    pub ang_ki: AngVector,
+    /// The Derivative gain applied to the instantaneous angular velocity errors.
+    pub ang_kd: AngVector,
+    /// The axes affected by this controller.
+    pub axes: AxesMask,
+    /// The linear position error accumulated through time (updated by the plugin).
+    pub lin_integral: Vect,
+    /// The angular position error accumulated through time (updated by the plugin).
+    pub ang_integral: AngVector,
+}
+
+impl Default for PidController {
+    fn default() -> Self {
+        Self::from_raw(&rapier::control::PidController::default())
+    }
+}
+
+impl PidController {
+    /// Initializes a PID controller with the same gains on all axes, and a default target.
+    ///
+    /// Only the axes specified in `axes` are controlled.
+    pub fn new(kp: Real, ki: Real, kd: Real, axes: AxesMask) -> Self {
+        Self::from_raw(&rapier::control::PidController::new(
+            kp,
+            ki,
+            kd,
+            axes.into(),
+        ))
+    }
+
+    /// Sets the target of this controller.
+    pub fn with_target(mut self, target: PidTarget) -> Self {
+        self.target = target;
+        self
+    }
+
+    /// Resets to zero the accumulated errors used by the Integral part of the controller.
+    pub fn reset_integrals(&mut self) {
+        self.lin_integral = Vect::ZERO;
+        self.ang_integral = splat_ang(0.0);
+    }
+
+    /// Converts a Rapier PID controller into this component, with a default target.
+    pub fn from_raw(raw: &rapier::control::PidController) -> Self {
+        Self {
+            target: PidTarget::default(),
+            lin_kp: raw.pd.lin_kp,
+            lin_ki: raw.lin_ki,
+            lin_kd: raw.pd.lin_kd,
+            ang_kp: raw.pd.ang_kp,
+            ang_ki: raw.ang_ki,
+            ang_kd: raw.pd.ang_kd,
+            axes: raw.pd.axes.into(),
+            lin_integral: raw.lin_integral,
+            ang_integral: raw.ang_integral,
+        }
+    }
+
+    /// Converts this component into a Rapier PID controller (the target is not part of it).
+    pub fn to_raw(&self) -> rapier::control::PidController {
+        rapier::control::PidController {
+            pd: rapier::control::PdController {
+                lin_kp: self.lin_kp,
+                lin_kd: self.lin_kd,
+                ang_kp: self.ang_kp,
+                ang_kd: self.ang_kd,
+                axes: self.axes.into(),
+            },
+            lin_integral: self.lin_integral,
+            ang_integral: self.ang_integral,
+            lin_ki: self.lin_ki,
+            ang_ki: self.ang_ki,
+        }
+    }
+
+    fn read_integrals(&mut self, raw: &rapier::control::PidController) {
+        self.lin_integral = raw.lin_integral;
+        self.ang_integral = raw.ang_integral;
+    }
+
+    /// Computes the velocity correction from the given position and velocity errors, and
+    /// accumulates the position errors for the Integral part.
+    pub fn correction(
+        &mut self,
+        dt: Real,
+        pose_errors: &PdErrors,
+        vel_errors: &PdErrors,
+    ) -> Velocity {
+        let mut raw = self.to_raw();
+        let result = raw.correction(dt, pose_errors, vel_errors);
+        self.read_integrals(&raw);
+        to_velocity(result)
+    }
+
+    /// Computes the velocity correction driving the given Rapier rigid-body toward
+    /// [`Self::target`], and accumulates the position errors for the Integral part.
+    pub fn rigid_body_correction(&mut self, dt: Real, body: &RapierRigidBody) -> Velocity {
+        let (pose, vels) = self.target.to_rapier();
+        let mut raw = self.to_raw();
+        let result = raw.rigid_body_correction(dt, body, pose, vels);
+        self.read_integrals(&raw);
+        to_velocity(result)
+    }
+}
diff --git a/bindings/bevy_rapier/src/control/vehicle_controller.rs b/bindings/bevy_rapier/src/control/vehicle_controller.rs
new file mode 100644
index 000000000..f88224ffd
--- /dev/null
+++ b/bindings/bevy_rapier/src/control/vehicle_controller.rs
@@ -0,0 +1,239 @@
+use crate::control::ControllerFilterPredicate;
+use crate::geometry::CollisionGroups;
+use crate::math::{Real, Vect};
+use crate::reflect::WheelTuningWrapper;
+use bevy::ecs::entity::EntityHashSet;
+use bevy::prelude::*;
+use rapier::control::DynamicRayCastVehicleController;
+use rapier::prelude::QueryFilterFlags;
+
+pub use rapier::control::WheelTuning;
+
+/// The state of a [`VehicleWheel`] computed by the plugin at the last vehicle update.
+///
+/// World-space quantities are expressed relative to the chassis pose before the last
+/// simulation step.
+#[derive(Copy, Clone, Debug, Default, PartialEq, Reflect)]
+#[reflect(Default, PartialEq, Debug)]
+pub struct VehicleWheelState {
+    /// The wheel's current rotation angle (in radians) around its axle.
+    ///
+    /// This increases when the vehicle rolls along the wheel's forward direction
+    /// (`contact_normal × axle`).
+    pub rotation: Real,
+    /// The current length of the wheel's suspension.
+    pub suspension_length: Real,
+    /// Is the wheel in contact with the ground?
+    pub is_in_contact: bool,
+    /// The world-space point hit by the wheel's ray-cast.
+    pub contact_point: Vect,
+    /// The world-space contact normal between the wheel and the ground.
+    pub contact_normal: Vect,
+    /// The world-space starting point of the wheel's ray-cast.
+    pub hard_point: Vect,
+    /// The world-space center of the wheel.
+    pub center: Vect,
+    /// The world-space direction of the wheel's suspension.
+    pub suspension_direction: Vect,
+    /// The world-space direction of the wheel's axle, including steering.
+    pub axle_direction: Vect,
+    /// The collider entity hit by the wheel's ray-cast, if any.
+    pub ground_entity: Option<Entity>,
+    /// The force applied by the suspension.
+    pub suspension_force: Real,
+    /// The forward impulse applied by the wheel on the chassis.
+    pub forward_impulse: Real,
+    /// The side impulse applied by the wheel on the chassis.
+    pub side_impulse: Real,
+}
+
+/// A wheel of a [`RayCastVehicleController`].
+///
+/// The description fields (connection point, directions, lengths, tuning) and the controls
+/// (engine force, brake, steering) can be modified at any time. The [`Self::state`] is
+/// written by the plugin at each vehicle update.
+#[derive(Copy, Clone, Debug, PartialEq, Reflect)]
+#[reflect(Default, PartialEq, Debug)]
+pub struct VehicleWheel {
+    /// The position of the wheel's suspension attachment, in the chassis' local space.
+    pub chassis_connection_point: Vect,
+    /// The direction of the wheel's suspension, in the chassis' local space.
+    ///
+    /// The ray-cast detecting the ground follows this direction.
+    pub direction: Vect,
+    /// The wheel's axle axis, in the chassis' local space.
+    pub axle: Vect,
+    /// The rest length of the wheel's suspension spring.
+    pub suspension_rest_length: Real,
+    /// The wheel's radius.
+    pub radius: Real,
+    /// Parameters affecting the physical behavior of the wheel.
+    #[reflect(remote = WheelTuningWrapper)]
+    pub tuning: WheelTuning,
+    /// The forward force applied by this wheel on the chassis.
+    pub engine_force: Real,
+    /// The maximum braking impulse applied by this wheel to slow down the vehicle.
+    pub brake: Real,
+    /// The steering angle (in radians) of this wheel, around the suspension direction.
+    pub steering: Real,
+    /// The state of the wheel, written back by the plugin.
+    pub state: VehicleWheelState,
+}
+
+impl Default for VehicleWheel {
+    fn default() -> Self {
+        Self {
+            chassis_connection_point: Vect::ZERO,
+            direction: -Vect::Y,
+            axle: Vect::Z,
+            suspension_rest_length: 0.5,
+            radius: 0.5,
+            tuning: WheelTuning::default(),
+            engine_force: 0.0,
+            brake: 0.0,
+            steering: 0.0,
+            state: VehicleWheelState::default(),
+        }
+    }
+}
+
+impl VehicleWheel {
+    /// Creates a wheel with the given geometry, the given tuning, and no engine force,
+    /// brake, or steering.
+    pub fn new(
+        chassis_connection_point: Vect,
+        direction: Vect,
+        axle: Vect,
+        suspension_rest_length: Real,
+        radius: Real,
+        tuning: WheelTuning,
+    ) -> Self {
+        Self {
+            chassis_connection_point,
+            direction,
+            axle,
+            suspension_rest_length,
+            radius,
+            tuning,
+            ..Default::default()
+        }
+    }
+
+    /// The wheel's transform relative to the chassis, for rendering.
+    ///
+    /// The translation is the wheel center at the current suspension length, and the rotation
+    /// combines steering (around the suspension direction) and spin (around the axle).
+    pub fn local_transform(&self) -> Transform {
+        let translation =
+            self.chassis_connection_point + self.direction * self.state.suspension_length;
+        let steering = Quat::from_axis_angle(-self.direction.normalize_or_zero(), self.steering);
+        // Rolling forward along `normal × axle` is a negative rotation around the axle.
+        let spin = Quat::from_axis_angle(self.axle.normalize_or_zero(), -self.state.rotation);
+        Transform::from_translation(translation).with_rotation(steering * spin)
+    }
+
+    pub(crate) fn sync_to_raw(&self, raw: &mut rapier::control::Wheel) {
+        raw.chassis_connection_point_cs = self.chassis_connection_point;
+        raw.direction_cs = self.direction;
+        raw.axle_cs = self.axle;
+        raw.suspension_rest_length = self.suspension_rest_length;
+        raw.radius = self.radius;
+        raw.suspension_stiffness = self.tuning.suspension_stiffness;
+        raw.damping_compression = self.tuning.suspension_compression;
+        raw.damping_relaxation = self.tuning.suspension_damping;
+        raw.max_suspension_travel = self.tuning.max_suspension_travel;
+        raw.side_friction_stiffness = self.tuning.side_friction_stiffness;
+        raw.friction_slip = self.tuning.friction_slip;
+        raw.max_suspension_force = self.tuning.max_suspension_force;
+        raw.engine_force = self.engine_force;
+        raw.brake = self.brake;
+        raw.steering = self.steering;
+    }
+}
+
+/// A vehicle controller simulating wheels with ray-casts, attached to the chassis rigid-body.
+///
+/// Before each simulation step, the plugin casts one ray per wheel along its suspension
+/// direction, then applies suspension, engine, braking and friction impulses to the chassis,
+/// which must be a dynamic rigid-body on the same entity. Colliders attached to the chassis
+/// rigid-body are always ignored by the ray-casts. The results are written back into each
+/// wheel's [`VehicleWheel::state`] and into [`Self::current_vehicle_speed`].
+///
+/// The impulses are computed once per plugin update using the last simulation timestep, so
+/// this is best used with a fixed timestep.
+#[derive(Clone, Debug, Component, Reflect)]
+#[reflect(Component, Default, Debug)]
+pub struct RayCastVehicleController {
+    /// The wheels of this vehicle.
+    ///
+    /// Wheels can be added, removed or modified at any time.
+    pub wheels: Vec<VehicleWheel>,
+    /// The chassis' local up axis (`0 = x, 1 = y, 2 = z`).
+    pub index_up_axis: usize,
+    /// The chassis' local forward axis (`0 = x, 1 = y, 2 = z`).
+    ///
+    /// This is only used to determine the sign of [`Self::current_vehicle_speed`].
+    pub index_forward_axis: usize,
+    /// Flags for excluding some categories of colliders from the wheels' ray-casts.
+    #[reflect(ignore)]
+    pub filter_flags: QueryFilterFlags,
+    /// Groups for excluding some colliders from the wheels' ray-casts.
+    pub filter_groups: Option<CollisionGroups>,
+    /// Colliders (identified by their entity) ignored by the wheels' ray-casts.
+    pub exclude_colliders: EntityHashSet,
+    /// Rigid-bodies (identified by their entity) whose colliders are all ignored by the
+    /// wheels' ray-casts.
+    pub exclude_rigid_bodies: EntityHashSet,
+    /// If set, any collider for which this predicate returns `false` is ignored by the wheels'
+    /// ray-casts. The colliders with a [`ControllerIgnored`](crate::control::ControllerIgnored)
+    /// component (or attached to a rigid-body with one) are always ignored.
+    #[reflect(ignore)]
+    pub filter_predicate: Option<ControllerFilterPredicate>,
+    /// The current forward speed of the vehicle, written back by the plugin.
+    ///
+    /// It is negative if the vehicle moves backward along its forward axis.
+    pub current_vehicle_speed: Real,
+    /// The underlying Rapier controller, created and synchronized automatically by the plugin.
+    ///
+    /// Its wheels are overwritten from [`Self::wheels`] before each update.
+    #[reflect(ignore)]
+    pub raw: Option<DynamicRayCastVehicleController>,
+}
+
+impl Default for RayCastVehicleController {
+    fn default() -> Self {
+        Self {
+            wheels: vec![],
+            index_up_axis: 1,
+            index_forward_axis: 0,
+            filter_flags: QueryFilterFlags::EXCLUDE_SENSORS,
+            filter_groups: None,
+            exclude_colliders: EntityHashSet::default(),
+            exclude_rigid_bodies: EntityHashSet::default(),
+            filter_predicate: None,
+            current_vehicle_speed: 0.0,
+            raw: None,
+        }
+    }
+}
+
+impl RayCastVehicleController {
+    /// Creates a vehicle controller with the given wheels.
+    pub fn new(wheels: Vec<VehicleWheel>) -> Self {
+        Self {
+            wheels,
+            ..Default::default()
+        }
+    }
+
+    /// Adds a wheel to this vehicle.
+    pub fn add_wheel(&mut self, wheel: VehicleWheel) -> &mut Self {
+        self.wheels.push(wheel);
+        self
+    }
+
+    /// Is any wheel of this vehicle in contact with the ground?
+    pub fn any_wheel_in_contact(&self) -> bool {
+        self.wheels.iter().any(|w| w.state.is_in_contact)
+    }
+}
diff --git a/bindings/bevy_rapier/src/dynamics/fixed_joint.rs b/bindings/bevy_rapier/src/dynamics/fixed_joint.rs
new file mode 100644
index 000000000..4508b179c
--- /dev/null
+++ b/bindings/bevy_rapier/src/dynamics/fixed_joint.rs
@@ -0,0 +1,176 @@
+use crate::dynamics::{GenericJoint, GenericJointBuilder};
+use crate::math::{Real, Rot, Vect};
+use rapier::dynamics::JointAxesMask;
+
+use super::{SpringCoefficients, TypedJoint};
+
+#[derive(Copy, Clone, Debug, PartialEq)]
+#[repr(transparent)]
+/// A fixed joint, locks all relative motion between two bodies.
+pub struct FixedJoint {
+    /// The underlying joint data.
+    pub data: GenericJoint,
+}
+
+impl Default for FixedJoint {
+    fn default() -> Self {
+        FixedJoint::new()
+    }
+}
+
+impl FixedJoint {
+    /// Creates a new fixed joint.
+    #[must_use]
+    pub fn new() -> Self {
+        let data = GenericJointBuilder::new(JointAxesMask::LOCKED_FIXED_AXES).build();
+        Self { data }
+    }
+
+    /// Are contacts between the attached rigid-bodies enabled?
+    pub fn contacts_enabled(&self) -> bool {
+        self.data.contacts_enabled()
+    }
+
+    /// Sets whether contacts between the attached rigid-bodies are enabled.
+    pub fn set_contacts_enabled(&mut self, enabled: bool) -> &mut Self {
+        self.data.set_contacts_enabled(enabled);
+        self
+    }
+
+    /// The spring coefficients controlling the softness of this joint’s locked degrees of freedom.
+    #[must_use]
+    pub fn softness(&self) -> SpringCoefficients<Real> {
+        self.data.softness()
+    }
+
+    /// Sets the spring coefficients controlling the softness of this joint’s locked degrees of freedom.
+    pub fn set_softness(&mut self, softness: SpringCoefficients<Real>) -> &mut Self {
+        self.data.set_softness(softness);
+        self
+    }
+
+    /// The joint’s basis, expressed in the first rigid-body’s local-space.
+    #[must_use]
+    pub fn local_basis1(&self) -> Rot {
+        self.data.local_basis1()
+    }
+
+    /// Sets the joint’s basis, expressed in the first rigid-body’s local-space.
+    pub fn set_local_basis1(&mut self, local_basis: Rot) -> &mut Self {
+        self.data.set_local_basis1(local_basis);
+        self
+    }
+
+    /// The joint’s basis, expressed in the second rigid-body’s local-space.
+    #[must_use]
+    pub fn local_basis2(&self) -> Rot {
+        self.data.local_basis2()
+    }
+
+    /// Sets joint’s basis, expressed in the second rigid-body’s local-space.
+    pub fn set_local_basis2(&mut self, local_basis: Rot) -> &mut Self {
+        self.data.set_local_basis2(local_basis);
+        self
+    }
+
+    /// The joint’s anchor, expressed in the local-space of the first rigid-body.
+    #[must_use]
+    pub fn local_anchor1(&self) -> Vect {
+        self.data.local_anchor1()
+    }
+
+    /// Sets the joint’s anchor, expressed in the local-space of the first rigid-body.
+    pub fn set_local_anchor1(&mut self, anchor1: Vect) -> &mut Self {
+        self.data.set_local_anchor1(anchor1);
+        self
+    }
+
+    /// The joint’s anchor, expressed in the local-space of the second rigid-body.
+    #[must_use]
+    pub fn local_anchor2(&self) -> Vect {
+        self.data.local_anchor2()
+    }
+
+    /// Sets the joint’s anchor, expressed in the local-space of the second rigid-body.
+    pub fn set_local_anchor2(&mut self, anchor2: Vect) -> &mut Self {
+        self.data.set_local_anchor2(anchor2);
+        self
+    }
+}
+
+impl From<FixedJoint> for GenericJoint {
+    fn from(joint: FixedJoint) -> GenericJoint {
+        joint.data
+    }
+}
+
+/// Create fixed joints using the builder pattern.
+#[derive(Copy, Clone, Debug, PartialEq, Default)]
+pub struct FixedJointBuilder(FixedJoint);
+
+impl FixedJointBuilder {
+    /// Creates a new builder for fixed joints.
+    pub fn new() -> Self {
+        Self(FixedJoint::new())
+    }
+
+    /// Sets the joint’s basis, expressed in the first rigid-body’s local-space.
+    #[must_use]
+    pub fn local_basis1(mut self, local_basis: Rot) -> Self {
+        self.0.set_local_basis1(local_basis);
+        self
+    }
+
+    /// Sets joint’s basis, expressed in the second rigid-body’s local-space.
+    #[must_use]
+    pub fn local_basis2(mut self, local_basis: Rot) -> Self {
+        self.0.set_local_basis2(local_basis);
+        self
+    }
+
+    /// Sets the joint’s anchor, expressed in the local-space of the first rigid-body.
+    #[must_use]
+    pub fn local_anchor1(mut self, anchor1: Vect) -> Self {
+        self.0.set_local_anchor1(anchor1);
+        self
+    }
+
+    /// Sets the joint’s anchor, expressed in the local-space of the second rigid-body.
+    #[must_use]
+    pub fn local_anchor2(mut self, anchor2: Vect) -> Self {
+        self.0.set_local_anchor2(anchor2);
+        self
+    }
+
+    /// Sets whether contacts between the attached rigid-bodies are enabled.
+    #[must_use]
+    pub fn contacts_enabled(mut self, enabled: bool) -> Self {
+        self.0.set_contacts_enabled(enabled);
+        self
+    }
+
+    /// Sets the spring coefficients controlling the softness of this joint’s locked degrees of freedom.
+    #[must_use]
+    pub fn softness(mut self, softness: SpringCoefficients<Real>) -> Self {
+        self.0.set_softness(softness);
+        self
+    }
+
+    /// Build the fixed joint.
+    #[must_use]
+    pub fn build(self) -> FixedJoint {
+        self.0
+    }
+}
+
+impl From<FixedJointBuilder> for TypedJoint {
+    fn from(joint: FixedJointBuilder) -> TypedJoint {
+        joint.0.into()
+    }
+}
+
+impl From<FixedJoint> for TypedJoint {
+    fn from(joint: FixedJoint) -> TypedJoint {
+        TypedJoint::FixedJoint(joint)
+    }
+}
diff --git a/bindings/bevy_rapier/src/dynamics/generic_joint.rs b/bindings/bevy_rapier/src/dynamics/generic_joint.rs
new file mode 100644
index 000000000..2945c7758
--- /dev/null
+++ b/bindings/bevy_rapier/src/dynamics/generic_joint.rs
@@ -0,0 +1,556 @@
+use crate::dynamics::{FixedJoint, PrismaticJoint, RevoluteJoint, RopeJoint, TypedJoint};
+use crate::math::{Real, Rot, Vect};
+use rapier::dynamics::{
+    GenericJoint as RapierGenericJoint, JointAxesMask, JointAxis, JointLimits, JointMotor,
+    MotorModel, SpringCoefficients,
+};
+use rapier::math::Pose;
+
+#[cfg(feature = "dim2")]
+use crate::dynamics::PinSlotJoint;
+
+#[cfg(feature = "dim3")]
+use crate::dynamics::SphericalJoint;
+
+/// The description of any joint.
+#[cfg_attr(feature = "serde-serialize", derive(Serialize, Deserialize))]
+#[derive(Copy, Clone, Debug, PartialEq, Default)]
+#[repr(transparent)]
+pub struct GenericJoint {
+    /// The raw Rapier description of the joint.
+    pub raw: RapierGenericJoint,
+}
+
+impl GenericJoint {
+    /// Converts this joint into a Rapier joint.
+    pub fn into_rapier(self) -> RapierGenericJoint {
+        self.raw
+    }
+}
+
+/*
+ * NOTE: the following are copy-pasted from Rapier’s GenericJoint, to match its
+ *       construction methods, but using glam types.
+ */
+
+impl GenericJoint {
+    /// Creates a new generic joint that locks the specified degrees of freedom.
+    #[must_use]
+    pub fn new(locked_axes: JointAxesMask) -> Self {
+        Self {
+            raw: RapierGenericJoint::new(locked_axes),
+        }
+    }
+
+    /// The set of axes locked by this joint.
+    pub fn locked_axes(&self) -> JointAxesMask {
+        self.raw.locked_axes
+    }
+
+    /// Add the specified axes to the set of axes locked by this joint.
+    pub fn lock_axes(&mut self, axes: JointAxesMask) -> &mut Self {
+        self.raw.lock_axes(axes);
+        self
+    }
+
+    /// The basis of this joint, expressed in the first rigid-body’s local-space.
+    #[must_use]
+    pub fn local_basis1(&self) -> Rot {
+        #[cfg(feature = "dim2")]
+        return self.raw.local_frame1.rotation.angle();
+        #[cfg(feature = "dim3")]
+        return self.raw.local_frame1.rotation;
+    }
+
+    /// Sets the joint’s frame, expressed in the first rigid-body’s local-space.
+    pub fn set_local_basis1(&mut self, local_basis: Rot) -> &mut Self {
+        #[cfg(feature = "dim2")]
+        {
+            self.raw.local_frame1.rotation = rapier::math::Rot2::new(local_basis);
+        }
+        #[cfg(feature = "dim3")]
+        {
+            self.raw.local_frame1.rotation = local_basis;
+        }
+        self
+    }
+
+    /// The basis of this joint, expressed in the second rigid-body’s local-space.
+    #[must_use]
+    pub fn local_basis2(&self) -> Rot {
+        #[cfg(feature = "dim2")]
+        return self.raw.local_frame2.rotation.angle();
+        #[cfg(feature = "dim3")]
+        return self.raw.local_frame2.rotation;
+    }
+
+    /// Sets the joint’s frame, expressed in the second rigid-body’s local-space.
+    pub fn set_local_basis2(&mut self, local_basis: Rot) -> &mut Self {
+        #[cfg(feature = "dim2")]
+        {
+            self.raw.local_frame2.rotation = rapier::math::Rot2::new(local_basis);
+        }
+        #[cfg(feature = "dim3")]
+        {
+            self.raw.local_frame2.rotation = local_basis;
+        }
+        self
+    }
+
+    /// The principal (local X) axis of this joint, expressed in the first rigid-body’s local-space.
+    #[must_use]
+    pub fn local_axis1(&self) -> Vect {
+        self.raw.local_axis1()
+    }
+
+    /// Sets the principal (local X) axis of this joint, expressed in the first rigid-body’s local-space.
+    pub fn set_local_axis1(&mut self, local_axis: Vect) -> &mut Self {
+        self.raw.set_local_axis1(local_axis.normalize());
+        self
+    }
+
+    /// The principal (local X) axis of this joint, expressed in the second rigid-body’s local-space.
+    #[must_use]
+    pub fn local_axis2(&self) -> Vect {
+        self.raw.local_axis2()
+    }
+
+    /// Sets the principal (local X) axis of this joint, expressed in the second rigid-body’s local-space.
+    pub fn set_local_axis2(&mut self, local_axis: Vect) -> &mut Self {
+        self.raw.set_local_axis2(local_axis.normalize());
+        self
+    }
+
+    /// The anchor of this joint, expressed in the first rigid-body’s local-space.
+    #[must_use]
+    pub fn local_anchor1(&self) -> Vect {
+        self.raw.local_anchor1()
+    }
+
+    /// Sets anchor of this joint, expressed in the first rigid-body’s local-space.
+    pub fn set_local_anchor1(&mut self, anchor1: Vect) -> &mut Self {
+        self.raw.set_local_anchor1(anchor1);
+        self
+    }
+
+    /// The anchor of this joint, expressed in the second rigid-body’s local-space.
+    #[must_use]
+    pub fn local_anchor2(&self) -> Vect {
+        self.raw.local_anchor2()
+    }
+
+    /// Sets anchor of this joint, expressed in the second rigid-body’s local-space.
+    pub fn set_local_anchor2(&mut self, anchor2: Vect) -> &mut Self {
+        self.raw.set_local_anchor2(anchor2);
+        self
+    }
+
+    /// The joint’s frame (anchor and basis), expressed in the first rigid-body’s local-space.
+    #[must_use]
+    pub fn local_frame1(&self) -> Pose {
+        self.raw.local_frame1
+    }
+
+    /// Sets the joint’s frame (anchor and basis), expressed in the first rigid-body’s local-space.
+    pub fn set_local_frame1(&mut self, local_frame: Pose) -> &mut Self {
+        self.raw.set_local_frame1(local_frame);
+        self
+    }
+
+    /// The joint’s frame (anchor and basis), expressed in the second rigid-body’s local-space.
+    #[must_use]
+    pub fn local_frame2(&self) -> Pose {
+        self.raw.local_frame2
+    }
+
+    /// Sets the joint’s frame (anchor and basis), expressed in the second rigid-body’s local-space.
+    pub fn set_local_frame2(&mut self, local_frame: Pose) -> &mut Self {
+        self.raw.set_local_frame2(local_frame);
+        self
+    }
+
+    /// Are contacts between the attached rigid-bodies enabled?
+    pub fn contacts_enabled(&self) -> bool {
+        self.raw.contacts_enabled
+    }
+
+    /// Sets whether contacts between the attached rigid-bodies are enabled.
+    pub fn set_contacts_enabled(&mut self, enabled: bool) -> &mut Self {
+        self.raw.set_contacts_enabled(enabled);
+        self
+    }
+
+    /// Is this joint enabled?
+    ///
+    /// This only reflects the value set on this joint description. See
+    /// [`ImpulseJointDisabled`](crate::dynamics::ImpulseJointDisabled) for a marker component
+    /// disabling an impulse joint.
+    pub fn is_enabled(&self) -> bool {
+        self.raw.is_enabled()
+    }
+
+    /// Sets whether this joint is enabled.
+    ///
+    /// A disabled impulse joint is ignored by the solver but stays attached to its rigid-bodies.
+    /// Multibody joints ignore this flag, except for filtering contacts between attached bodies.
+    pub fn set_enabled(&mut self, enabled: bool) -> &mut Self {
+        self.raw.set_enabled(enabled);
+        self
+    }
+
+    /// The spring coefficients controlling the softness of this joint’s locked degrees of freedom.
+    #[must_use]
+    pub fn softness(&self) -> SpringCoefficients<Real> {
+        self.raw.softness
+    }
+
+    /// Sets the spring coefficients controlling the softness of this joint’s locked degrees of freedom.
+    pub fn set_softness(&mut self, softness: SpringCoefficients<Real>) -> &mut Self {
+        self.raw.softness = softness;
+        self
+    }
+
+    /// Flips the orientation of the joint, swapping its two frames and negating its limits and motor targets.
+    ///
+    /// This is useful to keep the joint’s behavior unchanged after swapping its two attached rigid-bodies.
+    pub fn flip(&mut self) -> &mut Self {
+        self.raw.flip();
+        self
+    }
+
+    /// The joint limits along the specified axis.
+    #[must_use]
+    pub fn limits(&self, axis: JointAxis) -> Option<&JointLimits<Real>> {
+        self.raw.limits(axis)
+    }
+
+    /// Sets the joint limits along the specified axis.
+    pub fn set_limits(&mut self, axis: JointAxis, limits: [Real; 2]) -> &mut Self {
+        self.raw.set_limits(axis, limits);
+        self
+    }
+
+    /// Sets the coupled degrees of freedom for this joint’s limits and motor.
+    pub fn set_coupled_axes(&mut self, axes: JointAxesMask) -> &mut Self {
+        self.raw.coupled_axes = axes;
+        self
+    }
+
+    /// The spring-like motor model along the specified axis of this joint.
+    #[must_use]
+    pub fn motor_model(&self, axis: JointAxis) -> Option<MotorModel> {
+        self.raw.motor_model(axis)
+    }
+
+    /// Set the spring-like model used by the motor to reach the desired target velocity and position.
+    pub fn set_motor_model(&mut self, axis: JointAxis, model: MotorModel) -> &mut Self {
+        self.raw.set_motor_model(axis, model);
+        self
+    }
+
+    /// Sets the target velocity this motor needs to reach.
+    pub fn set_motor_velocity(
+        &mut self,
+        axis: JointAxis,
+        target_vel: Real,
+        factor: Real,
+    ) -> &mut Self {
+        self.raw.set_motor_velocity(axis, target_vel, factor);
+        self
+    }
+
+    /// Sets the target angle this motor needs to reach.
+    pub fn set_motor_position(
+        &mut self,
+        axis: JointAxis,
+        target_pos: Real,
+        stiffness: Real,
+        damping: Real,
+    ) -> &mut Self {
+        self.raw
+            .set_motor_position(axis, target_pos, stiffness, damping);
+        self
+    }
+
+    /// Sets the maximum force the motor can deliver along the specified axis.
+    pub fn set_motor_max_force(&mut self, axis: JointAxis, max_force: Real) -> &mut Self {
+        self.raw.set_motor_max_force(axis, max_force);
+        self
+    }
+
+    /// The motor affecting the joint’s degree of freedom along the specified axis.
+    #[must_use]
+    pub fn motor(&self, axis: JointAxis) -> Option<&JointMotor> {
+        self.raw.motor(axis)
+    }
+
+    /// Configure both the target angle and target velocity of the motor.
+    pub fn set_motor(
+        &mut self,
+        axis: JointAxis,
+        target_pos: Real,
+        target_vel: Real,
+        stiffness: Real,
+        damping: Real,
+    ) -> &mut Self {
+        self.raw
+            .set_motor(axis, target_pos, target_vel, stiffness, damping);
+        self
+    }
+}
+
+macro_rules! joint_conversion_methods(
+    ($as_joint: ident, $as_joint_mut: ident, $Joint: ty, $axes: expr) => {
+        /// Converts the joint to its specific variant, if it is one.
+        #[must_use]
+        pub fn $as_joint(&self) -> Option<&$Joint> {
+            if self.locked_axes() == $axes {
+                // SAFETY: this is OK because the target joint type is
+                //         a `repr(transparent)` newtype of `Joint`.
+                Some(unsafe { std::mem::transmute::<&Self, &$Joint>(self) })
+            } else {
+                None
+            }
+        }
+
+        /// Converts the joint to its specific mutable variant, if it is one.
+        #[must_use]
+        pub fn $as_joint_mut(&mut self) -> Option<&mut $Joint> {
+            if self.locked_axes() == $axes {
+                // SAFETY: this is OK because the target joint type is
+                //         a `repr(transparent)` newtype of `Joint`.
+                Some(unsafe { std::mem::transmute::<&mut Self, &mut $Joint>(self) })
+            } else {
+                None
+            }
+        }
+    }
+);
+
+impl GenericJoint {
+    joint_conversion_methods!(
+        as_revolute,
+        as_revolute_mut,
+        RevoluteJoint,
+        JointAxesMask::LOCKED_REVOLUTE_AXES
+    );
+    joint_conversion_methods!(
+        as_fixed,
+        as_fixed_mut,
+        FixedJoint,
+        JointAxesMask::LOCKED_FIXED_AXES
+    );
+    joint_conversion_methods!(
+        as_prismatic,
+        as_prismatic_mut,
+        PrismaticJoint,
+        JointAxesMask::LOCKED_PRISMATIC_AXES
+    );
+    joint_conversion_methods!(
+        as_rope,
+        as_rope_mut,
+        RopeJoint,
+        JointAxesMask::FREE_FIXED_AXES
+    );
+
+    #[cfg(feature = "dim3")]
+    joint_conversion_methods!(
+        as_spherical,
+        as_spherical_mut,
+        SphericalJoint,
+        JointAxesMask::LOCKED_SPHERICAL_AXES
+    );
+
+    #[cfg(feature = "dim2")]
+    joint_conversion_methods!(
+        as_pin_slot,
+        as_pin_slot_mut,
+        PinSlotJoint,
+        JointAxesMask::LOCKED_PIN_SLOT_AXES
+    );
+}
+
+/// Create generic joints using the builder pattern.
+#[cfg_attr(feature = "serde-serialize", derive(Serialize, Deserialize))]
+#[derive(Copy, Clone, Debug)]
+pub struct GenericJointBuilder(GenericJoint);
+
+impl GenericJointBuilder {
+    /// Creates a new generic joint builder.
+    #[must_use]
+    pub fn new(locked_axes: JointAxesMask) -> Self {
+        Self(GenericJoint::new(locked_axes))
+    }
+
+    /// Sets the degrees of freedom locked by the joint.
+    #[must_use]
+    pub fn locked_axes(mut self, axes: JointAxesMask) -> Self {
+        self.0.lock_axes(axes);
+        self
+    }
+
+    /// Sets the joint’s frame, expressed in the first rigid-body’s local-space.
+    #[must_use]
+    pub fn local_basis1(mut self, local_basis: Rot) -> Self {
+        self.0.set_local_basis1(local_basis);
+        self
+    }
+
+    /// Sets the joint’s frame, expressed in the second rigid-body’s local-space.
+    #[must_use]
+    pub fn local_basis2(mut self, local_basis: Rot) -> Self {
+        self.0.set_local_basis2(local_basis);
+        self
+    }
+
+    /// Sets the principal (local X) axis of this joint, expressed in the first rigid-body’s local-space.
+    #[must_use]
+    pub fn local_axis1(mut self, local_axis: Vect) -> Self {
+        self.0.set_local_axis1(local_axis);
+        self
+    }
+
+    /// Sets the principal (local X) axis of this joint, expressed in the second rigid-body’s local-space.
+    #[must_use]
+    pub fn local_axis2(mut self, local_axis: Vect) -> Self {
+        self.0.set_local_axis2(local_axis);
+        self
+    }
+
+    /// Sets the anchor of this joint, expressed in the first rigid-body’s local-space.
+    #[must_use]
+    pub fn local_anchor1(mut self, anchor1: Vect) -> Self {
+        self.0.set_local_anchor1(anchor1);
+        self
+    }
+
+    /// Sets the anchor of this joint, expressed in the second rigid-body’s local-space.
+    #[must_use]
+    pub fn local_anchor2(mut self, anchor2: Vect) -> Self {
+        self.0.set_local_anchor2(anchor2);
+        self
+    }
+
+    /// Sets the joint’s frame (anchor and basis), expressed in the first rigid-body’s local-space.
+    #[must_use]
+    pub fn local_frame1(mut self, local_frame: Pose) -> Self {
+        self.0.set_local_frame1(local_frame);
+        self
+    }
+
+    /// Sets the joint’s frame (anchor and basis), expressed in the second rigid-body’s local-space.
+    #[must_use]
+    pub fn local_frame2(mut self, local_frame: Pose) -> Self {
+        self.0.set_local_frame2(local_frame);
+        self
+    }
+
+    /// Sets whether contacts between the attached rigid-bodies are enabled.
+    #[must_use]
+    pub fn contacts_enabled(mut self, enabled: bool) -> Self {
+        self.0.set_contacts_enabled(enabled);
+        self
+    }
+
+    /// Sets whether the joint is enabled.
+    #[must_use]
+    pub fn enabled(mut self, enabled: bool) -> Self {
+        self.0.set_enabled(enabled);
+        self
+    }
+
+    /// Sets the spring coefficients controlling the softness of this joint’s locked degrees of freedom.
+    #[must_use]
+    pub fn softness(mut self, softness: SpringCoefficients<Real>) -> Self {
+        self.0.set_softness(softness);
+        self
+    }
+
+    /// Sets the joint limits along the specified axis.
+    #[must_use]
+    pub fn limits(mut self, axis: JointAxis, limits: [Real; 2]) -> Self {
+        self.0.set_limits(axis, limits);
+        self
+    }
+
+    /// Sets the coupled degrees of freedom for this joint’s limits and motor.
+    #[must_use]
+    pub fn coupled_axes(mut self, axes: JointAxesMask) -> Self {
+        self.0.set_coupled_axes(axes);
+        self
+    }
+
+    /// Set the spring-like model used by the motor to reach the desired target velocity and position.
+    #[must_use]
+    pub fn motor_model(mut self, axis: JointAxis, model: MotorModel) -> Self {
+        self.0.set_motor_model(axis, model);
+        self
+    }
+
+    /// Sets the target velocity this motor needs to reach.
+    #[must_use]
+    pub fn motor_velocity(mut self, axis: JointAxis, target_vel: Real, factor: Real) -> Self {
+        self.0.set_motor_velocity(axis, target_vel, factor);
+        self
+    }
+
+    /// Sets the target angle this motor needs to reach.
+    #[must_use]
+    pub fn motor_position(
+        mut self,
+        axis: JointAxis,
+        target_pos: Real,
+        stiffness: Real,
+        damping: Real,
+    ) -> Self {
+        self.0
+            .set_motor_position(axis, target_pos, stiffness, damping);
+        self
+    }
+
+    /// Configure both the target angle and target velocity of the motor.
+    #[must_use]
+    pub fn set_motor(
+        mut self,
+        axis: JointAxis,
+        target_pos: Real,
+        target_vel: Real,
+        stiffness: Real,
+        damping: Real,
+    ) -> Self {
+        self.0
+            .set_motor(axis, target_pos, target_vel, stiffness, damping);
+        self
+    }
+
+    /// Sets the maximum force the motor can deliver along the specified axis.
+    #[must_use]
+    pub fn motor_max_force(mut self, axis: JointAxis, max_force: Real) -> Self {
+        self.0.set_motor_max_force(axis, max_force);
+        self
+    }
+
+    /// Builds the generic joint.
+    #[must_use]
+    pub fn build(self) -> GenericJoint {
+        self.0
+    }
+}
+
+impl From<GenericJointBuilder> for GenericJoint {
+    fn from(joint: GenericJointBuilder) -> GenericJoint {
+        joint.0
+    }
+}
+
+impl From<GenericJointBuilder> for TypedJoint {
+    fn from(joint: GenericJointBuilder) -> TypedJoint {
+        joint.0.into()
+    }
+}
+
+impl From<GenericJoint> for TypedJoint {
+    fn from(joint: GenericJoint) -> TypedJoint {
+        TypedJoint::GenericJoint(joint)
+    }
+}
diff --git a/bindings/bevy_rapier/src/dynamics/joint.rs b/bindings/bevy_rapier/src/dynamics/joint.rs
new file mode 100644
index 000000000..3a39f8e8e
--- /dev/null
+++ b/bindings/bevy_rapier/src/dynamics/joint.rs
@@ -0,0 +1,219 @@
+use crate::math::{AngVector, Real, Vect};
+use bevy::prelude::*;
+use rapier::dynamics::{
+    ImpulseJoint as RapierImpulseJoint, ImpulseJointHandle, MultibodyJointHandle,
+};
+
+pub use rapier::dynamics::{JointAxesMask, JointAxis, MotorModel, SpringCoefficients};
+
+use super::{
+    FixedJoint, GenericJoint, MultibodyJointState, PrismaticJoint, RevoluteJoint, RopeJoint,
+    SpringJoint,
+};
+
+#[cfg(doc)]
+use super::{
+    KinematicMultibodyJoint, MultibodyJointArmature, MultibodyJointCouplings,
+    MultibodyJointDamping, MultibodyJointFriction, MultibodyJointSprings,
+};
+
+#[cfg(feature = "dim2")]
+use super::PinSlotJoint;
+#[cfg(feature = "dim3")]
+use super::SphericalJoint;
+
+/// Wrapper enum over a specific joint.
+#[derive(Clone, Copy, Debug, PartialEq)]
+pub enum TypedJoint {
+    /// See [`FixedJoint`]
+    FixedJoint(FixedJoint),
+    /// See [`GenericJoint`]
+    GenericJoint(GenericJoint),
+    /// See [`PrismaticJoint`]
+    PrismaticJoint(PrismaticJoint),
+    /// See [`RevoluteJoint`]
+    RevoluteJoint(RevoluteJoint),
+    /// See [`RopeJoint`]
+    RopeJoint(RopeJoint),
+    /// See [`SphericalJoint`]
+    #[cfg(feature = "dim3")]
+    SphericalJoint(SphericalJoint),
+    /// See [`SpringJoint`]
+    SpringJoint(SpringJoint),
+    /// See [`PinSlotJoint`]
+    #[cfg(feature = "dim2")]
+    PinSlotJoint(PinSlotJoint),
+}
+
+impl AsMut<GenericJoint> for TypedJoint {
+    fn as_mut(&mut self) -> &mut GenericJoint {
+        match self {
+            TypedJoint::FixedJoint(ref mut j) => &mut j.data,
+            TypedJoint::GenericJoint(ref mut j) => j,
+            TypedJoint::PrismaticJoint(ref mut j) => &mut j.data,
+            TypedJoint::RevoluteJoint(ref mut j) => &mut j.data,
+            TypedJoint::RopeJoint(ref mut j) => &mut j.data,
+            #[cfg(feature = "dim3")]
+            TypedJoint::SphericalJoint(ref mut j) => &mut j.data,
+            TypedJoint::SpringJoint(ref mut j) => &mut j.data,
+            #[cfg(feature = "dim2")]
+            TypedJoint::PinSlotJoint(ref mut j) => &mut j.data,
+        }
+    }
+}
+
+impl AsRef<GenericJoint> for TypedJoint {
+    fn as_ref(&self) -> &GenericJoint {
+        match self {
+            TypedJoint::FixedJoint(j) => &j.data,
+            TypedJoint::GenericJoint(j) => j,
+            TypedJoint::PrismaticJoint(j) => &j.data,
+            TypedJoint::RevoluteJoint(j) => &j.data,
+            TypedJoint::RopeJoint(j) => &j.data,
+            #[cfg(feature = "dim3")]
+            TypedJoint::SphericalJoint(j) => &j.data,
+            TypedJoint::SpringJoint(j) => &j.data,
+            #[cfg(feature = "dim2")]
+            TypedJoint::PinSlotJoint(j) => &j.data,
+        }
+    }
+}
+
+/// The handle of an impulse joint added to the physics scene.
+#[derive(Copy, Clone, Debug, Component)]
+pub struct RapierImpulseJointHandle(pub ImpulseJointHandle);
+
+/// The handle of a multibody joint added to the physics scene.
+#[derive(Copy, Clone, Debug, Component)]
+pub struct RapierMultibodyJointHandle(pub MultibodyJointHandle);
+
+/// An impulse-based joint attached to two entities.
+///
+/// The first end-point of the joint is the rigid-body attached to
+/// `ImpulseJoint::parent`. The second endpoint of the joint is the
+/// rigid-body attached to the entity (or the parent of the entity)
+/// containing this `ImpulseJoint` component.
+///
+/// To attach multiple impulse joints to the same rigid-body, multiple
+/// joints can be added in the children of the entity containing that
+/// rigid-body (this is similar to the technique used to attach multiple
+/// colliders to the same rigid-body).
+///
+/// Modifying `parent` re-attaches the joint to the rigid-body of the new parent entity. Add the
+/// [`ImpulseJointDisabled`] component to disable the joint, and read the impulses it applied
+/// during the last simulation step from the [`ImpulseJointImpulses`] component.
+///
+/// Note that the `user_data` of the underlying Rapier joint is reserved: it stores the bits of
+/// the entity containing this component.
+#[derive(Copy, Clone, Debug, PartialEq, Component)]
+#[require(ImpulseJointImpulses)]
+pub struct ImpulseJoint {
+    /// The entity containing the rigid-body used as the first endpoint of this joint.
+    pub parent: Entity,
+    /// The joint’s description.
+    pub data: TypedJoint,
+}
+
+impl ImpulseJoint {
+    /// Initializes an impulse-based joint from its first endpoint and the joint description.
+    pub fn new(parent: Entity, data: impl Into<TypedJoint>) -> Self {
+        Self {
+            parent,
+            data: data.into(),
+        }
+    }
+}
+
+/// Marker component disabling the [`ImpulseJoint`] of its entity.
+///
+/// A disabled joint stays attached to its rigid-bodies but is ignored by the constraints solver.
+/// Removing this component enables the joint again. Multibody joints cannot be disabled.
+#[derive(Copy, Clone, Default, Debug, PartialEq, Eq, Component, Reflect)]
+#[reflect(Component, Default, PartialEq)]
+pub struct ImpulseJointDisabled;
+
+/// The number of degrees of freedom of a joint (3 in 2D, 6 in 3D).
+#[cfg(feature = "dim2")]
+pub const JOINT_DOFS: usize = 3;
+/// The number of degrees of freedom of a joint (3 in 2D, 6 in 3D).
+#[cfg(feature = "dim3")]
+pub const JOINT_DOFS: usize = 6;
+
+/// The impulses applied by an [`ImpulseJoint`] during the last simulation step.
+///
+/// This component is automatically added alongside [`ImpulseJoint`] and updated after each
+/// simulation step. Comparing these impulses with a threshold can be used to implement
+/// breakable joints (by removing the [`ImpulseJoint`] once the threshold is exceeded).
+///
+/// All impulses are expressed along the axes of the joint frame attached to the first
+/// rigid-body. Divide them by the (sub)step length to get the corresponding forces.
+#[derive(Copy, Clone, Debug, Default, PartialEq, Component, Reflect)]
+#[reflect(Component, Default, PartialEq)]
+pub struct ImpulseJointImpulses {
+    /// The impulse applied along the locked translational degrees of freedom.
+    pub linear: Vect,
+    /// The angular impulse applied along the locked rotational degrees of freedom.
+    pub angular: AngVector,
+    /// The impulse applied by the limits along each degree of freedom (see [`JointAxis`]).
+    pub limits: [Real; JOINT_DOFS],
+    /// The impulse applied by the motors along each degree of freedom (see [`JointAxis`]).
+    pub motors: [Real; JOINT_DOFS],
+}
+
+impl ImpulseJointImpulses {
+    /// Reads the impulses applied by the given Rapier impulse joint.
+    pub fn from_rapier(joint: &RapierImpulseJoint) -> Self {
+        let impulses = joint.impulses;
+        #[cfg(feature = "dim2")]
+        let (linear, angular) = (Vect::new(impulses[0], impulses[1]), impulses[2]);
+        #[cfg(feature = "dim3")]
+        let (linear, angular) = (
+            Vect::new(impulses[0], impulses[1], impulses[2]),
+            AngVector::new(impulses[3], impulses[4], impulses[5]),
+        );
+        Self {
+            linear,
+            angular,
+            limits: std::array::from_fn(|i| joint.data.limits[i].impulse),
+            motors: std::array::from_fn(|i| joint.data.motors[i].impulse),
+        }
+    }
+}
+
+/// An joint based on generalized coordinates, attached to two entities.
+///
+/// The first end-point of the joint is the rigid-body attached to
+/// `MultibodyJoint::parent`. The second endpoint of the joint is the
+/// rigid-body attached to the entity containing this `MultibodyJoint` component.
+///
+/// Note that a set of multibody joints cannot form closed loops (for example a necklace).
+/// If a closed loop is detected, the last joint that closes the loop is ignored, and an
+/// error is printed to `stderr` (using `log::error!`).
+///
+/// Modifying `parent` re-attaches the joint to the rigid-body of the new parent entity. The
+/// joint can be further configured with the [`KinematicMultibodyJoint`],
+/// [`MultibodyJointDamping`], [`MultibodyJointFriction`], [`MultibodyJointArmature`],
+/// [`MultibodyJointSprings`] and [`MultibodyJointCouplings`] components, and its coordinates are
+/// read back into the [`MultibodyJointState`] component after each simulation step.
+///
+/// Note that the `user_data` of the underlying Rapier joint is reserved: it stores the bits of
+/// the entity containing this component.
+#[derive(Copy, Clone, Debug, PartialEq, Component)]
+#[require(MultibodyJointState)]
+pub struct MultibodyJoint {
+    /// The entity containing the rigid-body used as the first endpoint of this joint.
+    pub parent: Entity,
+    /// The joint’s description.
+    pub data: TypedJoint,
+}
+
+impl MultibodyJoint {
+    /// Initializes an joint based on reduced coordinates from its first endpoint and
+    /// the joint description.
+    pub fn new(parent: Entity, data: impl Into<TypedJoint>) -> Self {
+        Self {
+            parent,
+            data: data.into(),
+        }
+    }
+}
diff --git a/bindings/bevy_rapier/src/dynamics/mod.rs b/bindings/bevy_rapier/src/dynamics/mod.rs
new file mode 100644
index 000000000..31251cb5b
--- /dev/null
+++ b/bindings/bevy_rapier/src/dynamics/mod.rs
@@ -0,0 +1,148 @@
+pub use self::generic_joint::*;
+pub use self::joint::*;
+pub use self::multibody::*;
+pub use self::rigid_body::*;
+pub use self::soft_body::*;
+
+pub use self::fixed_joint::*;
+pub use self::prismatic_joint::*;
+pub use self::revolute_joint::*;
+pub use self::rope_joint::*;
+pub use self::spring_joint::*;
+
+use bevy::reflect::Reflect;
+use rapier::dynamics::CoefficientCombineRule as RapierCoefficientCombineRule;
+
+#[cfg(feature = "dim2")]
+pub use self::pin_slot_joint::*;
+#[cfg(feature = "dim3")]
+pub use self::spherical_joint::*;
+
+mod generic_joint;
+mod joint;
+mod multibody;
+mod rigid_body;
+pub mod soft_body;
+
+mod fixed_joint;
+mod prismatic_joint;
+mod revolute_joint;
+mod rope_joint;
+
+#[cfg(feature = "dim2")]
+mod pin_slot_joint;
+#[cfg(feature = "dim3")]
+mod spherical_joint;
+mod spring_joint;
+
+/// Rules used to combine two coefficients.
+///
+/// This is used to determine the effective restitution and
+/// friction coefficients for a contact between two colliders.
+/// Each collider has its combination rule of type
+/// `CoefficientCombineRule`. And the rule
+/// actually used is given by `max(first_combine_rule as usize, second_combine_rule as usize)`,
+/// i.e., `GeometricMean > ClampedSum > Max > Multiply > Min > Average`.
+///
+/// It is set by the [`Friction`] and [`Restitution`] components of colliders, and applies to
+/// every contact between colliders, whether they are attached to a rigid-body or not.
+///
+/// [`Friction`]: crate::geometry::Friction
+/// [`Restitution`]: crate::geometry::Restitution
+#[derive(Copy, Clone, Debug, PartialEq, Eq, Reflect, Default)]
+#[cfg_attr(feature = "serde-serialize", derive(Serialize, Deserialize))]
+pub enum CoefficientCombineRule {
+    #[default]
+    /// The two coefficients are averaged.
+    Average = 0,
+    /// The smallest coefficient is chosen.
+    Min,
+    /// The two coefficients are multiplied.
+    Multiply,
+    /// The greatest coefficient is chosen.
+    Max,
+    /// The sum of the two coefficients, clamped to the range `[0, 1]`.
+    ClampedSum,
+    /// The square root of the product of the two coefficients.
+    ///
+    /// This is zero if either coefficient is zero.
+    GeometricMean,
+}
+
+impl CoefficientCombineRule {
+    /// Combines two coefficients according to their respective combine rules.
+    ///
+    /// If the two rules differ, the one with the highest priority is used
+    /// (`GeometricMean > ClampedSum > Max > Multiply > Min > Average`).
+    pub fn combine(coeff1: f32, coeff2: f32, rule1: Self, rule2: Self) -> f32 {
+        RapierCoefficientCombineRule::combine(coeff1, coeff2, rule1.into(), rule2.into())
+    }
+}
+
+impl From<CoefficientCombineRule> for RapierCoefficientCombineRule {
+    fn from(combine_rule: CoefficientCombineRule) -> RapierCoefficientCombineRule {
+        match combine_rule {
+            CoefficientCombineRule::Average => RapierCoefficientCombineRule::Average,
+            CoefficientCombineRule::Min => RapierCoefficientCombineRule::Min,
+            CoefficientCombineRule::Multiply => RapierCoefficientCombineRule::Multiply,
+            CoefficientCombineRule::Max => RapierCoefficientCombineRule::Max,
+            CoefficientCombineRule::ClampedSum => RapierCoefficientCombineRule::ClampedSum,
+            CoefficientCombineRule::GeometricMean => RapierCoefficientCombineRule::GeometricMean,
+        }
+    }
+}
+
+impl From<RapierCoefficientCombineRule> for CoefficientCombineRule {
+    fn from(combine_rule: RapierCoefficientCombineRule) -> CoefficientCombineRule {
+        match combine_rule {
+            RapierCoefficientCombineRule::Average => CoefficientCombineRule::Average,
+            RapierCoefficientCombineRule::Min => CoefficientCombineRule::Min,
+            RapierCoefficientCombineRule::Multiply => CoefficientCombineRule::Multiply,
+            RapierCoefficientCombineRule::Max => CoefficientCombineRule::Max,
+            RapierCoefficientCombineRule::ClampedSum => CoefficientCombineRule::ClampedSum,
+            RapierCoefficientCombineRule::GeometricMean => CoefficientCombineRule::GeometricMean,
+        }
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use super::CoefficientCombineRule as Rule;
+
+    #[test]
+    fn combine_rules() {
+        assert_eq!(Rule::combine(0.2, 0.6, Rule::Average, Rule::Average), 0.4);
+        assert_eq!(Rule::combine(0.2, 0.6, Rule::Min, Rule::Average), 0.2);
+        assert_eq!(Rule::combine(0.5, 0.6, Rule::Multiply, Rule::Min), 0.3);
+        assert_eq!(Rule::combine(0.2, 0.6, Rule::Max, Rule::Multiply), 0.6);
+        assert_eq!(Rule::combine(0.7, 0.6, Rule::ClampedSum, Rule::Max), 1.0);
+        assert_eq!(
+            Rule::combine(0.2, 0.3, Rule::Average, Rule::ClampedSum),
+            0.5
+        );
+        assert_eq!(
+            Rule::combine(0.25, 1.0, Rule::ClampedSum, Rule::GeometricMean),
+            0.5
+        );
+        assert_eq!(
+            Rule::combine(0.0, 0.8, Rule::GeometricMean, Rule::Average),
+            0.0
+        );
+    }
+
+    #[test]
+    fn combine_rule_conversions_round_trip() {
+        for rule in [
+            Rule::Average,
+            Rule::Min,
+            Rule::Multiply,
+            Rule::Max,
+            Rule::ClampedSum,
+            Rule::GeometricMean,
+        ] {
+            let raw: rapier::dynamics::CoefficientCombineRule = rule.into();
+            assert_eq!(raw as u32, rule as u32);
+            assert_eq!(Rule::from(raw), rule);
+        }
+    }
+}
diff --git a/bindings/bevy_rapier/src/dynamics/multibody.rs b/bindings/bevy_rapier/src/dynamics/multibody.rs
new file mode 100644
index 000000000..dbc5c7fed
--- /dev/null
+++ b/bindings/bevy_rapier/src/dynamics/multibody.rs
@@ -0,0 +1,256 @@
+use crate::math::{Real, Rot};
+use crate::reflect::JointAxisWrapper;
+use bevy::prelude::*;
+use rapier::dynamics::{JointAxesMask, JointAxis, MultibodyJoint as RapierMultibodyJoint};
+use rapier::math::SPATIAL_DIM;
+
+pub use rapier::dynamics::InverseKinematicsOption;
+
+use super::JOINT_DOFS;
+
+#[cfg(doc)]
+use super::MultibodyJoint;
+#[cfg(doc)]
+use crate::plugin::context::RapierContextJoints;
+
+/// Iterates through the free degrees of freedom of a joint with the given locked axes, as
+/// `(dof, axis)` pairs, where `dof` is the index of the DoF in the joint’s slice of the
+/// multibody’s generalized coordinates, and `axis` its [`JointAxis`] index.
+pub(crate) fn free_joint_dofs(locked_axes: JointAxesMask) -> impl Iterator<Item = (usize, usize)> {
+    let locked = locked_axes.bits();
+    (0..SPATIAL_DIM)
+        .filter(move |axis| locked & (1 << axis) == 0)
+        .enumerate()
+}
+
+/// Marker component making the [`MultibodyJoint`] of its entity kinematic.
+///
+/// The velocities of a kinematic multibody joint are never modified by the physics engine: its
+/// degrees of freedom only move according to the generalized velocities set by the user (see
+/// [`RapierContextJoints::multibody_joint_velocity_mut`]), ignoring gravity, contacts and the
+/// other joints of the multibody. This can be added or removed at any time.
+#[derive(Copy, Clone, Default, Debug, PartialEq, Eq, Component, Reflect)]
+#[reflect(Component, Default, PartialEq)]
+pub struct KinematicMultibodyJoint;
+
+/// The per-DoF viscous damping of a [`MultibodyJoint`], indexed by [`JointAxis`].
+///
+/// The damping applies a generalized force opposed to the joint velocity along each free
+/// degree of freedom. Values along locked axes are ignored. Removing this component restores the
+/// default damping (see [`MultibodyJointDamping::default`]).
+#[derive(Copy, Clone, Debug, PartialEq, Component, Reflect)]
+#[reflect(Component, Default, PartialEq)]
+pub struct MultibodyJointDamping(pub [Real; JOINT_DOFS]);
+
+impl Default for MultibodyJointDamping {
+    /// The damping Rapier assigns to new multibody joints: `0.1` on angular axes, zero on
+    /// linear axes.
+    fn default() -> Self {
+        let lin_dofs = JOINT_DOFS - rapier::math::ANG_DIM;
+        Self(std::array::from_fn(
+            |i| if i < lin_dofs { 0.0 } else { 0.1 },
+        ))
+    }
+}
+
+impl MultibodyJointDamping {
+    /// The same damping along every axis.
+    pub fn splat(damping: Real) -> Self {
+        Self([damping; JOINT_DOFS])
+    }
+
+    /// Sets the damping along the given axis.
+    pub fn with(mut self, axis: JointAxis, damping: Real) -> Self {
+        self.0[axis as usize] = damping;
+        self
+    }
+}
+
+/// The per-DoF dry friction of a [`MultibodyJoint`], indexed by [`JointAxis`].
+///
+/// Each value is the largest generalized force (a force for linear axes, a torque for angular
+/// axes) friction may apply to stop the motion of the corresponding degree of freedom. Values
+/// along locked axes are ignored. Removing this component removes the friction.
+#[derive(Copy, Clone, Default, Debug, PartialEq, Component, Reflect)]
+#[reflect(Component, Default, PartialEq)]
+pub struct MultibodyJointFriction(pub [Real; JOINT_DOFS]);
+
+impl MultibodyJointFriction {
+    /// The same friction along every axis.
+    pub fn splat(friction: Real) -> Self {
+        Self([friction; JOINT_DOFS])
+    }
+
+    /// Sets the friction along the given axis.
+    pub fn with(mut self, axis: JointAxis, friction: Real) -> Self {
+        self.0[axis as usize] = friction;
+        self
+    }
+}
+
+/// The per-DoF armature (reflected rotor inertia) of a [`MultibodyJoint`], indexed by
+/// [`JointAxis`].
+///
+/// This inertia is added to the multibody’s mass matrix along each free degree of freedom, which
+/// typically models the inertia of an actuator and improves stability. Values along locked axes
+/// are ignored. Removing this component removes the armature.
+#[derive(Copy, Clone, Default, Debug, PartialEq, Component, Reflect)]
+#[reflect(Component, Default, PartialEq)]
+pub struct MultibodyJointArmature(pub [Real; JOINT_DOFS]);
+
+impl MultibodyJointArmature {
+    /// The same armature along every axis.
+    pub fn splat(armature: Real) -> Self {
+        Self([armature; JOINT_DOFS])
+    }
+
+    /// Sets the armature along the given axis.
+    pub fn with(mut self, axis: JointAxis, armature: Real) -> Self {
+        self.0[axis as usize] = armature;
+        self
+    }
+}
+
+/// Passive springs acting on the degrees of freedom of a [`MultibodyJoint`], indexed by
+/// [`JointAxis`].
+///
+/// Along each free axis, the spring applies the generalized force
+/// `-stiffness * (coord - rest)`, integrated implicitly (so stiff springs remain stable), where
+/// `coord` is the joint coordinate reported by [`MultibodyJointState::coords`]. Axes with a zero
+/// stiffness have no spring. Removing this component removes all the springs.
+#[derive(Copy, Clone, Default, Debug, PartialEq, Component, Reflect)]
+#[reflect(Component, Default, PartialEq)]
+pub struct MultibodyJointSprings {
+    /// The spring stiffness along each axis.
+    pub stiffness: [Real; JOINT_DOFS],
+    /// The rest coordinate of the spring along each axis.
+    pub rest: [Real; JOINT_DOFS],
+}
+
+impl MultibodyJointSprings {
+    /// Sets the spring along the given axis.
+    pub fn with(mut self, axis: JointAxis, stiffness: Real, rest: Real) -> Self {
+        self.stiffness[axis as usize] = stiffness;
+        self.rest[axis as usize] = rest;
+        self
+    }
+}
+
+/// A linear coupling between a degree of freedom of this [`MultibodyJoint`] and a degree of
+/// freedom of another joint of the same multibody.
+///
+/// The coupling enforces `coord(axis) = coeff * source_coord(source_axis) + offset`, similar to
+/// a "mimic" joint. See [`MultibodyJointCouplings`].
+#[derive(Copy, Clone, Debug, PartialEq, Reflect)]
+#[reflect(PartialEq)]
+pub struct MultibodyJointCoupling {
+    /// The coupled axis of the joint containing this coupling.
+    #[reflect(remote = JointAxisWrapper)]
+    pub axis: JointAxis,
+    /// The entity with the [`MultibodyJoint`] (or the root rigid-body) driving this coupling.
+    pub source: Entity,
+    /// The axis of `source` driving this coupling.
+    #[reflect(remote = JointAxisWrapper)]
+    pub source_axis: JointAxis,
+    /// The linear coupling coefficient.
+    pub coeff: Real,
+    /// The constant offset of the coupling.
+    pub offset: Real,
+}
+
+impl MultibodyJointCoupling {
+    /// Couples `axis` of this joint to `source_axis` of `source` with
+    /// `coord(axis) = coeff * source_coord(source_axis) + offset`.
+    pub fn new(
+        axis: JointAxis,
+        source: Entity,
+        source_axis: JointAxis,
+        coeff: Real,
+        offset: Real,
+    ) -> Self {
+        Self {
+            axis,
+            source,
+            source_axis,
+            coeff,
+            offset,
+        }
+    }
+}
+
+/// The couplings between the degrees of freedom of this [`MultibodyJoint`] and other joints of
+/// the same multibody.
+///
+/// A coupling is only active while both joints belong to the same multibody and both coupled
+/// axes are free; it is ignored otherwise. Removing a coupling (or this component) removes it
+/// from the multibody without affecting the joint state.
+#[derive(Clone, Default, Debug, PartialEq, Component, Reflect)]
+#[reflect(Component, Default, PartialEq)]
+pub struct MultibodyJointCouplings(pub Vec<MultibodyJointCoupling>);
+
+/// Marker component disabling the contacts between the links of the multibody containing the
+/// rigid-body of its entity.
+///
+/// This can be added to any rigid-body of the multibody (typically its root), and overrides the
+/// per-joint [`GenericJoint::contacts_enabled`](crate::dynamics::GenericJoint::contacts_enabled)
+/// flags. Removing it enables self-contacts again (unless another link of the multibody still has
+/// this component).
+#[derive(Copy, Clone, Default, Debug, PartialEq, Eq, Component, Reflect)]
+#[reflect(Component, Default, PartialEq)]
+pub struct MultibodySelfContactsDisabled;
+
+/// The state of a [`MultibodyJoint`], written back after each simulation step.
+///
+/// This component is automatically added alongside [`MultibodyJoint`]. Modifying it has no
+/// effect: use the helpers of [`RapierContextJoints`] to control the joint coordinates and
+/// velocities.
+#[derive(Copy, Clone, Debug, PartialEq, Component, Reflect)]
+#[reflect(Component, Default, PartialEq)]
+pub struct MultibodyJointState {
+    /// The generalized coordinates of the joint, indexed by [`JointAxis`], zero along locked
+    /// axes.
+    ///
+    /// These are translations along linear axes and angles along angular axes. With more than
+    /// one free angular axis (3D only), the angular coordinates are integrated angular
+    /// velocities: use [`Self::rotation`] instead.
+    pub coords: [Real; JOINT_DOFS],
+    /// The generalized velocities of the joint, indexed by [`JointAxis`], zero along locked axes.
+    pub velocities: [Real; JOINT_DOFS],
+    /// The rotation of the joint’s second frame relative to its first frame.
+    pub rotation: Rot,
+}
+
+impl Default for MultibodyJointState {
+    fn default() -> Self {
+        Self {
+            coords: [0.0; JOINT_DOFS],
+            velocities: [0.0; JOINT_DOFS],
+            #[cfg(feature = "dim2")]
+            rotation: 0.0,
+            #[cfg(feature = "dim3")]
+            rotation: Rot::IDENTITY,
+        }
+    }
+}
+
+impl MultibodyJointState {
+    /// Reads the state of a Rapier multibody joint, given its generalized velocities (the
+    /// joint’s slice of the multibody’s generalized velocities).
+    pub fn from_rapier(joint: &RapierMultibodyJoint, velocities: &[Real]) -> Self {
+        let coords = joint.coords();
+        let mut result = Self {
+            coords: std::array::from_fn(|i| coords[i]),
+            #[cfg(feature = "dim2")]
+            rotation: joint.joint_rot().angle(),
+            #[cfg(feature = "dim3")]
+            rotation: joint.joint_rot(),
+            ..Default::default()
+        };
+        for (dof, axis) in free_joint_dofs(joint.data.locked_axes) {
+            if let Some(vel) = velocities.get(dof) {
+                result.velocities[axis] = *vel;
+            }
+        }
+        result
+    }
+}
diff --git a/bindings/bevy_rapier/src/dynamics/pin_slot_joint.rs b/bindings/bevy_rapier/src/dynamics/pin_slot_joint.rs
new file mode 100644
index 000000000..e42ec875e
--- /dev/null
+++ b/bindings/bevy_rapier/src/dynamics/pin_slot_joint.rs
@@ -0,0 +1,294 @@
+use crate::dynamics::{GenericJoint, GenericJointBuilder};
+use crate::math::{Real, Vect};
+use rapier::dynamics::{JointAxesMask, JointAxis, JointLimits, JointMotor, MotorModel};
+
+use super::{SpringCoefficients, TypedJoint};
+
+#[cfg_attr(feature = "serde-serialize", derive(Serialize, Deserialize))]
+#[derive(Copy, Clone, Debug, PartialEq)]
+#[repr(transparent)]
+/// A pin-slot joint, locks all relative motion between two bodies except for translations along the joint’s
+/// principal axis and relative rotations.
+///
+/// This joint is also known as a groove joint. It is only available in 2D.
+pub struct PinSlotJoint {
+    /// The underlying joint data.
+    pub data: GenericJoint,
+}
+
+impl PinSlotJoint {
+    /// Creates a new pin-slot joint allowing only relative rotations and relative translations along the specified axis.
+    ///
+    /// This axis is expressed in the local-space of both rigid-bodies.
+    pub fn new(axis: Vect) -> Self {
+        let data = GenericJointBuilder::new(JointAxesMask::LOCKED_PIN_SLOT_AXES)
+            .local_axis1(axis)
+            .local_axis2(axis)
+            .build();
+        Self { data }
+    }
+
+    /// Are contacts between the attached rigid-bodies enabled?
+    pub fn contacts_enabled(&self) -> bool {
+        self.data.contacts_enabled()
+    }
+
+    /// Sets whether contacts between the attached rigid-bodies are enabled.
+    pub fn set_contacts_enabled(&mut self, enabled: bool) -> &mut Self {
+        self.data.set_contacts_enabled(enabled);
+        self
+    }
+
+    /// The spring coefficients controlling the softness of this joint’s locked degrees of freedom.
+    #[must_use]
+    pub fn softness(&self) -> SpringCoefficients<Real> {
+        self.data.softness()
+    }
+
+    /// Sets the spring coefficients controlling the softness of this joint’s locked degrees of freedom.
+    pub fn set_softness(&mut self, softness: SpringCoefficients<Real>) -> &mut Self {
+        self.data.set_softness(softness);
+        self
+    }
+
+    /// The joint’s anchor, expressed in the local-space of the first rigid-body.
+    #[must_use]
+    pub fn local_anchor1(&self) -> Vect {
+        self.data.local_anchor1()
+    }
+
+    /// Sets the joint’s anchor, expressed in the local-space of the first rigid-body.
+    pub fn set_local_anchor1(&mut self, anchor1: Vect) -> &mut Self {
+        self.data.set_local_anchor1(anchor1);
+        self
+    }
+
+    /// The joint’s anchor, expressed in the local-space of the second rigid-body.
+    #[must_use]
+    pub fn local_anchor2(&self) -> Vect {
+        self.data.local_anchor2()
+    }
+
+    /// Sets the joint’s anchor, expressed in the local-space of the second rigid-body.
+    pub fn set_local_anchor2(&mut self, anchor2: Vect) -> &mut Self {
+        self.data.set_local_anchor2(anchor2);
+        self
+    }
+
+    /// The principal axis of the joint, expressed in the local-space of the first rigid-body.
+    #[must_use]
+    pub fn local_axis1(&self) -> Vect {
+        self.data.local_axis1()
+    }
+
+    /// Sets the principal axis of the joint, expressed in the local-space of the first rigid-body.
+    pub fn set_local_axis1(&mut self, axis1: Vect) -> &mut Self {
+        self.data.set_local_axis1(axis1);
+        self
+    }
+
+    /// The principal axis of the joint, expressed in the local-space of the second rigid-body.
+    #[must_use]
+    pub fn local_axis2(&self) -> Vect {
+        self.data.local_axis2()
+    }
+
+    /// Sets the principal axis of the joint, expressed in the local-space of the second rigid-body.
+    pub fn set_local_axis2(&mut self, axis2: Vect) -> &mut Self {
+        self.data.set_local_axis2(axis2);
+        self
+    }
+
+    /// The motor affecting the joint’s translational degree of freedom.
+    #[must_use]
+    pub fn motor(&self) -> Option<&JointMotor> {
+        self.data.motor(JointAxis::LinX)
+    }
+
+    /// Set the spring-like model used by the motor to reach the desired target velocity and position.
+    pub fn set_motor_model(&mut self, model: MotorModel) -> &mut Self {
+        self.data.set_motor_model(JointAxis::LinX, model);
+        self
+    }
+
+    /// Sets the target velocity this motor needs to reach.
+    pub fn set_motor_velocity(&mut self, target_vel: Real, factor: Real) -> &mut Self {
+        self.data
+            .set_motor_velocity(JointAxis::LinX, target_vel, factor);
+        self
+    }
+
+    /// Sets the target angle this motor needs to reach.
+    pub fn set_motor_position(
+        &mut self,
+        target_pos: Real,
+        stiffness: Real,
+        damping: Real,
+    ) -> &mut Self {
+        self.data
+            .set_motor_position(JointAxis::LinX, target_pos, stiffness, damping);
+        self
+    }
+
+    /// Configure both the target angle and target velocity of the motor.
+    pub fn set_motor(
+        &mut self,
+        target_pos: Real,
+        target_vel: Real,
+        stiffness: Real,
+        damping: Real,
+    ) -> &mut Self {
+        self.data
+            .set_motor(JointAxis::LinX, target_pos, target_vel, stiffness, damping);
+        self
+    }
+
+    /// Sets the maximum force the motor can deliver.
+    pub fn set_motor_max_force(&mut self, max_force: Real) -> &mut Self {
+        self.data.set_motor_max_force(JointAxis::LinX, max_force);
+        self
+    }
+
+    /// The limit distance attached bodies can translate along the joint’s principal axis.
+    #[must_use]
+    pub fn limits(&self) -> Option<&JointLimits<Real>> {
+        self.data.limits(JointAxis::LinX)
+    }
+
+    /// Sets the `[min,max]` limit distances attached bodies can translate along the joint’s principal axis.
+    pub fn set_limits(&mut self, limits: [Real; 2]) -> &mut Self {
+        self.data.set_limits(JointAxis::LinX, limits);
+        self
+    }
+}
+
+impl From<PinSlotJoint> for GenericJoint {
+    fn from(joint: PinSlotJoint) -> GenericJoint {
+        joint.data
+    }
+}
+
+/// Create pin-slot joints using the builder pattern.
+///
+/// A pin-slot joint locks all relative motion except for translations along the joint’s principal axis
+/// and relative rotations.
+#[cfg_attr(feature = "serde-serialize", derive(Serialize, Deserialize))]
+#[derive(Copy, Clone, Debug, PartialEq)]
+pub struct PinSlotJointBuilder(PinSlotJoint);
+
+impl PinSlotJointBuilder {
+    /// Creates a new builder for pin-slot joints.
+    ///
+    /// This axis is expressed in the local-space of both rigid-bodies.
+    pub fn new(axis: Vect) -> Self {
+        Self(PinSlotJoint::new(axis))
+    }
+
+    /// Sets the joint’s anchor, expressed in the local-space of the first rigid-body.
+    #[must_use]
+    pub fn local_anchor1(mut self, anchor1: Vect) -> Self {
+        self.0.set_local_anchor1(anchor1);
+        self
+    }
+
+    /// Sets the joint’s anchor, expressed in the local-space of the second rigid-body.
+    #[must_use]
+    pub fn local_anchor2(mut self, anchor2: Vect) -> Self {
+        self.0.set_local_anchor2(anchor2);
+        self
+    }
+
+    /// Sets the principal axis of the joint, expressed in the local-space of the first rigid-body.
+    #[must_use]
+    pub fn local_axis1(mut self, axis1: Vect) -> Self {
+        self.0.set_local_axis1(axis1);
+        self
+    }
+
+    /// Sets the principal axis of the joint, expressed in the local-space of the second rigid-body.
+    #[must_use]
+    pub fn local_axis2(mut self, axis2: Vect) -> Self {
+        self.0.set_local_axis2(axis2);
+        self
+    }
+
+    /// Set the spring-like model used by the motor to reach the desired target velocity and position.
+    #[must_use]
+    pub fn motor_model(mut self, model: MotorModel) -> Self {
+        self.0.set_motor_model(model);
+        self
+    }
+
+    /// Sets the target velocity this motor needs to reach.
+    #[must_use]
+    pub fn motor_velocity(mut self, target_vel: Real, factor: Real) -> Self {
+        self.0.set_motor_velocity(target_vel, factor);
+        self
+    }
+
+    /// Sets the target angle this motor needs to reach.
+    #[must_use]
+    pub fn motor_position(mut self, target_pos: Real, stiffness: Real, damping: Real) -> Self {
+        self.0.set_motor_position(target_pos, stiffness, damping);
+        self
+    }
+
+    /// Configure both the target angle and target velocity of the motor.
+    #[must_use]
+    pub fn set_motor(
+        mut self,
+        target_pos: Real,
+        target_vel: Real,
+        stiffness: Real,
+        damping: Real,
+    ) -> Self {
+        self.0.set_motor(target_pos, target_vel, stiffness, damping);
+        self
+    }
+
+    /// Sets the maximum force the motor can deliver.
+    #[must_use]
+    pub fn motor_max_force(mut self, max_force: Real) -> Self {
+        self.0.set_motor_max_force(max_force);
+        self
+    }
+
+    /// Sets the `[min,max]` limit distances attached bodies can translate along the joint’s principal axis.
+    #[must_use]
+    pub fn limits(mut self, limits: [Real; 2]) -> Self {
+        self.0.set_limits(limits);
+        self
+    }
+
+    /// Sets whether contacts between the attached rigid-bodies are enabled.
+    #[must_use]
+    pub fn contacts_enabled(mut self, enabled: bool) -> Self {
+        self.0.set_contacts_enabled(enabled);
+        self
+    }
+
+    /// Sets the spring coefficients controlling the softness of this joint’s locked degrees of freedom.
+    #[must_use]
+    pub fn softness(mut self, softness: SpringCoefficients<Real>) -> Self {
+        self.0.set_softness(softness);
+        self
+    }
+
+    /// Builds the pin-slot joint.
+    #[must_use]
+    pub fn build(self) -> PinSlotJoint {
+        self.0
+    }
+}
+
+impl From<PinSlotJointBuilder> for TypedJoint {
+    fn from(joint: PinSlotJointBuilder) -> TypedJoint {
+        joint.0.into()
+    }
+}
+
+impl From<PinSlotJoint> for TypedJoint {
+    fn from(joint: PinSlotJoint) -> TypedJoint {
+        TypedJoint::PinSlotJoint(joint)
+    }
+}
diff --git a/bindings/bevy_rapier/src/dynamics/prismatic_joint.rs b/bindings/bevy_rapier/src/dynamics/prismatic_joint.rs
new file mode 100644
index 000000000..efb30c6fd
--- /dev/null
+++ b/bindings/bevy_rapier/src/dynamics/prismatic_joint.rs
@@ -0,0 +1,290 @@
+use crate::dynamics::{GenericJoint, GenericJointBuilder};
+use crate::math::{Real, Vect};
+use rapier::dynamics::{JointAxesMask, JointAxis, JointLimits, JointMotor, MotorModel};
+
+use super::{SpringCoefficients, TypedJoint};
+
+#[cfg_attr(feature = "serde-serialize", derive(Serialize, Deserialize))]
+#[derive(Copy, Clone, Debug, PartialEq)]
+#[repr(transparent)]
+/// A prismatic joint, locks all relative motion between two bodies except for translation along the joint’s principal axis.
+pub struct PrismaticJoint {
+    /// The underlying joint data.
+    pub data: GenericJoint,
+}
+
+impl PrismaticJoint {
+    /// Creates a new prismatic joint allowing only relative translations along the specified axis.
+    ///
+    /// This axis is expressed in the local-space of both rigid-bodies.
+    pub fn new(axis: Vect) -> Self {
+        let data = GenericJointBuilder::new(JointAxesMask::LOCKED_PRISMATIC_AXES)
+            .local_axis1(axis)
+            .local_axis2(axis)
+            .build();
+        Self { data }
+    }
+
+    /// Are contacts between the attached rigid-bodies enabled?
+    pub fn contacts_enabled(&self) -> bool {
+        self.data.contacts_enabled()
+    }
+
+    /// Sets whether contacts between the attached rigid-bodies are enabled.
+    pub fn set_contacts_enabled(&mut self, enabled: bool) -> &mut Self {
+        self.data.set_contacts_enabled(enabled);
+        self
+    }
+
+    /// The spring coefficients controlling the softness of this joint’s locked degrees of freedom.
+    #[must_use]
+    pub fn softness(&self) -> SpringCoefficients<Real> {
+        self.data.softness()
+    }
+
+    /// Sets the spring coefficients controlling the softness of this joint’s locked degrees of freedom.
+    pub fn set_softness(&mut self, softness: SpringCoefficients<Real>) -> &mut Self {
+        self.data.set_softness(softness);
+        self
+    }
+
+    /// The joint’s anchor, expressed in the local-space of the first rigid-body.
+    #[must_use]
+    pub fn local_anchor1(&self) -> Vect {
+        self.data.local_anchor1()
+    }
+
+    /// Sets the joint’s anchor, expressed in the local-space of the first rigid-body.
+    pub fn set_local_anchor1(&mut self, anchor1: Vect) -> &mut Self {
+        self.data.set_local_anchor1(anchor1);
+        self
+    }
+
+    /// The joint’s anchor, expressed in the local-space of the second rigid-body.
+    #[must_use]
+    pub fn local_anchor2(&self) -> Vect {
+        self.data.local_anchor2()
+    }
+
+    /// Sets the joint’s anchor, expressed in the local-space of the second rigid-body.
+    pub fn set_local_anchor2(&mut self, anchor2: Vect) -> &mut Self {
+        self.data.set_local_anchor2(anchor2);
+        self
+    }
+
+    /// The principal axis of the joint, expressed in the local-space of the first rigid-body.
+    #[must_use]
+    pub fn local_axis1(&self) -> Vect {
+        self.data.local_axis1()
+    }
+
+    /// Sets the principal axis of the joint, expressed in the local-space of the first rigid-body.
+    pub fn set_local_axis1(&mut self, axis1: Vect) -> &mut Self {
+        self.data.set_local_axis1(axis1);
+        self
+    }
+
+    /// The principal axis of the joint, expressed in the local-space of the second rigid-body.
+    #[must_use]
+    pub fn local_axis2(&self) -> Vect {
+        self.data.local_axis2()
+    }
+
+    /// Sets the principal axis of the joint, expressed in the local-space of the second rigid-body.
+    pub fn set_local_axis2(&mut self, axis2: Vect) -> &mut Self {
+        self.data.set_local_axis2(axis2);
+        self
+    }
+
+    /// The motor affecting the joint’s translational degree of freedom.
+    #[must_use]
+    pub fn motor(&self) -> Option<&JointMotor> {
+        self.data.motor(JointAxis::LinX)
+    }
+
+    /// Set the spring-like model used by the motor to reach the desired target velocity and position.
+    pub fn set_motor_model(&mut self, model: MotorModel) -> &mut Self {
+        self.data.set_motor_model(JointAxis::LinX, model);
+        self
+    }
+
+    /// Sets the target velocity this motor needs to reach.
+    pub fn set_motor_velocity(&mut self, target_vel: Real, factor: Real) -> &mut Self {
+        self.data
+            .set_motor_velocity(JointAxis::LinX, target_vel, factor);
+        self
+    }
+
+    /// Sets the target angle this motor needs to reach.
+    pub fn set_motor_position(
+        &mut self,
+        target_pos: Real,
+        stiffness: Real,
+        damping: Real,
+    ) -> &mut Self {
+        self.data
+            .set_motor_position(JointAxis::LinX, target_pos, stiffness, damping);
+        self
+    }
+
+    /// Configure both the target angle and target velocity of the motor.
+    pub fn set_motor(
+        &mut self,
+        target_pos: Real,
+        target_vel: Real,
+        stiffness: Real,
+        damping: Real,
+    ) -> &mut Self {
+        self.data
+            .set_motor(JointAxis::LinX, target_pos, target_vel, stiffness, damping);
+        self
+    }
+
+    /// Sets the maximum force the motor can deliver.
+    pub fn set_motor_max_force(&mut self, max_force: Real) -> &mut Self {
+        self.data.set_motor_max_force(JointAxis::LinX, max_force);
+        self
+    }
+
+    /// The limit distance attached bodies can translate along the joint’s principal axis.
+    #[must_use]
+    pub fn limits(&self) -> Option<&JointLimits<Real>> {
+        self.data.limits(JointAxis::LinX)
+    }
+
+    /// Sets the `[min,max]` limit distances attached bodies can translate along the joint’s principal axis.
+    pub fn set_limits(&mut self, limits: [Real; 2]) -> &mut Self {
+        self.data.set_limits(JointAxis::LinX, limits);
+        self
+    }
+}
+
+impl From<PrismaticJoint> for GenericJoint {
+    fn from(joint: PrismaticJoint) -> GenericJoint {
+        joint.data
+    }
+}
+
+/// Create prismatic joints using the builder pattern.
+///
+/// A prismatic joint locks all relative motion except for translations along the joint’s principal axis.
+#[cfg_attr(feature = "serde-serialize", derive(Serialize, Deserialize))]
+#[derive(Copy, Clone, Debug, PartialEq)]
+pub struct PrismaticJointBuilder(PrismaticJoint);
+
+impl PrismaticJointBuilder {
+    /// Creates a new builder for prismatic joints.
+    ///
+    /// This axis is expressed in the local-space of both rigid-bodies.
+    pub fn new(axis: Vect) -> Self {
+        Self(PrismaticJoint::new(axis))
+    }
+
+    /// Sets the joint’s anchor, expressed in the local-space of the first rigid-body.
+    #[must_use]
+    pub fn local_anchor1(mut self, anchor1: Vect) -> Self {
+        self.0.set_local_anchor1(anchor1);
+        self
+    }
+
+    /// Sets the joint’s anchor, expressed in the local-space of the second rigid-body.
+    #[must_use]
+    pub fn local_anchor2(mut self, anchor2: Vect) -> Self {
+        self.0.set_local_anchor2(anchor2);
+        self
+    }
+
+    /// Sets the principal axis of the joint, expressed in the local-space of the first rigid-body.
+    #[must_use]
+    pub fn local_axis1(mut self, axis1: Vect) -> Self {
+        self.0.set_local_axis1(axis1);
+        self
+    }
+
+    /// Sets the principal axis of the joint, expressed in the local-space of the second rigid-body.
+    #[must_use]
+    pub fn local_axis2(mut self, axis2: Vect) -> Self {
+        self.0.set_local_axis2(axis2);
+        self
+    }
+
+    /// Set the spring-like model used by the motor to reach the desired target velocity and position.
+    #[must_use]
+    pub fn motor_model(mut self, model: MotorModel) -> Self {
+        self.0.set_motor_model(model);
+        self
+    }
+
+    /// Sets the target velocity this motor needs to reach.
+    #[must_use]
+    pub fn motor_velocity(mut self, target_vel: Real, factor: Real) -> Self {
+        self.0.set_motor_velocity(target_vel, factor);
+        self
+    }
+
+    /// Sets the target angle this motor needs to reach.
+    #[must_use]
+    pub fn motor_position(mut self, target_pos: Real, stiffness: Real, damping: Real) -> Self {
+        self.0.set_motor_position(target_pos, stiffness, damping);
+        self
+    }
+
+    /// Configure both the target angle and target velocity of the motor.
+    #[must_use]
+    pub fn set_motor(
+        mut self,
+        target_pos: Real,
+        target_vel: Real,
+        stiffness: Real,
+        damping: Real,
+    ) -> Self {
+        self.0.set_motor(target_pos, target_vel, stiffness, damping);
+        self
+    }
+
+    /// Sets the maximum force the motor can deliver.
+    #[must_use]
+    pub fn motor_max_force(mut self, max_force: Real) -> Self {
+        self.0.set_motor_max_force(max_force);
+        self
+    }
+
+    /// Sets the `[min,max]` limit distances attached bodies can translate along the joint’s principal axis.
+    #[must_use]
+    pub fn limits(mut self, limits: [Real; 2]) -> Self {
+        self.0.set_limits(limits);
+        self
+    }
+
+    /// Sets whether contacts between the attached rigid-bodies are enabled.
+    #[must_use]
+    pub fn contacts_enabled(mut self, enabled: bool) -> Self {
+        self.0.set_contacts_enabled(enabled);
+        self
+    }
+
+    /// Sets the spring coefficients controlling the softness of this joint’s locked degrees of freedom.
+    #[must_use]
+    pub fn softness(mut self, softness: SpringCoefficients<Real>) -> Self {
+        self.0.set_softness(softness);
+        self
+    }
+
+    /// Builds the prismatic joint.
+    #[must_use]
+    pub fn build(self) -> PrismaticJoint {
+        self.0
+    }
+}
+
+impl From<PrismaticJointBuilder> for TypedJoint {
+    fn from(joint: PrismaticJointBuilder) -> TypedJoint {
+        joint.0.into()
+    }
+}
+
+impl From<PrismaticJoint> for TypedJoint {
+    fn from(joint: PrismaticJoint) -> TypedJoint {
+        TypedJoint::PrismaticJoint(joint)
+    }
+}
diff --git a/bindings/bevy_rapier/src/dynamics/revolute_joint.rs b/bindings/bevy_rapier/src/dynamics/revolute_joint.rs
new file mode 100644
index 000000000..fbe15a76f
--- /dev/null
+++ b/bindings/bevy_rapier/src/dynamics/revolute_joint.rs
@@ -0,0 +1,347 @@
+use crate::dynamics::{GenericJoint, GenericJointBuilder};
+use crate::math::{Real, Vect};
+use crate::plugin::context::RapierRigidBodySet;
+use bevy::prelude::Entity;
+use rapier::dynamics::{
+    JointAxesMask, JointAxis, JointLimits, JointMotor, MotorModel, RigidBodyHandle, RigidBodySet,
+};
+
+#[cfg(doc)]
+use crate::prelude::RapierContext;
+
+use super::{SpringCoefficients, TypedJoint};
+
+#[cfg_attr(feature = "serde-serialize", derive(Serialize, Deserialize))]
+#[derive(Copy, Clone, Debug, PartialEq)]
+#[repr(transparent)]
+/// A revolute joint, locks all relative motion except for rotation along the joint’s principal axis.
+pub struct RevoluteJoint {
+    /// The underlying joint data.
+    pub data: GenericJoint,
+}
+
+#[cfg(feature = "dim2")]
+impl Default for RevoluteJoint {
+    fn default() -> Self {
+        Self::new()
+    }
+}
+
+impl RevoluteJoint {
+    /// Creates a new revolute joint allowing only relative rotations.
+    #[cfg(feature = "dim2")]
+    pub fn new() -> Self {
+        let data = GenericJointBuilder::new(JointAxesMask::LOCKED_REVOLUTE_AXES);
+        Self { data: data.build() }
+    }
+
+    /// Creates a new revolute joint allowing only relative rotations along the specified axis.
+    ///
+    /// This axis is expressed in the local-space of both rigid-bodies.
+    #[cfg(feature = "dim3")]
+    pub fn new(axis: Vect) -> Self {
+        let data = GenericJointBuilder::new(JointAxesMask::LOCKED_REVOLUTE_AXES)
+            .local_axis1(axis)
+            .local_axis2(axis)
+            .build();
+        Self { data }
+    }
+
+    /// Are contacts between the attached rigid-bodies enabled?
+    pub fn contacts_enabled(&self) -> bool {
+        self.data.contacts_enabled()
+    }
+
+    /// Sets whether contacts between the attached rigid-bodies are enabled.
+    pub fn set_contacts_enabled(&mut self, enabled: bool) -> &mut Self {
+        self.data.set_contacts_enabled(enabled);
+        self
+    }
+
+    /// The spring coefficients controlling the softness of this joint’s locked degrees of freedom.
+    #[must_use]
+    pub fn softness(&self) -> SpringCoefficients<Real> {
+        self.data.softness()
+    }
+
+    /// Sets the spring coefficients controlling the softness of this joint’s locked degrees of freedom.
+    pub fn set_softness(&mut self, softness: SpringCoefficients<Real>) -> &mut Self {
+        self.data.set_softness(softness);
+        self
+    }
+
+    /// The joint’s anchor, expressed in the local-space of the first rigid-body.
+    #[must_use]
+    pub fn local_anchor1(&self) -> Vect {
+        self.data.local_anchor1()
+    }
+
+    /// Sets the joint’s anchor, expressed in the local-space of the first rigid-body.
+    pub fn set_local_anchor1(&mut self, anchor1: Vect) -> &mut Self {
+        self.data.set_local_anchor1(anchor1);
+        self
+    }
+
+    /// The joint’s anchor, expressed in the local-space of the second rigid-body.
+    #[must_use]
+    pub fn local_anchor2(&self) -> Vect {
+        self.data.local_anchor2()
+    }
+
+    /// Sets the joint’s anchor, expressed in the local-space of the second rigid-body.
+    pub fn set_local_anchor2(&mut self, anchor2: Vect) -> &mut Self {
+        self.data.set_local_anchor2(anchor2);
+        self
+    }
+
+    /// Sets the joint's rotation axis in the local-space of the first rigid-body
+    pub fn set_local_axis1(&mut self, axis1: Vect) -> &mut Self {
+        self.data.set_local_axis1(axis1);
+        self
+    }
+
+    /// Sets the joint's rotation axis in the local-space of the second rigid-body
+    pub fn set_local_axis2(&mut self, axis2: Vect) -> &mut Self {
+        self.data.set_local_axis2(axis2);
+        self
+    }
+
+    /// The motor affecting the joint’s rotational degree of freedom.
+    #[must_use]
+    pub fn motor(&self) -> Option<&JointMotor> {
+        self.data.motor(JointAxis::AngX)
+    }
+
+    /// Set the spring-like model used by the motor to reach the desired target velocity and position.
+    pub fn set_motor_model(&mut self, model: MotorModel) -> &mut Self {
+        self.data.set_motor_model(JointAxis::AngX, model);
+        self
+    }
+
+    /// Sets the target velocity this motor needs to reach.
+    pub fn set_motor_velocity(&mut self, target_vel: Real, factor: Real) -> &mut Self {
+        self.data
+            .set_motor_velocity(JointAxis::AngX, target_vel, factor);
+        self
+    }
+
+    /// Sets the target angle this motor needs to reach.
+    pub fn set_motor_position(
+        &mut self,
+        target_pos: Real,
+        stiffness: Real,
+        damping: Real,
+    ) -> &mut Self {
+        self.data
+            .set_motor_position(JointAxis::AngX, target_pos, stiffness, damping);
+        self
+    }
+
+    /// Configure both the target angle and target velocity of the motor.
+    pub fn set_motor(
+        &mut self,
+        target_pos: Real,
+        target_vel: Real,
+        stiffness: Real,
+        damping: Real,
+    ) -> &mut Self {
+        self.data
+            .set_motor(JointAxis::AngX, target_pos, target_vel, stiffness, damping);
+        self
+    }
+
+    /// Sets the maximum force the motor can deliver.
+    pub fn set_motor_max_force(&mut self, max_force: Real) -> &mut Self {
+        self.data.set_motor_max_force(JointAxis::AngX, max_force);
+        self
+    }
+
+    /// The limit angle attached bodies can translate along the joint’s principal axis.
+    #[must_use]
+    pub fn limits(&self) -> Option<&JointLimits<Real>> {
+        self.data.limits(JointAxis::AngX)
+    }
+
+    /// Sets the `[min,max]` limit angle attached bodies can translate along the joint’s principal axis.
+    pub fn set_limits(&mut self, limits: [Real; 2]) -> &mut Self {
+        self.data.set_limits(JointAxis::AngX, limits);
+        self
+    }
+
+    /// The angle along the free degree of freedom of this revolute joint in `[-π, π]`.
+    ///
+    /// See also [`Self::angle`] for a version of this method taking entities instead of rigid-body handles.
+    /// Similarly [`RapierContext::impulse_revolute_joint_angle`] only takes a single entity as argument to compute that angle.
+    ///
+    /// # Parameters
+    /// - `bodies` : the rigid body set from [`RapierRigidBodySet`]
+    /// - `body1`: the first rigid-body attached to this revolute joint, obtained through [`rapier::dynamics::ImpulseJoint`] or [`rapier::dynamics::MultibodyJoint`].
+    /// - `body2`: the second rigid-body attached to this revolute joint, obtained through [`rapier::dynamics::ImpulseJoint`] or [`rapier::dynamics::MultibodyJoint`].
+    pub fn angle_from_handles(
+        &self,
+        bodies: &RigidBodySet,
+        body1: RigidBodyHandle,
+        body2: RigidBodyHandle,
+    ) -> f32 {
+        // NOTE: unwrap will always succeed since `Self` is known to be a revolute joint.
+        let joint = self.data.raw.as_revolute().unwrap();
+
+        let rb1 = &bodies[body1];
+        let rb2 = &bodies[body2];
+        joint.angle(rb1.rotation(), rb2.rotation())
+    }
+
+    /// The angle along the free degree of freedom of this revolute joint in `[-π, π]`.
+    ///
+    /// # Parameters
+    /// - `bodies` : the rigid body set from [`RapierRigidBodySet`]
+    /// - `body1`: the first rigid-body attached to this revolute joint.
+    /// - `body2`: the second rigid-body attached to this revolute joint.
+    pub fn angle(&self, rigidbody_set: &RapierRigidBodySet, body1: Entity, body2: Entity) -> f32 {
+        let rb1 = rigidbody_set.entity2body().get(&body1).unwrap();
+        let rb2 = rigidbody_set.entity2body().get(&body2).unwrap();
+        self.angle_from_handles(&rigidbody_set.bodies, *rb1, *rb2)
+    }
+}
+
+impl From<RevoluteJoint> for GenericJoint {
+    fn from(joint: RevoluteJoint) -> GenericJoint {
+        joint.data
+    }
+}
+
+/// Create revolute joints using the builder pattern.
+///
+/// A revolute joint locks all relative motion except for rotations along the joint’s principal axis.
+#[cfg_attr(feature = "serde-serialize", derive(Serialize, Deserialize))]
+#[derive(Copy, Clone, Debug, PartialEq)]
+pub struct RevoluteJointBuilder(RevoluteJoint);
+
+#[cfg(feature = "dim2")]
+impl Default for RevoluteJointBuilder {
+    fn default() -> Self {
+        Self::new()
+    }
+}
+
+impl RevoluteJointBuilder {
+    /// Creates a new revolute joint builder.
+    #[cfg(feature = "dim2")]
+    pub fn new() -> Self {
+        Self(RevoluteJoint::new())
+    }
+
+    /// Creates a new revolute joint builder, allowing only relative rotations along the specified axis.
+    ///
+    /// This axis is expressed in the local-space of both rigid-bodies.
+    #[cfg(feature = "dim3")]
+    pub fn new(axis: Vect) -> Self {
+        Self(RevoluteJoint::new(axis))
+    }
+
+    /// Sets the joint’s anchor, expressed in the local-space of the first rigid-body.
+    #[must_use]
+    pub fn local_anchor1(mut self, anchor1: Vect) -> Self {
+        self.0.set_local_anchor1(anchor1);
+        self
+    }
+
+    /// Sets the joint’s anchor, expressed in the local-space of the second rigid-body.
+    #[must_use]
+    pub fn local_anchor2(mut self, anchor2: Vect) -> Self {
+        self.0.set_local_anchor2(anchor2);
+        self
+    }
+
+    /// Sets the joint's axis, expressed in the local-space of the first rigid-body
+    pub fn local_axis1(mut self, axis1: Vect) -> Self {
+        self.0.set_local_axis1(axis1);
+        self
+    }
+
+    /// Sets the joint's axis, expressed in the local-space of the second rigid-body
+    pub fn local_axis2(mut self, axis2: Vect) -> Self {
+        self.0.set_local_axis2(axis2);
+        self
+    }
+
+    /// Set the spring-like model used by the motor to reach the desired target velocity and position.
+    #[must_use]
+    pub fn motor_model(mut self, model: MotorModel) -> Self {
+        self.0.set_motor_model(model);
+        self
+    }
+
+    /// Sets the target velocity this motor needs to reach.
+    #[must_use]
+    pub fn motor_velocity(mut self, target_vel: Real, factor: Real) -> Self {
+        self.0.set_motor_velocity(target_vel, factor);
+        self
+    }
+
+    /// Sets the target angle this motor needs to reach.
+    #[must_use]
+    pub fn motor_position(mut self, target_pos: Real, stiffness: Real, damping: Real) -> Self {
+        self.0.set_motor_position(target_pos, stiffness, damping);
+        self
+    }
+
+    /// Configure both the target angle and target velocity of the motor.
+    #[must_use]
+    pub fn motor(
+        mut self,
+        target_pos: Real,
+        target_vel: Real,
+        stiffness: Real,
+        damping: Real,
+    ) -> Self {
+        self.0.set_motor(target_pos, target_vel, stiffness, damping);
+        self
+    }
+
+    /// Sets the maximum force the motor can deliver.
+    #[must_use]
+    pub fn motor_max_force(mut self, max_force: Real) -> Self {
+        self.0.set_motor_max_force(max_force);
+        self
+    }
+
+    /// Sets the `[min,max]` limit angles attached bodies can rotate along the joint’s principal axis.
+    #[must_use]
+    pub fn limits(mut self, limits: [Real; 2]) -> Self {
+        self.0.set_limits(limits);
+        self
+    }
+
+    /// Sets whether contacts between the attached rigid-bodies are enabled.
+    #[must_use]
+    pub fn contacts_enabled(mut self, enabled: bool) -> Self {
+        self.0.set_contacts_enabled(enabled);
+        self
+    }
+
+    /// Sets the spring coefficients controlling the softness of this joint’s locked degrees of freedom.
+    #[must_use]
+    pub fn softness(mut self, softness: SpringCoefficients<Real>) -> Self {
+        self.0.set_softness(softness);
+        self
+    }
+
+    /// Builds the revolute joint.
+    #[must_use]
+    pub fn build(self) -> RevoluteJoint {
+        self.0
+    }
+}
+
+impl From<RevoluteJointBuilder> for TypedJoint {
+    fn from(joint: RevoluteJointBuilder) -> TypedJoint {
+        joint.0.into()
+    }
+}
+
+impl From<RevoluteJoint> for TypedJoint {
+    fn from(joint: RevoluteJoint) -> TypedJoint {
+        TypedJoint::RevoluteJoint(joint)
+    }
+}
diff --git a/bindings/bevy_rapier/src/dynamics/rigid_body.rs b/bindings/bevy_rapier/src/dynamics/rigid_body.rs
new file mode 100644
index 000000000..5f8bb58a5
--- /dev/null
+++ b/bindings/bevy_rapier/src/dynamics/rigid_body.rs
@@ -0,0 +1,755 @@
+use crate::math::Vect;
+use bevy::prelude::*;
+use rapier::prelude::{
+    LockedAxes as RapierLockedAxes, Pose, RigidBodyActivation, RigidBodyHandle, RigidBodyType,
+};
+use std::ops::{Add, AddAssign, Sub, SubAssign};
+
+#[cfg(doc)]
+use rapier::dynamics::IntegrationParameters;
+
+/// The Rapier handle of a [`RigidBody`] that was inserted to the physics scene.
+#[derive(Copy, Clone, Debug, Component)]
+pub struct RapierRigidBodyHandle(pub RigidBodyHandle);
+
+/// A [`RigidBody`].
+///
+/// Related components:
+/// - [`GlobalTransform`]: used as the ground truth for the bodies position.
+/// - [`Velocity`]
+/// - [`ExternalImpulse`]
+/// - [`ExternalForce`]
+/// - [`AdditionalMassProperties`]
+/// - [`ReadMassProperties`]
+/// - [`ReadWorldMassProperties`]
+/// - [`Damping`]
+/// - [`Dominance`]
+/// - [`Ccd`]: Helps prevent fast bodies from tunneling through other moving bodies.
+/// - [`SoftCcd`]
+/// - [`LockedAxes`]
+/// - [`RigidBodyDisabled`]
+/// - [`GravityScale`]
+/// - [`Sleeping`]
+/// - [`AdditionalSolverIterations`]
+/// - [`AdditionalPgsIterations`]
+/// - [`AllowFastRotation`]
+/// - `GyroscopicForces` (3D only)
+#[derive(Copy, Clone, Debug, PartialEq, Eq, Component, Reflect, Default)]
+#[cfg_attr(feature = "serde-serialize", derive(Serialize, Deserialize))]
+#[reflect(Component, Default, PartialEq)]
+#[require(ReadMassProperties)]
+pub enum RigidBody {
+    /// A `RigidBody::Dynamic` body can be affected by all external forces.
+    #[default]
+    Dynamic,
+    /// A `RigidBody::Fixed` body cannot be affected by external forces.
+    Fixed,
+    /// A `RigidBody::KinematicPositionBased` body cannot be affected by any external forces but can be controlled
+    /// by the user at the position level while keeping realistic one-way interaction with dynamic bodies.
+    ///
+    /// One-way interaction means that a kinematic body can push a dynamic body, but a kinematic body
+    /// cannot be pushed by anything. In other words, the trajectory of a kinematic body can only be
+    /// modified by the user and is independent from any contact or joint it is involved in.
+    KinematicPositionBased,
+    /// A `RigidBody::KinematicVelocityBased` body cannot be affected by any external forces but can be controlled
+    /// by the user at the velocity level while keeping realistic one-way interaction with dynamic bodies.
+    ///
+    /// One-way interaction means that a kinematic body can push a dynamic body, but a kinematic body
+    /// cannot be pushed by anything. In other words, the trajectory of a kinematic body can only be
+    /// modified by the user and is independent from any contact or joint it is involved in.
+    KinematicVelocityBased,
+}
+
+impl From<RigidBody> for RigidBodyType {
+    fn from(rigid_body: RigidBody) -> RigidBodyType {
+        match rigid_body {
+            RigidBody::Dynamic => RigidBodyType::Dynamic,
+            RigidBody::Fixed => RigidBodyType::Fixed,
+            RigidBody::KinematicPositionBased => RigidBodyType::KinematicPositionBased,
+            RigidBody::KinematicVelocityBased => RigidBodyType::KinematicVelocityBased,
+        }
+    }
+}
+
+impl From<RigidBodyType> for RigidBody {
+    fn from(rigid_body: RigidBodyType) -> RigidBody {
+        match rigid_body {
+            // Soft-body cluster proxies are simulated like dynamic bodies.
+            RigidBodyType::Dynamic | RigidBodyType::SoftFrame => RigidBody::Dynamic,
+            RigidBodyType::Fixed => RigidBody::Fixed,
+            RigidBodyType::KinematicPositionBased => RigidBody::KinematicPositionBased,
+            RigidBodyType::KinematicVelocityBased => RigidBody::KinematicVelocityBased,
+        }
+    }
+}
+
+/// The velocity of a [`RigidBody`].
+///
+/// Use this component to control and/or read the velocity of a dynamic or kinematic [`RigidBody`].
+/// If this component isn’t present, a dynamic [`RigidBody`] will still be able to move (you will just
+/// not be able to read/modify its velocity).
+///
+/// This only affects entities with a [`RigidBody`] component.
+#[derive(Copy, Clone, Debug, Default, PartialEq, Component, Reflect)]
+#[cfg_attr(feature = "serde-serialize", derive(Serialize, Deserialize))]
+#[reflect(Component, Default, PartialEq)]
+pub struct Velocity {
+    /// The linear velocity of the [`RigidBody`].
+    pub linear: Vect,
+    /// The angular velocity of the [`RigidBody`] in radian per second.
+    #[cfg(feature = "dim2")]
+    pub angular: f32,
+    /// The angular velocity of the [`RigidBody`].
+    #[cfg(feature = "dim3")]
+    pub angular: Vect,
+}
+
+impl Velocity {
+    /// Initialize a velocity set to zero.
+    pub const fn zero() -> Self {
+        Self {
+            linear: Vect::ZERO,
+            #[cfg(feature = "dim2")]
+            angular: 0.0,
+            #[cfg(feature = "dim3")]
+            angular: Vect::ZERO,
+        }
+    }
+
+    /// Initialize a velocity with the given linear velocity, and an angular velocity of zero.
+    pub const fn linear(linear: Vect) -> Self {
+        Self {
+            linear,
+            #[cfg(feature = "dim2")]
+            angular: 0.0,
+            #[cfg(feature = "dim3")]
+            angular: Vect::ZERO,
+        }
+    }
+
+    /// Initialize a velocity with the given angular velocity, and a linear velocity of zero.
+    #[cfg(feature = "dim2")]
+    pub const fn angular(angular: f32) -> Self {
+        Self {
+            linear: Vect::ZERO,
+            angular,
+        }
+    }
+
+    /// Initialize a velocity with the given angular velocity, and a linear velocity of zero.
+    #[cfg(feature = "dim3")]
+    pub const fn angular(angular: Vect) -> Self {
+        Self {
+            linear: Vect::ZERO,
+            angular,
+        }
+    }
+
+    /// Get linear velocity of specific world-space point of a [`RigidBody`].
+    ///
+    /// # Parameters
+    /// - `point`: the point (world-space) to compute the velocity for.
+    /// - `center_of_mass`: the center-of-mass (world-space) of the [`RigidBody`] the velocity belongs to.
+    pub fn linear_velocity_at_point(&self, point: Vect, center_of_mass: Vect) -> Vect {
+        #[cfg(feature = "dim2")]
+        return self.linear + self.angular * (point - center_of_mass).perp();
+
+        #[cfg(feature = "dim3")]
+        return self.linear + self.angular.cross(point - center_of_mass);
+    }
+}
+
+/// Mass-properties of a [`RigidBody`], added to the contributions of its attached colliders.
+///
+/// This only affects entities with a [`RigidBody`] component.
+#[derive(Copy, Clone, Debug, PartialEq, Component, Reflect)]
+#[reflect(Component, Default, PartialEq)]
+pub enum AdditionalMassProperties {
+    /// This mass will be added to the [`RigidBody`]. The rigid-body’s total
+    /// angular inertia tensor (obtained from its attached colliders) will
+    /// be scaled accordingly.
+    Mass(f32),
+    /// These mass properties will be added to the [`RigidBody`].
+    MassProperties(MassProperties),
+}
+
+impl Default for AdditionalMassProperties {
+    fn default() -> Self {
+        Self::MassProperties(MassProperties::default())
+    }
+}
+
+/// Center-of-mass, mass, and angular inertia.
+///
+/// When this is used as a component, this lets you read the total mass properties of
+/// a [`RigidBody`] (including the colliders contribution). Modifying this component won’t
+/// affect the mass-properties of the [`RigidBody`] (the attached colliders’ `ColliderMassProperties`
+/// and the `AdditionalMassProperties` should be modified instead).
+///
+/// This only reads the mass from entities with a [`RigidBody`] component. It is inserted
+/// automatically with [`RigidBody`] (like the joint read-backs), since it is only updated when
+/// the mass properties change.
+#[derive(Copy, Clone, Debug, Default, PartialEq, Component, Reflect)]
+#[reflect(Component, Default, PartialEq)]
+pub struct ReadMassProperties(MassProperties);
+
+impl ReadMassProperties {
+    /// Get the [`MassProperties`] of this [`RigidBody`].
+    pub fn get(&self) -> &MassProperties {
+        &self.0
+    }
+
+    pub(crate) fn set(&mut self, mass_props: MassProperties) {
+        self.0 = mass_props;
+    }
+}
+
+impl std::ops::Deref for ReadMassProperties {
+    type Target = MassProperties;
+    fn deref(&self) -> &Self::Target {
+        self.get()
+    }
+}
+
+/// World-space and locked-axes-aware mass properties of a [`RigidBody`].
+///
+/// When this is used as a component, it is updated after each physics step to reflect the
+/// current state of the [`RigidBody`]. Modifying this component has no effect on the simulation.
+///
+/// This only reads the mass properties from entities with a [`RigidBody`] component. Unlike
+/// [`ReadMassProperties`], it must be added manually: it changes at every step for every moving
+/// body (its center of mass moves), so, like [`Velocity`], it is only written back for the bodies
+/// that ask for it.
+#[derive(Copy, Clone, Debug, Default, PartialEq, Component, Reflect)]
+#[reflect(Component, Default, PartialEq)]
+pub struct ReadWorldMassProperties {
+    /// The world-space center of mass of the [`RigidBody`].
+    pub center_of_mass: Vect,
+    /// The inverse mass along each world axis, set to zero along locked translation axes.
+    ///
+    /// This is zero for non-dynamic rigid-bodies.
+    pub effective_inv_mass: Vect,
+    /// The world-space inverse angular inertia, set to zero if rotations are locked.
+    ///
+    /// This is zero for non-dynamic rigid-bodies.
+    #[cfg(feature = "dim2")]
+    pub effective_world_inv_inertia: f32,
+    /// The world-space inverse angular inertia tensor, with the rows and columns of locked
+    /// rotation axes set to zero.
+    ///
+    /// This is zero for non-dynamic rigid-bodies.
+    #[cfg(feature = "dim3")]
+    pub effective_world_inv_inertia: Mat3,
+}
+
+impl ReadWorldMassProperties {
+    /// Extracts the world-space mass properties from Rapier’s `RigidBodyMassProps` structure.
+    pub fn from_rapier(mprops: &rapier::dynamics::RigidBodyMassProps) -> Self {
+        #[cfg(feature = "dim3")]
+        let effective_world_inv_inertia = {
+            let i = &mprops.effective_world_inv_inertia;
+            Mat3::from_cols(
+                Vec3::new(i.m11, i.m12, i.m13),
+                Vec3::new(i.m12, i.m22, i.m23),
+                Vec3::new(i.m13, i.m23, i.m33),
+            )
+        };
+        #[cfg(feature = "dim2")]
+        let effective_world_inv_inertia = mprops.effective_world_inv_inertia;
+
+        Self {
+            center_of_mass: mprops.world_com,
+            effective_inv_mass: mprops.effective_inv_mass,
+            effective_world_inv_inertia,
+        }
+    }
+}
+
+/// Entity that likely had their mass properties changed this frame.
+#[derive(Deref, Copy, Clone, Debug, PartialEq, Message)]
+pub struct MassModifiedMessage(pub Entity);
+
+impl From<Entity> for MassModifiedMessage {
+    fn from(entity: Entity) -> Self {
+        Self(entity)
+    }
+}
+
+#[deprecated(
+    since = "0.32.0",
+    note = "MassModifiedMessage has been renamed to MassModifiedEvent for consistency with Bevy 0.17 naming conventions. "
+)]
+pub use MassModifiedMessage as MassModifiedEvent;
+
+/// Center-of-mass, mass, and angular inertia.
+///
+/// This cannot be used as a component. Use the components `ReadMassProperties` to read a [`RigidBody`]’s
+/// mass-properties or `AdditionalMassProperties` to set its additional mass-properties.
+#[derive(Copy, Clone, Debug, Default, PartialEq, Reflect)]
+#[reflect(Default, PartialEq)]
+pub struct MassProperties {
+    /// The center of mass of a [`RigidBody`] expressed in its local-space.
+    pub local_center_of_mass: Vect,
+    /// The mass of a [`RigidBody`].
+    pub mass: f32,
+    /// The principal angular inertia of the [`RigidBody`].
+    #[cfg(feature = "dim2")]
+    pub principal_inertia: f32,
+    /// The principal vectors of the local angular inertia tensor of the [`RigidBody`].
+    #[cfg(feature = "dim3")]
+    pub principal_inertia_local_frame: crate::math::Rot,
+    /// The principal angular inertia of the [`RigidBody`].
+    #[cfg(feature = "dim3")]
+    pub principal_inertia: Vect,
+}
+
+impl MassProperties {
+    /// Converts these mass-properties to Rapier’s `MassProperties` structure.
+    #[cfg(feature = "dim2")]
+    pub fn into_rapier(self) -> rapier::dynamics::MassProperties {
+        rapier::dynamics::MassProperties::new(
+            self.local_center_of_mass,
+            self.mass,
+            #[allow(clippy::useless_conversion)] // Need to convert if dim3 enabled
+            self.principal_inertia.into(),
+        )
+    }
+
+    /// Converts these mass-properties to Rapier’s `MassProperties` structure.
+    #[cfg(feature = "dim3")]
+    pub fn into_rapier(self) -> rapier::dynamics::MassProperties {
+        rapier::dynamics::MassProperties::with_principal_inertia_frame(
+            self.local_center_of_mass,
+            self.mass,
+            self.principal_inertia,
+            self.principal_inertia_local_frame,
+        )
+    }
+
+    /// Converts Rapier’s `MassProperties` structure to `Self`.
+    pub fn from_rapier(mprops: rapier::dynamics::MassProperties) -> Self {
+        #[allow(clippy::useless_conversion)] // Need to convert if dim3 enabled
+        Self {
+            mass: mprops.mass(),
+            local_center_of_mass: mprops.local_com.into(),
+            principal_inertia: mprops.principal_inertia().into(),
+            #[cfg(feature = "dim3")]
+            principal_inertia_local_frame: mprops.principal_inertia_local_frame.into(),
+        }
+    }
+}
+
+#[derive(Default, Debug, Component, Reflect, Copy, Clone, Ord, PartialOrd, Eq, PartialEq, Hash)]
+#[reflect(Component, Default, PartialEq)]
+/// Flags affecting the behavior of the constraints solver for a given contact manifold.
+pub struct LockedAxes(u8);
+
+bitflags::bitflags! {
+    impl LockedAxes: u8 {
+        /// Flag indicating that the [`RigidBody`] cannot translate along the `X` axis.
+        const TRANSLATION_LOCKED_X = 1 << 0;
+        /// Flag indicating that the [`RigidBody`] cannot translate along the `Y` axis.
+        const TRANSLATION_LOCKED_Y = 1 << 1;
+        /// Flag indicating that the [`RigidBody`] cannot translate along the `Z` axis.
+        const TRANSLATION_LOCKED_Z = 1 << 2;
+        /// Flag indicating that the [`RigidBody`] cannot translate along any direction.
+        const TRANSLATION_LOCKED = Self::TRANSLATION_LOCKED_X.bits() | Self::TRANSLATION_LOCKED_Y.bits() | Self::TRANSLATION_LOCKED_Z.bits();
+        /// Flag indicating that the [`RigidBody`] cannot rotate along the `X` axis.
+        const ROTATION_LOCKED_X = 1 << 3;
+        /// Flag indicating that the [`RigidBody`] cannot rotate along the `Y` axis.
+        const ROTATION_LOCKED_Y = 1 << 4;
+        /// Flag indicating that the [`RigidBody`] cannot rotate along the `Z` axis.
+        const ROTATION_LOCKED_Z = 1 << 5;
+        /// Combination of flags indicating that the [`RigidBody`] cannot rotate along any axis.
+        const ROTATION_LOCKED = Self::ROTATION_LOCKED_X.bits() | Self::ROTATION_LOCKED_Y.bits() | Self::ROTATION_LOCKED_Z.bits();
+    }
+}
+
+impl From<LockedAxes> for RapierLockedAxes {
+    fn from(locked_axes: LockedAxes) -> RapierLockedAxes {
+        RapierLockedAxes::from_bits(locked_axes.bits()).expect("Internal conversion error.")
+    }
+}
+
+/// Constant external forces applied continuously to a [`RigidBody`].
+///
+/// This force is applied at each timestep.
+#[derive(Copy, Clone, Debug, Default, PartialEq, Component, Reflect)]
+#[reflect(Component, Default, PartialEq)]
+pub struct ExternalForce {
+    /// The linear force applied to the [`RigidBody`].
+    pub force: Vect,
+    /// The angular torque applied to the [`RigidBody`].
+    #[cfg(feature = "dim2")]
+    pub torque: f32,
+    /// The angular torque applied to the [`RigidBody`].
+    #[cfg(feature = "dim3")]
+    pub torque: Vect,
+}
+
+impl ExternalForce {
+    /// A force applied at a specific world-space point of a [`RigidBody`].
+    ///
+    /// # Parameters
+    /// - `force`: the force to apply.
+    /// - `point`: the point (world-space) where the impulse must be applied.
+    /// - `center_of_mass`: the center-of-mass (world-space) of the [`RigidBody`] the impulse is being
+    ///   applied to.
+    pub fn at_point(force: Vect, point: Vect, center_of_mass: Vect) -> Self {
+        Self {
+            force,
+            #[cfg(feature = "dim2")]
+            torque: (point - center_of_mass).perp_dot(force),
+            #[cfg(feature = "dim3")]
+            torque: (point - center_of_mass).cross(force),
+        }
+    }
+}
+
+impl Add for ExternalForce {
+    type Output = Self;
+
+    #[inline]
+    fn add(mut self, rhs: Self) -> Self::Output {
+        self += rhs;
+        self
+    }
+}
+
+impl Sub for ExternalForce {
+    type Output = Self;
+
+    #[inline]
+    fn sub(mut self, rhs: Self) -> Self::Output {
+        self -= rhs;
+        self
+    }
+}
+
+impl AddAssign for ExternalForce {
+    #[inline]
+    fn add_assign(&mut self, rhs: Self) {
+        self.force += rhs.force;
+        self.torque += rhs.torque;
+    }
+}
+
+impl SubAssign for ExternalForce {
+    #[inline]
+    fn sub_assign(&mut self, rhs: Self) {
+        self.force -= rhs.force;
+        self.torque -= rhs.torque;
+    }
+}
+
+/// Instantaneous external impulse applied continuously to a [`RigidBody`].
+///
+/// The impulse is only applied once, and whenever it it modified (based
+/// on Bevy’s change detection).
+#[derive(Copy, Clone, Debug, Default, PartialEq, Component, Reflect)]
+#[reflect(Component, Default, PartialEq)]
+pub struct ExternalImpulse {
+    /// The linear impulse applied to the [`RigidBody`].
+    pub impulse: Vect,
+    /// The angular impulse applied to the [`RigidBody`].
+    #[cfg(feature = "dim2")]
+    pub torque_impulse: f32,
+    /// The angular impulse applied to the [`RigidBody`].
+    #[cfg(feature = "dim3")]
+    pub torque_impulse: Vect,
+}
+
+impl ExternalImpulse {
+    /// An impulse applied at a specific world-space point of a [`RigidBody`].
+    ///
+    /// # Parameters
+    /// - `impulse`: the impulse to apply.
+    /// - `point`: the point (world-space) where the impulse must be applied.
+    /// - `center_of_mass`: the center-of-mass (world-space) of the [`RigidBody`] the impulse is being
+    ///   applied to.
+    pub fn at_point(impulse: Vect, point: Vect, center_of_mass: Vect) -> Self {
+        Self {
+            impulse,
+            #[cfg(feature = "dim2")]
+            torque_impulse: (point - center_of_mass).perp_dot(impulse),
+            #[cfg(feature = "dim3")]
+            torque_impulse: (point - center_of_mass).cross(impulse),
+        }
+    }
+
+    /// Reset the external impulses to zero.
+    pub fn reset(&mut self) {
+        *self = Default::default();
+    }
+}
+
+impl Add for ExternalImpulse {
+    type Output = Self;
+
+    #[inline]
+    fn add(mut self, rhs: Self) -> Self::Output {
+        self += rhs;
+        self
+    }
+}
+
+impl Sub for ExternalImpulse {
+    type Output = Self;
+
+    #[inline]
+    fn sub(mut self, rhs: Self) -> Self::Output {
+        self -= rhs;
+        self
+    }
+}
+
+impl AddAssign for ExternalImpulse {
+    #[inline]
+    fn add_assign(&mut self, rhs: Self) {
+        self.impulse += rhs.impulse;
+        self.torque_impulse += rhs.torque_impulse;
+    }
+}
+
+impl SubAssign for ExternalImpulse {
+    #[inline]
+    fn sub_assign(&mut self, rhs: Self) {
+        self.impulse -= rhs.impulse;
+        self.torque_impulse -= rhs.torque_impulse;
+    }
+}
+
+/// Gravity is multiplied by this scaling factor before it's
+/// applied to this [`RigidBody`].
+#[derive(Copy, Clone, Debug, PartialEq, Component, Reflect)]
+#[reflect(Component, Default, PartialEq)]
+pub struct GravityScale(pub f32);
+
+impl Default for GravityScale {
+    fn default() -> Self {
+        Self(1.0)
+    }
+}
+
+/// Enables full ("bullet") Continuous-Collision-Detection for a [`RigidBody`].
+///
+/// Fast dynamic bodies always sweep against fixed colliders automatically (unless
+/// [`IntegrationParameters::max_ccd_substeps`] is `0`), even without this component. Enabling
+/// CCD upgrades the body to also sweep against kinematic and dynamic bodies, at an extra CPU cost.
+/// This is useful for projectiles that must not tunnel through other moving bodies. Note that a
+/// bullet never sweeps another bullet, so two CCD-enabled bodies can still tunnel through each other.
+#[derive(Copy, Clone, Debug, Default, PartialEq, Eq, Component, Reflect)]
+#[reflect(Component, Default, PartialEq)]
+pub struct Ccd {
+    /// Is full ("bullet") CCD enabled for this [`RigidBody`]?
+    pub enabled: bool,
+}
+
+impl Ccd {
+    /// Enable CCD for a [`RigidBody`].
+    pub fn enabled() -> Self {
+        Self { enabled: true }
+    }
+
+    /// Disable full CCD for a [`RigidBody`].
+    ///
+    /// Note that a [`RigidBody`] without the Ccd component attached
+    /// has full CCD disabled by default (it still sweeps against fixed colliders when moving fast).
+    pub fn disabled() -> Self {
+        Self { enabled: false }
+    }
+}
+
+/// Sets the maximum prediction distance Soft Continuous Collision-Detection.
+///
+/// When set to 0, soft-CCD is disabled. Soft-CCD helps prevent tunneling especially of
+/// slow-but-thin to moderately fast objects. The soft CCD prediction distance indicates how
+/// far in the object’s path the CCD algorithm is allowed to inspect. Large values can impact
+/// performance badly by increasing the work needed from the broad-phase.
+///
+/// It is a generally cheaper variant of regular CCD (that can be enabled with
+/// [`Ccd`]) since it relies on predictive constraints instead of shape-cast and substeps.
+#[derive(Copy, Clone, Debug, Default, PartialEq, Component, Reflect)]
+#[reflect(Component, Default, PartialEq)]
+pub struct SoftCcd {
+    /// The soft CCD prediction distance.
+    pub prediction: f32,
+}
+
+/// The dominance groups of a [`RigidBody`].
+#[derive(Copy, Clone, Debug, Default, PartialEq, Eq, Component, Reflect)]
+#[reflect(Component, Default, PartialEq)]
+pub struct Dominance {
+    // FIXME: rename this to `group` (no `s`).
+    /// The dominance groups of a [`RigidBody`].
+    pub groups: i8,
+}
+
+impl Dominance {
+    /// Initialize the dominance to the given group.
+    pub fn group(group: i8) -> Self {
+        Self { groups: group }
+    }
+}
+
+/// The activation status of a body.
+///
+/// This controls whether a body is sleeping or not.
+/// If the threshold is negative, the body never sleeps.
+///
+/// Setting `sleeping` to `false` on a sleeping body wakes up its whole island (every body
+/// connected to it through contacts or joints).
+#[derive(Copy, Clone, Debug, PartialEq, Component, Reflect)]
+#[reflect(Component, Default, PartialEq)]
+pub struct Sleeping {
+    /// The linear velocity below which the body can fall asleep.
+    ///
+    /// The effictive threshold is obtained by multpilying this value by the
+    /// [`IntegrationParameters::length_unit`].
+    pub normalized_linear_threshold: f32,
+    /// The angular velocity below which the body can fall asleep.
+    pub angular_threshold: f32,
+    /// How long (in seconds) the body must remain below the velocity thresholds before
+    /// falling asleep.
+    pub time_until_sleep: f32,
+    /// Is this body sleeping?
+    pub sleeping: bool,
+}
+
+impl Sleeping {
+    /// Creates a components that disables sleeping for the associated [`RigidBody`].
+    pub fn disabled() -> Self {
+        Self {
+            normalized_linear_threshold: -1.0,
+            angular_threshold: -1.0,
+            time_until_sleep: RigidBodyActivation::default_time_until_sleep(),
+            sleeping: false,
+        }
+    }
+}
+
+impl Default for Sleeping {
+    fn default() -> Self {
+        Self {
+            normalized_linear_threshold: RigidBodyActivation::default_normalized_linear_threshold(),
+            angular_threshold: RigidBodyActivation::default_angular_threshold(),
+            time_until_sleep: RigidBodyActivation::default_time_until_sleep(),
+            sleeping: false,
+        }
+    }
+}
+
+/// Damping factors to gradually slow down a [`RigidBody`].
+#[derive(Copy, Clone, Debug, PartialEq, Component, Reflect)]
+#[reflect(Component, Default, PartialEq)]
+pub struct Damping {
+    // TODO: rename these to "linear" and "angular"?
+    /// Damping factor for gradually slowing down the translational motion of the [`RigidBody`].
+    pub linear_damping: f32,
+    /// Damping factor for gradually slowing down the angular motion of the [`RigidBody`].
+    pub angular_damping: f32,
+}
+
+impl Default for Damping {
+    fn default() -> Self {
+        Self {
+            linear_damping: 0.0,
+            angular_damping: 0.0,
+        }
+    }
+}
+
+/// If the `TimestepMode::Interpolated` mode is set and this component is present,
+/// the associated [`RigidBody`] will have its position automatically interpolated
+/// between the last two [`RigidBody`] positions set by the physics engine.
+#[derive(Copy, Clone, Debug, Default, PartialEq, Component)]
+pub struct TransformInterpolation {
+    /// The starting point of the interpolation.
+    pub start: Option<Pose>,
+    /// The end point of the interpolation.
+    pub end: Option<Pose>,
+}
+
+impl TransformInterpolation {
+    /// Interpolates between the start and end positions with `t` in the range `[0..1]`.
+    pub fn lerp_slerp(&self, t: f32) -> Option<Pose> {
+        if let (Some(start), Some(end)) = (self.start, self.end) {
+            Some(start.lerp(&end, t))
+        } else {
+            None
+        }
+    }
+}
+
+/// Indicates whether or not the [`RigidBody`] is disabled explicitly by the user.
+#[derive(Copy, Clone, Default, Debug, PartialEq, Eq, Component, Reflect)]
+#[reflect(Component, Default, PartialEq)]
+pub struct RigidBodyDisabled;
+
+/// Set the additional number of solver substeps run for the simulation island containing this
+/// rigid-body.
+///
+/// Each extra substep re-derives the soft constraint bias at a smaller timestep, improving
+/// accuracy for stiff couplings (joint chains, stacks with high mass ratios). The whole
+/// connected component (every body linked to this one through contacts or joints) runs
+/// [`IntegrationParameters::num_solver_iterations`] plus the largest
+/// `AdditionalSolverIterations` among its bodies substeps. The cost thus scales with the size
+/// of that component: attaching such a body to a large pile also substeps the whole pile.
+///
+/// The default value is 0, meaning exactly [`IntegrationParameters::num_solver_iterations`]
+/// substeps will be used for this body.
+#[derive(Copy, Clone, Default, Debug, PartialEq, Eq, Component, Reflect)]
+#[reflect(Component, Default, PartialEq)]
+pub struct AdditionalSolverIterations(pub usize);
+
+/// Set the additional number of internal PGS iterations run at each substep for the simulation
+/// island containing this rigid-body.
+///
+/// The whole connected component (every body linked to this one through contacts or joints)
+/// runs [`IntegrationParameters::num_internal_pgs_iterations`] plus the largest
+/// `AdditionalPgsIterations` among its bodies. The default value is 0.
+#[derive(Copy, Clone, Default, Debug, PartialEq, Eq, Component, Reflect)]
+#[reflect(Component, Default, PartialEq)]
+pub struct AdditionalPgsIterations(pub usize);
+
+/// Allows the [`RigidBody`] to exceed the angular speed cap.
+///
+/// By default, the angular velocity of a rigid-body is clamped at each substep (to roughly
+/// 45 degrees per step) to keep CCD reliable. Add this marker to bodies that must spin fast,
+/// e.g., wheels. Removing it restores the cap.
+#[derive(Copy, Clone, Default, Debug, PartialEq, Eq, Component, Reflect)]
+#[reflect(Component, Default, PartialEq)]
+pub struct AllowFastRotation;
+
+/// Enables or disables gyroscopic forces on a [`RigidBody`].
+///
+/// Gyroscopic forces make spinning bodies resist changes of their rotation axis (e.g.,
+/// spinning tops or flywheels), at a slight performance cost. Rapier enables them by default,
+/// so a rigid-body without this component has gyroscopic forces enabled.
+#[cfg(feature = "dim3")]
+#[derive(Copy, Clone, Debug, PartialEq, Eq, Component, Reflect)]
+#[reflect(Component, Default, PartialEq)]
+pub struct GyroscopicForces {
+    /// Are gyroscopic forces enabled for this [`RigidBody`]?
+    pub enabled: bool,
+}
+
+#[cfg(feature = "dim3")]
+impl GyroscopicForces {
+    /// Enable gyroscopic forces for a [`RigidBody`].
+    pub fn enabled() -> Self {
+        Self { enabled: true }
+    }
+
+    /// Disable gyroscopic forces for a [`RigidBody`].
+    pub fn disabled() -> Self {
+        Self { enabled: false }
+    }
+}
+
+#[cfg(feature = "dim3")]
+impl Default for GyroscopicForces {
+    fn default() -> Self {
+        Self::enabled()
+    }
+}
diff --git a/bindings/bevy_rapier/src/dynamics/rope_joint.rs b/bindings/bevy_rapier/src/dynamics/rope_joint.rs
new file mode 100644
index 000000000..0d42d3573
--- /dev/null
+++ b/bindings/bevy_rapier/src/dynamics/rope_joint.rs
@@ -0,0 +1,299 @@
+use crate::dynamics::{GenericJoint, GenericJointBuilder};
+use crate::math::{Real, Vect};
+use rapier::dynamics::{JointAxesMask, JointAxis, JointLimits, JointMotor, MotorModel};
+
+use super::{SpringCoefficients, TypedJoint};
+
+#[cfg_attr(feature = "serde-serialize", derive(Serialize, Deserialize))]
+#[derive(Copy, Clone, Debug, PartialEq)]
+#[repr(transparent)]
+/// A rope joint, limits the maximum distance between two bodies
+pub struct RopeJoint {
+    /// The underlying joint data.
+    pub data: GenericJoint,
+}
+
+impl RopeJoint {
+    /// Creates a new rope joint limiting the max distance between to bodies
+    pub fn new(max_dist: Real) -> Self {
+        let data = GenericJointBuilder::new(JointAxesMask::empty())
+            .coupled_axes(JointAxesMask::LIN_AXES)
+            .build();
+        let mut result = Self { data };
+        result.set_max_distance(max_dist);
+        result
+    }
+
+    /// Are contacts between the attached rigid-bodies enabled?
+    pub fn contacts_enabled(&self) -> bool {
+        self.data.contacts_enabled()
+    }
+
+    /// Sets whether contacts between the attached rigid-bodies are enabled.
+    pub fn set_contacts_enabled(&mut self, enabled: bool) -> &mut Self {
+        self.data.set_contacts_enabled(enabled);
+        self
+    }
+
+    /// The spring coefficients controlling the softness of this joint’s locked degrees of freedom.
+    #[must_use]
+    pub fn softness(&self) -> SpringCoefficients<Real> {
+        self.data.softness()
+    }
+
+    /// Sets the spring coefficients controlling the softness of this joint’s locked degrees of freedom.
+    pub fn set_softness(&mut self, softness: SpringCoefficients<Real>) -> &mut Self {
+        self.data.set_softness(softness);
+        self
+    }
+
+    /// The joint’s anchor, expressed in the local-space of the first rigid-body.
+    #[must_use]
+    pub fn local_anchor1(&self) -> Vect {
+        self.data.local_anchor1()
+    }
+
+    /// Sets the joint’s anchor, expressed in the local-space of the first rigid-body.
+    pub fn set_local_anchor1(&mut self, anchor1: Vect) -> &mut Self {
+        self.data.set_local_anchor1(anchor1);
+        self
+    }
+
+    /// The joint’s anchor, expressed in the local-space of the second rigid-body.
+    #[must_use]
+    pub fn local_anchor2(&self) -> Vect {
+        self.data.local_anchor2()
+    }
+
+    /// Sets the joint’s anchor, expressed in the local-space of the second rigid-body.
+    pub fn set_local_anchor2(&mut self, anchor2: Vect) -> &mut Self {
+        self.data.set_local_anchor2(anchor2);
+        self
+    }
+
+    /// The principal axis of the joint, expressed in the local-space of the first rigid-body.
+    #[must_use]
+    pub fn local_axis1(&self) -> Vect {
+        self.data.local_axis1()
+    }
+
+    /// Sets the principal axis of the joint, expressed in the local-space of the first rigid-body.
+    pub fn set_local_axis1(&mut self, axis1: Vect) -> &mut Self {
+        self.data.set_local_axis1(axis1);
+        self
+    }
+
+    /// The principal axis of the joint, expressed in the local-space of the second rigid-body.
+    #[must_use]
+    pub fn local_axis2(&self) -> Vect {
+        self.data.local_axis2()
+    }
+
+    /// Sets the principal axis of the joint, expressed in the local-space of the second rigid-body.
+    pub fn set_local_axis2(&mut self, axis2: Vect) -> &mut Self {
+        self.data.set_local_axis2(axis2);
+        self
+    }
+
+    /// The motor affecting the joint’s translational degree of freedom.
+    #[must_use]
+    pub fn motor(&self, axis: JointAxis) -> Option<&JointMotor> {
+        self.data.motor(axis)
+    }
+
+    /// Set the spring-like model used by the motor to reach the desired target velocity and position.
+    pub fn set_motor_model(&mut self, model: MotorModel) -> &mut Self {
+        self.data.set_motor_model(JointAxis::LinX, model);
+        self
+    }
+
+    /// Sets the target velocity this motor needs to reach.
+    pub fn set_motor_velocity(&mut self, target_vel: Real, factor: Real) -> &mut Self {
+        self.data
+            .set_motor_velocity(JointAxis::LinX, target_vel, factor);
+        self
+    }
+
+    /// Sets the target angle this motor needs to reach.
+    pub fn set_motor_position(
+        &mut self,
+        target_pos: Real,
+        stiffness: Real,
+        damping: Real,
+    ) -> &mut Self {
+        self.data
+            .set_motor_position(JointAxis::LinX, target_pos, stiffness, damping);
+        self
+    }
+
+    /// Configure both the target angle and target velocity of the motor.
+    pub fn set_motor(
+        &mut self,
+        target_pos: Real,
+        target_vel: Real,
+        stiffness: Real,
+        damping: Real,
+    ) -> &mut Self {
+        self.data
+            .set_motor(JointAxis::LinX, target_pos, target_vel, stiffness, damping);
+        self
+    }
+
+    /// Sets the maximum force the motor can deliver.
+    pub fn set_motor_max_force(&mut self, max_force: Real) -> &mut Self {
+        self.data.set_motor_max_force(JointAxis::LinX, max_force);
+        self
+    }
+
+    /// The limit distance attached bodies can translate along the joint’s principal axis.
+    #[must_use]
+    pub fn limits(&self, axis: JointAxis) -> Option<&JointLimits<Real>> {
+        self.data.limits(axis)
+    }
+
+    /// Sets the maximum allowed distance between the attached bodies.
+    ///
+    /// The `max_dist` must be strictly greater than 0.0.
+    pub fn set_max_distance(&mut self, max_dist: Real) -> &mut Self {
+        self.data.set_limits(JointAxis::LinX, [0.0, max_dist]);
+        self
+    }
+
+    /// The maximum distance between the attached bodies.
+    pub fn max_distance(&self) -> Real {
+        self.data
+            .limits(JointAxis::LinX)
+            .map(|l| l.max)
+            .unwrap_or(Real::MAX)
+    }
+}
+
+impl From<RopeJoint> for GenericJoint {
+    fn from(joint: RopeJoint) -> GenericJoint {
+        joint.data
+    }
+}
+
+/// Create rope joints using the builder pattern.
+///
+/// A rope joint, limits the maximum distance between two bodies.
+#[cfg_attr(feature = "serde-serialize", derive(Serialize, Deserialize))]
+#[derive(Copy, Clone, Debug, PartialEq)]
+pub struct RopeJointBuilder(RopeJoint);
+
+impl RopeJointBuilder {
+    /// Creates a new builder for rope joints.
+    pub fn new(max_dist: Real) -> Self {
+        Self(RopeJoint::new(max_dist))
+    }
+
+    /// Sets the joint’s anchor, expressed in the local-space of the first rigid-body.
+    #[must_use]
+    pub fn local_anchor1(mut self, anchor1: Vect) -> Self {
+        self.0.set_local_anchor1(anchor1);
+        self
+    }
+
+    /// Sets the joint’s anchor, expressed in the local-space of the second rigid-body.
+    #[must_use]
+    pub fn local_anchor2(mut self, anchor2: Vect) -> Self {
+        self.0.set_local_anchor2(anchor2);
+        self
+    }
+
+    /// Sets the principal axis of the joint, expressed in the local-space of the first rigid-body.
+    #[must_use]
+    pub fn local_axis1(mut self, axis1: Vect) -> Self {
+        self.0.set_local_axis1(axis1);
+        self
+    }
+
+    /// Sets the principal axis of the joint, expressed in the local-space of the second rigid-body.
+    #[must_use]
+    pub fn local_axis2(mut self, axis2: Vect) -> Self {
+        self.0.set_local_axis2(axis2);
+        self
+    }
+
+    /// Set the spring-like model used by the motor to reach the desired target velocity and position.
+    #[must_use]
+    pub fn motor_model(mut self, model: MotorModel) -> Self {
+        self.0.set_motor_model(model);
+        self
+    }
+
+    /// Sets the target velocity this motor needs to reach.
+    #[must_use]
+    pub fn motor_velocity(mut self, target_vel: Real, factor: Real) -> Self {
+        self.0.set_motor_velocity(target_vel, factor);
+        self
+    }
+
+    /// Sets the target angle this motor needs to reach.
+    #[must_use]
+    pub fn motor_position(mut self, target_pos: Real, stiffness: Real, damping: Real) -> Self {
+        self.0.set_motor_position(target_pos, stiffness, damping);
+        self
+    }
+
+    /// Configure both the target angle and target velocity of the motor.
+    #[must_use]
+    pub fn set_motor(
+        mut self,
+        target_pos: Real,
+        target_vel: Real,
+        stiffness: Real,
+        damping: Real,
+    ) -> Self {
+        self.0.set_motor(target_pos, target_vel, stiffness, damping);
+        self
+    }
+
+    /// Sets the maximum force the motor can deliver.
+    #[must_use]
+    pub fn motor_max_force(mut self, max_force: Real) -> Self {
+        self.0.set_motor_max_force(max_force);
+        self
+    }
+
+    /// Sets the maximum allowed distance between the attached bodies.
+    ///
+    /// The `max_dist` must be strictly greater than 0.0.    
+    #[must_use]
+    pub fn max_distance(mut self, max_dist: Real) -> Self {
+        self.0.set_max_distance(max_dist);
+        self
+    }
+
+    /// Sets whether contacts between the attached rigid-bodies are enabled.
+    #[must_use]
+    pub fn contacts_enabled(mut self, enabled: bool) -> Self {
+        self.0.set_contacts_enabled(enabled);
+        self
+    }
+
+    /// Sets the spring coefficients controlling the softness of this joint’s locked degrees of freedom.
+    #[must_use]
+    pub fn softness(mut self, softness: SpringCoefficients<Real>) -> Self {
+        self.0.set_softness(softness);
+        self
+    }
+
+    /// Builds the rope joint.
+    #[must_use]
+    pub fn build(self) -> RopeJoint {
+        self.0
+    }
+}
+
+impl From<RopeJointBuilder> for TypedJoint {
+    fn from(joint: RopeJointBuilder) -> TypedJoint {
+        joint.0.into()
+    }
+}
+
+impl From<RopeJoint> for TypedJoint {
+    fn from(joint: RopeJoint) -> TypedJoint {
+        TypedJoint::RopeJoint(joint)
+    }
+}
diff --git a/bindings/bevy_rapier/src/dynamics/soft_body.rs b/bindings/bevy_rapier/src/dynamics/soft_body.rs
new file mode 100644
index 000000000..173db7eca
--- /dev/null
+++ b/bindings/bevy_rapier/src/dynamics/soft_body.rs
@@ -0,0 +1,741 @@
+//! Components describing soft bodies: deformable bodies made of particles linked by elastic
+//! constraints, simulated together with the rigid-bodies.
+//!
+//! # Entities and conventions
+//!
+//! A soft body is created by inserting a [`SoftBody`] component on an entity. The positions of
+//! the soft body's particles given by its [`SoftBodyBuilder`] are expressed in the local frame of
+//! that entity: they are transformed by the entity's [`GlobalTransform`] when the soft body is
+//! created. After its creation, the particles live in world space and the plugin drives the
+//! entity's [`Transform`]: it follows the pose of the soft body's whole-body proxy (the frame of
+//! its whole-body cluster: its origin is the centroid of the free particles, and its rotation the
+//! best fit of the particles onto their rest shape, identity at creation), its scale is kept. The
+//! colliders of children entities are attached to that proxy, so their entities stay where
+//! their colliders are. A mesh synchronized with [`SoftBodyMeshSync`] is expressed in that frame.
+//! The mass-weighted center of the particles is written to [`SoftBodyState::center_of_mass`].
+//!
+//! The soft body entity also stands for the Rapier objects created with the soft body:
+//! - its surface colliders (their `user_data` holds the entity bits), so collision events,
+//!   contact pairs and scene queries report the soft body entity as the collider entity;
+//! - its hidden proxy rigid-bodies, so contact pairs report it as the rigid-body entity;
+//! - its whole-body proxy rigid-body in particular (the proxy of its whole-body cluster, see
+//!   [`RapierRigidBodySet::soft_body_whole_proxy`]): the entity is mapped to it, so impulse joints
+//!   can attach the whole soft body like a rigid-body, with the soft body entity as their
+//!   `parent` or by adding them to the soft body entity.
+//!
+//! [`SoftBodyCluster`] entities stand for their own cluster proxy rigid-body, which impulse joints
+//! and colliders can be attached to like to any rigid-body. A cluster (or the whole-body cluster
+//! of a soft body entity) can be driven with the [`SoftBodyClusterPinned`],
+//! [`SoftBodyClusterKinematicTarget`], [`SoftBodyClusterShapeMatching`] and
+//! [`SoftBodyClusterMaterial`] components.
+//!
+//! When a soft body tears, the particle indices of its [`SoftBodyPinnedParticles`],
+//! [`SoftBodyKinematicTargets`], [`SoftBodyAttachments`], [`SoftBodyExternalForce`] and
+//! [`SoftBodyExternalImpulse`] components (and the pinned particles of its [`SoftBody`] builder,
+//! restored when [`SoftBodyPinnedParticles`] is removed) are remapped to the renumbered
+//! particles, the entries of the particles moved to a new piece being moved to the entity of that
+//! piece. When a tear splits a cluster, the entity spawned for the new cluster inherits the
+//! [`SoftBodyClusterPinned`], [`SoftBodyClusterKinematicTarget`] (shifted so that the particles
+//! keep their targets), [`SoftBodyClusterShapeMatching`] and [`SoftBodyClusterMaterial`]
+//! components of the split cluster's entity.
+//!
+//! Modifying the [`SoftBody`] component after the soft body was created has no effect. Use the
+//! other components of this module, or the helpers of [`RapierRigidBodySet`] and
+//! [`RapierContextMut`], to control it at runtime. Removing the [`SoftBody`] component or
+//! despawning its entity removes the soft body from the simulation.
+//!
+//! [`RapierRigidBodySet`]: crate::plugin::context::RapierRigidBodySet
+//! [`RapierRigidBodySet::soft_body_whole_proxy`]: crate::plugin::context::RapierRigidBodySet::soft_body_whole_proxy
+//! [`RapierContextMut`]: crate::plugin::context::systemparams::RapierContextMut
+
+use crate::math::{Real, Vect};
+use bevy::prelude::*;
+
+#[cfg(feature = "dim3")]
+pub use rapier::dynamics::SoftBodyDihedral;
+pub use rapier::dynamics::{
+    SoftBindingError, SoftBodiesSettings, SoftBody as RapierSoftBody, SoftBodyBuilder,
+    SoftBodyCell, SoftBodyCellModel, SoftBodyCluster as RapierSoftBodyCluster, SoftBodyEdge,
+    SoftBodyEdgeKind, SoftBodyHandle, SoftBodyMaterial as RapierSoftBodyMaterial, SoftBodyParticle,
+    SoftBodyParticleSettings, SoftBodyPiece, SoftBodyTearEvent as RapierSoftBodyTearEvent,
+    SoftClusterRemoval, SoftClusterSplit, SoftCollisionMesh, SoftEdgePlasticFlow, SoftJointMove,
+    SoftMeshBinding, SoftMeshBindingMode, SoftMeshId, SoftMeshRef, SoftParticleAttachment,
+    SoftPatchConstraints, SoftRecoverySettings, SoftVolumePiece,
+};
+#[cfg(feature = "fem")]
+pub use rapier::dynamics::{SoftBodySolver, SoftFemParameters};
+pub use rapier::geometry::{PairContacts, SoftContactImpulse, SoftPairContacts};
+use rapier::prelude::SpringCoefficients;
+
+#[cfg(doc)]
+use crate::prelude::{Collider, ImpulseJoint, RigidBody};
+
+/// Describes a soft body to create.
+///
+/// The particle positions of [`Self::builder`] are expressed in the local frame of the entity (see
+/// the [module documentation](self) for the conventions). Changes made to this component after
+/// the soft body was created are ignored.
+///
+/// The collider-related components of the entity ([`crate::geometry::Friction`],
+/// [`crate::geometry::Restitution`], [`crate::geometry::CollisionGroups`],
+/// [`crate::geometry::SolverGroups`], [`crate::geometry::ActiveEvents`],
+/// [`crate::geometry::ActiveHooks`], [`crate::geometry::ActiveCollisionTypes`],
+/// [`crate::geometry::ContactForceEventThreshold`], [`crate::geometry::ContactSkin`] and
+/// [`crate::geometry::Sensor`]) configure the soft body's surface colliders (see
+/// [`RapierRigidBodySet::soft_body_colliders`]), like for a [`Collider`]: they override the
+/// builder's collider template, their changes are applied, and removing them restores the
+/// template's values (the particle radius for the contact skin). The `user_data` of the builder
+/// and of its collider template are overwritten with the entity bits.
+///
+/// [`RapierRigidBodySet::soft_body_colliders`]: crate::plugin::context::RapierRigidBodySet::soft_body_colliders
+#[derive(Component, Clone, Debug)]
+pub struct SoftBody {
+    /// The Rapier builder of the soft body, in the local frame of the entity.
+    pub builder: SoftBodyBuilder,
+}
+
+impl From<SoftBodyBuilder> for SoftBody {
+    fn from(builder: SoftBodyBuilder) -> Self {
+        Self::new(builder)
+    }
+}
+
+impl SoftBody {
+    /// A soft body created from the given Rapier builder (positions in the entity's local frame).
+    pub fn new(builder: SoftBodyBuilder) -> Self {
+        Self { builder }
+    }
+
+    /// Applies `f` to the builder of this soft body.
+    ///
+    /// This is useful to chain the builder's methods, e.g.
+    /// `SoftBody::rope(a, b, 20).map(|b| b.particle_mass(0.1).pinned_particles([0]))`.
+    pub fn map(mut self, f: impl FnOnce(SoftBodyBuilder) -> SoftBodyBuilder) -> Self {
+        self.builder = f(self.builder);
+        self
+    }
+
+    /// A rope of `num_particles` particles from `start` to `end` (see [`SoftBodyBuilder::rope`]).
+    pub fn rope(start: Vect, end: Vect, num_particles: usize) -> Self {
+        Self::new(SoftBodyBuilder::rope(start, end, num_particles))
+    }
+
+    /// A triangle-mesh soft body without volumetric cells (see [`SoftBodyBuilder::trimesh`]).
+    ///
+    /// Returns `None` if the mesh is empty.
+    pub fn trimesh(vertices: Vec<Vect>, indices: Vec<[u32; 3]>) -> Option<Self> {
+        SoftBodyBuilder::trimesh(vertices, indices).map(Self::new)
+    }
+
+    /// A volumetric soft body filling a closed, outward-oriented mesh (triangles in 3D, segments
+    /// in 2D) with cells of size `cell_size` (see [`SoftBodyBuilder::volumetric`]).
+    ///
+    /// Returns `None` if the mesh is empty, open, or encloses nothing at that cell size.
+    #[cfg(feature = "dim3")]
+    pub fn volumetric(vertices: &[Vect], indices: &[[u32; 3]], cell_size: Real) -> Option<Self> {
+        SoftBodyBuilder::volumetric(vertices, indices, cell_size).map(Self::new)
+    }
+
+    /// A volumetric soft body filling a closed, outward-oriented mesh (triangles in 3D, segments
+    /// in 2D) with cells of size `cell_size` (see [`SoftBodyBuilder::volumetric`]).
+    ///
+    /// Returns `None` if the mesh is empty, open, or encloses nothing at that cell size.
+    #[cfg(feature = "dim2")]
+    pub fn volumetric(vertices: &[Vect], indices: &[[u32; 2]], cell_size: Real) -> Option<Self> {
+        SoftBodyBuilder::volumetric(vertices, indices, cell_size).map(Self::new)
+    }
+
+    /// Same as [`Self::volumetric`], keeping the given mesh as the soft body's skin (see
+    /// [`SoftBodyBuilder::volumetric_skinned`]).
+    #[cfg(feature = "dim3")]
+    pub fn volumetric_skinned(
+        vertices: &[Vect],
+        indices: &[[u32; 3]],
+        cell_size: Real,
+    ) -> Option<Self> {
+        SoftBodyBuilder::volumetric_skinned(vertices, indices, cell_size).map(Self::new)
+    }
+
+    /// Same as [`Self::volumetric`], keeping the given polyline as the soft body's skin (see
+    /// [`SoftBodyBuilder::volumetric_skinned`]).
+    #[cfg(feature = "dim2")]
+    pub fn volumetric_skinned(
+        vertices: &[Vect],
+        indices: &[[u32; 2]],
+        cell_size: Real,
+    ) -> Option<Self> {
+        SoftBodyBuilder::volumetric_skinned(vertices, indices, cell_size).map(Self::new)
+    }
+
+    /// A rectangular cloth of `nu × nv` particles at `origin + i * du + j * dv` (see
+    /// [`SoftBodyBuilder::cloth`]).
+    #[cfg(feature = "dim3")]
+    pub fn cloth(origin: Vect, du: Vect, dv: Vect, nu: usize, nv: usize) -> Self {
+        Self::new(SoftBodyBuilder::cloth(origin, du, dv, nu, nv))
+    }
+
+    /// A cloth tube around the segment from `origin` to `origin + axis` (see
+    /// [`SoftBodyBuilder::cloth_tube`]).
+    #[cfg(feature = "dim3")]
+    pub fn cloth_tube(
+        origin: Vect,
+        axis: Vect,
+        radius_start: Real,
+        radius_end: Real,
+        num_around: usize,
+        num_along: usize,
+    ) -> Self {
+        Self::new(SoftBodyBuilder::cloth_tube(
+            origin,
+            axis,
+            radius_start,
+            radius_end,
+            num_around,
+            num_along,
+        ))
+    }
+
+    /// A solid box centered at the entity's origin, tetrahedralized on a `nx × ny × nz` particle
+    /// grid (see [`SoftBodyBuilder::cuboid`]).
+    #[cfg(feature = "dim3")]
+    pub fn cuboid(half_extents: Vect, nx: usize, ny: usize, nz: usize) -> Self {
+        Self::new(SoftBodyBuilder::cuboid(
+            Vect::ZERO,
+            half_extents,
+            nx,
+            ny,
+            nz,
+        ))
+    }
+
+    /// A hollow sphere centered at the entity's origin, with volume preservation (see
+    /// [`SoftBodyBuilder::sphere`]).
+    #[cfg(feature = "dim3")]
+    pub fn sphere(radius: Real, subdivisions: usize) -> Self {
+        Self::new(SoftBodyBuilder::sphere(Vect::ZERO, radius, subdivisions))
+    }
+
+    /// A closed polygon with counter-clockwise `points`, with area preservation (see
+    /// [`SoftBodyBuilder::polygon`]).
+    #[cfg(feature = "dim2")]
+    pub fn polygon(points: Vec<Vect>) -> Self {
+        Self::new(SoftBodyBuilder::polygon(points))
+    }
+
+    /// A regular polygon centered at the entity's origin with `num_particles` boundary particles
+    /// (see [`SoftBodyBuilder::disk`]).
+    #[cfg(feature = "dim2")]
+    pub fn disk(radius: Real, num_particles: usize) -> Self {
+        Self::new(SoftBodyBuilder::disk(Vect::ZERO, radius, num_particles))
+    }
+
+    /// A solid rectangle centered at the entity's origin, triangulated on a `nx × ny` particle
+    /// grid (see [`SoftBodyBuilder::grid`]).
+    #[cfg(feature = "dim2")]
+    pub fn grid(half_extents: Vect, nx: usize, ny: usize) -> Self {
+        Self::new(SoftBodyBuilder::grid(Vect::ZERO, half_extents, nx, ny))
+    }
+
+    /// A soft body from a polyline (see [`SoftBodyBuilder::polyline`]).
+    ///
+    /// Returns `None` if the polyline is empty.
+    #[cfg(feature = "dim2")]
+    pub fn polyline(vertices: Vec<Vect>, indices: Option<Vec<[u32; 2]>>) -> Option<Self> {
+        SoftBodyBuilder::polyline(vertices, indices).map(Self::new)
+    }
+}
+
+/// The Rapier handle of a [`SoftBody`] that was inserted to the physics scene.
+#[derive(Copy, Clone, Debug, PartialEq, Eq, Hash, Component)]
+pub struct RapierSoftBodyHandle(pub SoftBodyHandle);
+
+/// The material (stiffness, damping, plasticity and tearing) of a soft body.
+///
+/// It overrides the material of the [`SoftBody`] builder, and changes to it are applied to the
+/// soft body. When removed, the builder's material is restored.
+#[derive(Component, Copy, Clone, Debug, PartialEq, Default, Reflect)]
+#[reflect(Component, Default, PartialEq)]
+pub struct SoftBodyMaterial(
+    /// The Rapier material.
+    #[reflect(remote = crate::reflect::SoftBodyMaterialWrapper)]
+    pub RapierSoftBodyMaterial,
+);
+
+impl SoftBodyMaterial {
+    /// A material with the same softness for every spring family (see
+    /// [`RapierSoftBodyMaterial::uniform`]).
+    pub fn uniform(natural_frequency: Real, damping_ratio: Real) -> Self {
+        Self(RapierSoftBodyMaterial::uniform(
+            rapier::dynamics::SpringCoefficients::new(natural_frequency, damping_ratio),
+        ))
+    }
+}
+
+impl From<RapierSoftBodyMaterial> for SoftBodyMaterial {
+    fn from(material: RapierSoftBodyMaterial) -> Self {
+        Self(material)
+    }
+}
+
+impl std::ops::Deref for SoftBodyMaterial {
+    type Target = RapierSoftBodyMaterial;
+    fn deref(&self) -> &Self::Target {
+        &self.0
+    }
+}
+
+impl std::ops::DerefMut for SoftBodyMaterial {
+    fn deref_mut(&mut self) -> &mut Self::Target {
+        &mut self.0
+    }
+}
+
+/// Add this component to disable a soft body: it is left where it is, without colliders or
+/// constraints, until this component is removed.
+#[derive(Component, Copy, Clone, Debug, Default, Reflect)]
+#[reflect(Component, Default)]
+pub struct SoftBodyDisabled;
+
+/// The particles of a soft body that are pinned (kinematic).
+///
+/// While this component is present, exactly the listed particles are pinned (plus the particles
+/// of the clusters with a [`SoftBodyClusterPinned`] component): they hold their position, or
+/// follow the targets of [`SoftBodyKinematicTargets`]. When removed, the particles pinned by the
+/// [`SoftBody`] builder are restored. Invalid indices are ignored.
+#[derive(Component, Clone, Debug, Default, PartialEq, Eq, Reflect)]
+#[reflect(Component, Default, PartialEq)]
+pub struct SoftBodyPinnedParticles(pub Vec<u32>);
+
+/// World-space kinematic targets of pinned particles, as `(particle index, target)` pairs.
+///
+/// Each time this component changes, every listed pinned particle is moved to its target over
+/// the next simulation step (with the matching velocity, so friction and contacts see the
+/// motion), then held there. Targets of free particles are ignored.
+#[derive(Component, Clone, Debug, Default, PartialEq, Reflect)]
+#[reflect(Component, Default, PartialEq)]
+pub struct SoftBodyKinematicTargets(pub Vec<(u32, Vect)>);
+
+/// A particle of a soft body attached to a rigid-body entity (see [`SoftBodyAttachments`]).
+#[derive(Copy, Clone, Debug, PartialEq, Eq, Reflect)]
+pub struct SoftBodyAttachment {
+    /// The index of the attached particle.
+    pub particle: u32,
+    /// The entity of the [`RigidBody`] (or [`SoftBodyCluster`]) the particle is attached to.
+    pub body: Entity,
+}
+
+/// Particles of a soft body attached to rigid-bodies by two-way point-to-point constraints.
+///
+/// The anchor of each attachment is the particle's position, relative to the rigid-body, at the
+/// time the attachment is created. Each time this component changes, the attachments of the soft
+/// body are updated to match it: the particles whose attached bodies changed are detached and
+/// attached again (with new anchors), the other attachments keep their anchor. When it is
+/// removed, every particle is detached. Attachments to entities that don't have a rigid-body yet
+/// are retried on the next frames.
+#[derive(Component, Clone, Debug, Default, PartialEq, Eq, Reflect)]
+#[reflect(Component, Default, PartialEq)]
+pub struct SoftBodyAttachments(pub Vec<SoftBodyAttachment>);
+
+/// Persistent forces applied to the particles of a soft body.
+///
+/// The forces are applied at each simulation step until this component changes or is removed,
+/// like [`crate::dynamics::ExternalForce`]. Pinned particles ignore them.
+#[derive(Component, Clone, Debug, Default, PartialEq, Reflect)]
+#[reflect(Component, Default, PartialEq)]
+pub struct SoftBodyExternalForce {
+    /// The force applied to every particle.
+    pub force: Vect,
+    /// Additional forces applied to individual particles, as `(particle index, force)` pairs.
+    pub particle_forces: Vec<(u32, Vect)>,
+}
+
+/// One-time impulses applied to the particles of a soft body.
+///
+/// The impulses are applied (and this component reset to zero) at the next simulation step,
+/// like [`crate::dynamics::ExternalImpulse`]. Pinned particles ignore them.
+#[derive(Component, Clone, Debug, Default, PartialEq, Reflect)]
+#[reflect(Component, Default, PartialEq)]
+pub struct SoftBodyExternalImpulse {
+    /// A velocity change applied to every particle, i.e., an impulse per unit of mass: the whole
+    /// soft body is kicked at the same velocity.
+    pub velocity_change: Vect,
+    /// Impulses applied to individual particles, as `(particle index, impulse)` pairs: the
+    /// velocity of each particle changes by its impulse divided by its mass.
+    pub particle_impulses: Vec<(u32, Vect)>,
+}
+
+impl SoftBodyExternalImpulse {
+    /// Resets these impulses to zero.
+    pub fn reset(&mut self) {
+        self.velocity_change = Vect::ZERO;
+        self.particle_impulses.clear();
+    }
+}
+
+/// The multiplier applied to the rest area (2D) or volume (3D) of a soft body to obtain the
+/// target of its volume preservation (`> 1` inflates the soft body).
+///
+/// It overrides the volume factor of the [`SoftBody`] builder. When removed, the builder's volume
+/// factor is restored.
+#[derive(Component, Copy, Clone, Debug, PartialEq, Reflect)]
+#[reflect(Component, Default, PartialEq)]
+pub struct SoftBodyVolumeFactor(pub Real);
+
+impl Default for SoftBodyVolumeFactor {
+    fn default() -> Self {
+        Self(1.0)
+    }
+}
+
+/// Selects the solver simulating the elasticity of a soft body.
+///
+/// It overrides the solver of the [`SoftBody`] builder. When removed, the builder's solver is
+/// restored.
+#[cfg(feature = "fem")]
+#[derive(Component, Copy, Clone, Debug, PartialEq, Eq, Default)]
+pub struct SoftBodyElasticitySolver(pub SoftBodySolver);
+
+/// The state of a soft body, written back after each simulation step.
+///
+/// This component is inserted automatically on every soft body entity. Modifying it has no
+/// effect.
+#[derive(Component, Copy, Clone, Debug, Default, PartialEq, Reflect)]
+#[reflect(Component, Default, PartialEq)]
+pub struct SoftBodyState {
+    /// The world-space, mass-weighted, center of the particles.
+    pub center_of_mass: Vect,
+    /// Whether the soft body is sleeping.
+    pub is_sleeping: bool,
+    /// Whether the soft body takes part in the simulation (see [`SoftBodyDisabled`]; Rapier also
+    /// disables soft bodies with non-finite state).
+    pub is_enabled: bool,
+    /// A counter bumped whenever the topology of the soft body changes (e.g. because of a tear).
+    pub topology_version: u32,
+    /// The number of particles of the soft body.
+    pub num_particles: usize,
+}
+
+/// A cluster of particles of a soft body, backed by a proxy rigid-body.
+///
+/// Insert this component on an entity (usually not the soft body entity itself) to create the
+/// cluster: the entity then gets a [`crate::dynamics::RapierRigidBodyHandle`] of the cluster's
+/// proxy rigid-body, so [`ImpulseJoint`]s and [`Collider`]s can be attached to it like to any
+/// rigid-body. The proxy follows the particles of the cluster: its pose is written back to the
+/// entity's [`Transform`], but changes of the [`Transform`] (or velocity, forces...) of the
+/// entity are not applied to it. Do not add a [`RigidBody`] component to this entity. A
+/// [`Transform`] (and a `Visibility` when a rendering feature is enabled) is inserted if missing,
+/// so rendered children can be added to the entity.
+///
+/// Removing this component or despawning its entity removes the cluster (particles covered only
+/// by this cluster are removed with it). Changes made to this component after the cluster was
+/// created are ignored, except for [`Self::soft_body`] which is updated by the plugin when a tear
+/// moves the cluster to another soft body.
+#[derive(Component, Clone, Debug, PartialEq, Eq, Reflect)]
+#[reflect(Component, PartialEq)]
+#[cfg_attr(
+    any(
+        feature = "debug-render-2d",
+        feature = "debug-render-3d",
+        feature = "picking-backend",
+        feature = "async-collider",
+        feature = "to-bevy-mesh"
+    ),
+    require(Transform, Visibility)
+)]
+#[cfg_attr(
+    not(any(
+        feature = "debug-render-2d",
+        feature = "debug-render-3d",
+        feature = "picking-backend",
+        feature = "async-collider",
+        feature = "to-bevy-mesh"
+    )),
+    require(Transform)
+)]
+pub struct SoftBodyCluster {
+    /// The entity of the soft body the cluster belongs to.
+    pub soft_body: Entity,
+    /// The indices of the particles of the cluster.
+    pub particles: Vec<u32>,
+}
+
+impl SoftBodyCluster {
+    /// A cluster of the given particles of `soft_body`.
+    pub fn new(soft_body: Entity, particles: impl IntoIterator<Item = u32>) -> Self {
+        Self {
+            soft_body,
+            particles: particles.into_iter().collect(),
+        }
+    }
+}
+
+/// Pins every particle of a cluster: the cluster becomes a fixed region dragging the rest of its
+/// soft body, and can be moved with a [`SoftBodyClusterKinematicTarget`].
+///
+/// Insert it on a [`SoftBodyCluster`] entity, or on a [`SoftBody`] entity to pin its whole-body
+/// cluster. The pinned particles add up to the ones of the soft body's
+/// [`SoftBodyPinnedParticles`]. When removed, the particles of the cluster get back the pinned
+/// state given by the [`SoftBodyPinnedParticles`] of the soft body (or its [`SoftBody`] builder)
+/// and by the other pinned clusters.
+#[derive(Component, Copy, Clone, Debug, Default, PartialEq, Eq, Reflect)]
+#[reflect(Component, Default, PartialEq)]
+pub struct SoftBodyClusterPinned;
+
+/// The world-space pose a pinned cluster is moved to.
+///
+/// Each time this component changes, the pinned particles of the cluster are moved rigidly over
+/// the next simulation step (with matching velocities) so that the rest shape of the cluster,
+/// centered on its rest centroid, is placed at this pose; then they are held there. Only the
+/// translation and rotation of the [`Transform`] are used. Inserting it also inserts
+/// [`SoftBodyClusterPinned`], since only pinned particles follow the target.
+///
+/// Insert it on a [`SoftBodyCluster`] entity, or on a [`SoftBody`] entity for its whole-body
+/// cluster. Removing it leaves the particles where they are.
+#[derive(Component, Copy, Clone, Debug, Default, PartialEq, Reflect)]
+#[reflect(Component, Default, PartialEq)]
+#[require(SoftBodyClusterPinned)]
+pub struct SoftBodyClusterKinematicTarget(pub Transform);
+
+/// Enables the shape matching of the particles of a cluster toward the cluster's frame, or
+/// toward a target pose.
+///
+/// Insert it on a [`SoftBodyCluster`] entity, or on a [`SoftBody`] entity for its whole-body
+/// cluster (whose shape matching can also be enabled by its [`SoftBody`] builder). Changes are
+/// applied to the cluster. When removed, the shape matching of the cluster is disabled (or reset
+/// to the builder's setting for a whole-body cluster) and its target is cleared.
+#[derive(Component, Copy, Clone, Debug, Default, PartialEq, Reflect)]
+#[reflect(Component, Default, PartialEq)]
+pub struct SoftBodyClusterShapeMatching {
+    /// The world-space pose the particles are shape-matched toward (only its translation and
+    /// rotation are used), or `None` to shape-match them toward the cluster's own frame.
+    pub target: Option<Transform>,
+}
+
+/// Regional material overrides of the elements (cells and edges) fully contained in a cluster.
+///
+/// Insert it on a [`SoftBodyCluster`] entity, or on a [`SoftBody`] entity for its whole-body
+/// cluster. Changes are applied to the elements of the cluster. When removed, the default values
+/// are applied back, which also discards the per-element tear resistances given by the
+/// [`SoftBody`] builder for these elements.
+#[derive(Component, Copy, Clone, Debug, PartialEq)]
+pub struct SoftBodyClusterMaterial {
+    /// Multiplier of the stiffness (Young modulus) of the cells of the cluster (default: `1.0`).
+    pub stiffness_scale: Real,
+    /// Softness overriding the one of the material for the structural and bending edges of the
+    /// cluster (default: `None`, the material's softness).
+    pub edge_softness: Option<SpringCoefficients<Real>>,
+    /// Multiplier of the tear thresholds of the edges and cells of the cluster (default: `1.0`).
+    pub tear_resistance: Real,
+}
+
+impl Default for SoftBodyClusterMaterial {
+    fn default() -> Self {
+        Self {
+            stiffness_scale: 1.0,
+            edge_softness: None,
+            tear_resistance: 1.0,
+        }
+    }
+}
+
+/// Turns the [`Collider`] of this entity into a deformable collider bound to the particles of a
+/// soft body.
+///
+/// The collider shape must be a polyline (2D) or a triangle mesh (3D) with the deformable flag
+/// (`PolylineFlags::DEFORMABLE`, `TriMeshFlags::DEFORMABLE`). Its vertices, placed by the
+/// [`GlobalTransform`] of the entity when it is created, are bound to the particles of `target`
+/// according to `binding`. After its creation, the collider follows the particles: changes to the
+/// [`Transform`] and shape of the entity are ignored, but the other collider components (friction,
+/// collision groups, events...) apply as usual.
+///
+/// If the binding fails, an error is logged and a [`DeformableColliderError`] is inserted.
+#[derive(Component, Clone, Debug)]
+pub struct DeformableCollider {
+    /// The entity of the [`SoftBody`] (the collider is bound to its whole-body cluster) or of the
+    /// [`SoftBodyCluster`] the collider is bound to.
+    pub target: Entity,
+    /// How the collider's vertices are bound to the particles.
+    pub binding: SoftMeshBinding,
+}
+
+impl DeformableCollider {
+    /// A deformable collider bound to `target` according to `binding`.
+    pub fn new(target: Entity, binding: SoftMeshBinding) -> Self {
+        Self { target, binding }
+    }
+}
+
+/// Inserted on an entity whose [`DeformableCollider`] could not be created.
+///
+/// Remove it (after fixing the collider or its binding) to try again.
+#[derive(Component, Copy, Clone, Debug, PartialEq, Eq)]
+pub struct DeformableColliderError(pub SoftBindingError);
+
+/// Add this component to a [`SoftBody`] entity to render the soft body with a mesh kept in sync
+/// with its particles.
+///
+/// The plugin generates the mesh (see [`soft_body_mesh`] for the geometry: the skin or surface
+/// of the soft body in 3D, its cells in 2D; never the meshes of [`DeformableCollider`]s) and
+/// inserts it as a `Mesh3d` (3D) or `Mesh2d` (2D) component if the entity doesn't have one
+/// already (the existing mesh asset is overwritten otherwise). After each simulation step, the
+/// vertex positions (and normals in 3D) are updated from the particles, and the mesh is rebuilt
+/// when the topology of the soft body changes (e.g. after a tear). The vertices are expressed in
+/// the frame of the entity's [`Transform`] (see the [module documentation](self)). A material
+/// must be added by the user.
+#[cfg(feature = "to-bevy-mesh")]
+#[derive(Component, Clone, Debug, Default)]
+pub struct SoftBodyMeshSync {
+    pub(crate) built: Option<SoftBodyMeshSignature>,
+}
+
+/// What a synchronized soft-body mesh was built from: it is rebuilt when this changes.
+#[cfg(feature = "to-bevy-mesh")]
+#[derive(Copy, Clone, Debug, PartialEq, Eq)]
+pub(crate) struct SoftBodyMeshSignature {
+    pub handle: SoftBodyHandle,
+    pub topology_version: u32,
+    pub num_vertices: usize,
+    pub num_indices: usize,
+}
+
+/// The geometry used to render a soft body.
+#[cfg(feature = "to-bevy-mesh")]
+pub(crate) struct SoftBodyRenderGeometry {
+    /// World-space vertex positions.
+    pub vertices: Vec<Vect>,
+    /// The indices of the triangles (triangle list) or segments (line list).
+    pub indices: Vec<u32>,
+    /// Whether the indices describe triangles (`true`) or segments.
+    pub triangles: bool,
+}
+
+#[cfg(feature = "to-bevy-mesh")]
+impl SoftBodyRenderGeometry {
+    /// The geometry rendering `soft_body`, whose colliders are in `colliders` (see
+    /// [`soft_body_mesh`]).
+    pub fn new(soft_body: &RapierSoftBody, colliders: &rapier::geometry::ColliderSet) -> Self {
+        let vertices: Vec<Vect> = soft_body.particle_positions().collect();
+
+        #[cfg(feature = "dim3")]
+        {
+            // The meshes created with the soft body (the colliders of the meshes added later,
+            // e.g. by `DeformableCollider`s, stand for other entities).
+            let own = |mesh: &&SoftCollisionMesh| {
+                !mesh.collision_enabled()
+                    || colliders
+                        .get(mesh.collider())
+                        .is_some_and(|co| co.user_data == soft_body.user_data)
+            };
+            let surface = |skinned: bool| {
+                soft_body.meshes().filter(own).find(|mesh| {
+                    mesh.arity() == 3 && !mesh.indices().is_empty() && mesh.is_skinned() == skinned
+                })
+            };
+            if let Some(mesh) = surface(true).or_else(|| surface(false)) {
+                return Self {
+                    vertices: mesh.vertex_positions(soft_body).collect(),
+                    indices: mesh.indices().iter().flatten().copied().collect(),
+                    triangles: true,
+                };
+            }
+
+            if !soft_body.boundary().is_empty() {
+                return Self {
+                    vertices,
+                    indices: soft_body.boundary().iter().flatten().copied().collect(),
+                    triangles: true,
+                };
+            }
+        }
+        #[cfg(feature = "dim2")]
+        let _ = colliders;
+
+        #[cfg(feature = "dim2")]
+        {
+            if !soft_body.cells().is_empty() {
+                return Self {
+                    vertices,
+                    indices: soft_body
+                        .cells()
+                        .iter()
+                        .flat_map(|cell| cell.vertices)
+                        .collect(),
+                    triangles: true,
+                };
+            }
+
+            if !soft_body.boundary().is_empty() {
+                return Self {
+                    vertices,
+                    indices: soft_body.boundary().iter().flatten().copied().collect(),
+                    triangles: false,
+                };
+            }
+        }
+
+        Self {
+            vertices,
+            indices: soft_body
+                .edges()
+                .iter()
+                .filter(|edge| edge.kind == SoftBodyEdgeKind::Structural)
+                .flat_map(|edge| edge.vertices)
+                .collect(),
+            triangles: false,
+        }
+    }
+
+    /// The mesh with this geometry, with its vertices transformed by `transform`.
+    pub fn to_mesh(&self, transform: &bevy::math::Affine3A) -> bevy::mesh::Mesh {
+        use bevy::asset::RenderAssetUsages;
+        use bevy::mesh::{Indices, Mesh, PrimitiveTopology};
+
+        let topology = if self.triangles {
+            PrimitiveTopology::TriangleList
+        } else {
+            PrimitiveTopology::LineList
+        };
+        let mut mesh = Mesh::new(topology, RenderAssetUsages::default());
+        mesh.insert_attribute(Mesh::ATTRIBUTE_POSITION, self.positions(transform));
+        mesh.insert_indices(Indices::U32(self.indices.clone()));
+        if self.triangles && !self.indices.is_empty() {
+            mesh.compute_smooth_normals();
+        }
+        mesh
+    }
+
+    /// The vertex positions transformed by `transform`, as a Bevy mesh attribute.
+    pub fn positions(&self, transform: &bevy::math::Affine3A) -> Vec<[f32; 3]> {
+        self.vertices
+            .iter()
+            .map(|v| {
+                #[cfg(feature = "dim2")]
+                let v = v.extend(0.0);
+                #[cfg(feature = "dim3")]
+                let v = *v;
+                transform.transform_point3(v).to_array()
+            })
+            .collect()
+    }
+}
+
+/// A mesh rendering the given Rapier soft body, with world-space vertices.
+///
+/// `colliders` is the collider set of the soft body's context: it tells apart the meshes created
+/// with the soft body from the ones added later by [`DeformableCollider`]s, which are not
+/// rendered. The rendered geometry is chosen in this order:
+/// - In 3D: the soft body's skin (see [`SoftBodyBuilder::volumetric_skinned`]), else its surface
+///   collision mesh, else its boundary triangles; for a soft body without surface (e.g. a rope),
+///   a line list of its structural edges. The mesh has normals.
+/// - In 2D: a triangle mesh of its cells (even if its skin is the collision mesh: the skin is
+///   embedded in the cells and cannot be filled), else a line list of its boundary, else of its
+///   structural edges.
+///
+/// The mesh can be modified after being added to the assets (it keeps its main-world data).
+#[cfg(feature = "to-bevy-mesh")]
+pub fn soft_body_mesh(
+    soft_body: &RapierSoftBody,
+    colliders: &rapier::geometry::ColliderSet,
+) -> bevy::mesh::Mesh {
+    SoftBodyRenderGeometry::new(soft_body, colliders).to_mesh(&bevy::math::Affine3A::IDENTITY)
+}
diff --git a/bindings/bevy_rapier/src/dynamics/spherical_joint.rs b/bindings/bevy_rapier/src/dynamics/spherical_joint.rs
new file mode 100644
index 000000000..15913f4fb
--- /dev/null
+++ b/bindings/bevy_rapier/src/dynamics/spherical_joint.rs
@@ -0,0 +1,341 @@
+use crate::dynamics::{GenericJoint, GenericJointBuilder};
+use crate::math::{Real, Rot, Vect};
+use rapier::dynamics::{JointAxesMask, JointAxis, JointLimits, JointMotor, MotorModel};
+use rapier::math::Pose;
+
+use super::{SpringCoefficients, TypedJoint};
+
+#[cfg_attr(feature = "serde-serialize", derive(Serialize, Deserialize))]
+#[derive(Copy, Clone, Debug, PartialEq)]
+#[repr(transparent)]
+/// A spherical joint, locks all relative translations between two bodies.
+pub struct SphericalJoint {
+    /// The underlying joint data.
+    pub data: GenericJoint,
+}
+
+impl Default for SphericalJoint {
+    fn default() -> Self {
+        SphericalJoint::new()
+    }
+}
+
+impl SphericalJoint {
+    /// Creates a new spherical joint locking all relative translations between two bodies.
+    pub fn new() -> Self {
+        let data = GenericJointBuilder::new(JointAxesMask::LOCKED_SPHERICAL_AXES).build();
+        Self { data }
+    }
+
+    /// Are contacts between the attached rigid-bodies enabled?
+    pub fn contacts_enabled(&self) -> bool {
+        self.data.contacts_enabled()
+    }
+
+    /// Sets whether contacts between the attached rigid-bodies are enabled.
+    pub fn set_contacts_enabled(&mut self, enabled: bool) -> &mut Self {
+        self.data.set_contacts_enabled(enabled);
+        self
+    }
+
+    /// The spring coefficients controlling the softness of this joint’s locked degrees of freedom.
+    #[must_use]
+    pub fn softness(&self) -> SpringCoefficients<Real> {
+        self.data.softness()
+    }
+
+    /// Sets the spring coefficients controlling the softness of this joint’s locked degrees of freedom.
+    pub fn set_softness(&mut self, softness: SpringCoefficients<Real>) -> &mut Self {
+        self.data.set_softness(softness);
+        self
+    }
+
+    /// The joint’s anchor, expressed in the local-space of the first rigid-body.
+    #[must_use]
+    pub fn local_anchor1(&self) -> Vect {
+        self.data.local_anchor1()
+    }
+
+    /// Sets the joint’s anchor, expressed in the local-space of the first rigid-body.
+    pub fn set_local_anchor1(&mut self, anchor1: Vect) -> &mut Self {
+        self.data.set_local_anchor1(anchor1);
+        self
+    }
+
+    /// The joint’s anchor, expressed in the local-space of the second rigid-body.
+    #[must_use]
+    pub fn local_anchor2(&self) -> Vect {
+        self.data.local_anchor2()
+    }
+
+    /// Sets the joint’s anchor, expressed in the local-space of the second rigid-body.
+    pub fn set_local_anchor2(&mut self, anchor2: Vect) -> &mut Self {
+        self.data.set_local_anchor2(anchor2);
+        self
+    }
+
+    /// The joint’s basis, expressed in the first rigid-body’s local-space.
+    #[must_use]
+    pub fn local_basis1(&self) -> Rot {
+        self.data.local_basis1()
+    }
+
+    /// Sets the joint’s basis, expressed in the first rigid-body’s local-space.
+    pub fn set_local_basis1(&mut self, local_basis: Rot) -> &mut Self {
+        self.data.set_local_basis1(local_basis);
+        self
+    }
+
+    /// The joint’s basis, expressed in the second rigid-body’s local-space.
+    #[must_use]
+    pub fn local_basis2(&self) -> Rot {
+        self.data.local_basis2()
+    }
+
+    /// Sets the joint’s basis, expressed in the second rigid-body’s local-space.
+    pub fn set_local_basis2(&mut self, local_basis: Rot) -> &mut Self {
+        self.data.set_local_basis2(local_basis);
+        self
+    }
+
+    /// The joint’s frame (anchor and basis), expressed in the first rigid-body’s local-space.
+    #[must_use]
+    pub fn local_frame1(&self) -> Pose {
+        self.data.local_frame1()
+    }
+
+    /// Sets the joint’s frame (anchor and basis), expressed in the first rigid-body’s local-space.
+    pub fn set_local_frame1(&mut self, local_frame: Pose) -> &mut Self {
+        self.data.set_local_frame1(local_frame);
+        self
+    }
+
+    /// The joint’s frame (anchor and basis), expressed in the second rigid-body’s local-space.
+    #[must_use]
+    pub fn local_frame2(&self) -> Pose {
+        self.data.local_frame2()
+    }
+
+    /// Sets the joint’s frame (anchor and basis), expressed in the second rigid-body’s local-space.
+    pub fn set_local_frame2(&mut self, local_frame: Pose) -> &mut Self {
+        self.data.set_local_frame2(local_frame);
+        self
+    }
+
+    /// The motor affecting the joint’s rotational degree of freedom along the specified axis.
+    #[must_use]
+    pub fn motor(&self, axis: JointAxis) -> Option<&JointMotor> {
+        self.data.motor(axis)
+    }
+
+    /// Set the spring-like model used by the motor to reach the desired target velocity and position.
+    pub fn set_motor_model(&mut self, axis: JointAxis, model: MotorModel) -> &mut Self {
+        self.data.set_motor_model(axis, model);
+        self
+    }
+
+    /// Sets the target velocity this motor needs to reach.
+    pub fn set_motor_velocity(
+        &mut self,
+        axis: JointAxis,
+        target_vel: Real,
+        factor: Real,
+    ) -> &mut Self {
+        self.data.set_motor_velocity(axis, target_vel, factor);
+        self
+    }
+
+    /// Sets the target angle this motor needs to reach.
+    pub fn set_motor_position(
+        &mut self,
+        axis: JointAxis,
+        target_pos: Real,
+        stiffness: Real,
+        damping: Real,
+    ) -> &mut Self {
+        self.data
+            .set_motor_position(axis, target_pos, stiffness, damping);
+        self
+    }
+
+    /// Configure both the target angle and target velocity of the motor.
+    pub fn set_motor(
+        &mut self,
+        axis: JointAxis,
+        target_pos: Real,
+        target_vel: Real,
+        stiffness: Real,
+        damping: Real,
+    ) -> &mut Self {
+        self.data
+            .set_motor(axis, target_pos, target_vel, stiffness, damping);
+        self
+    }
+
+    /// Sets the maximum force the motor can deliver along the specified axis.
+    pub fn set_motor_max_force(&mut self, axis: JointAxis, max_force: Real) -> &mut Self {
+        self.data.set_motor_max_force(axis, max_force);
+        self
+    }
+
+    /// The limit distance attached bodies can translate along the specified axis.
+    #[must_use]
+    pub fn limits(&self, axis: JointAxis) -> Option<&JointLimits<Real>> {
+        self.data.limits(axis)
+    }
+
+    /// Sets the `[min,max]` limit angles attached bodies can translate along the joint’s principal axis.
+    pub fn set_limits(&mut self, axis: JointAxis, limits: [Real; 2]) -> &mut Self {
+        self.data.set_limits(axis, limits);
+        self
+    }
+}
+
+impl From<SphericalJoint> for GenericJoint {
+    fn from(joint: SphericalJoint) -> GenericJoint {
+        joint.data
+    }
+}
+
+/// Create spherical joints using the builder pattern.
+#[cfg_attr(feature = "serde-serialize", derive(Serialize, Deserialize))]
+#[derive(Copy, Default, Clone, Debug, PartialEq)]
+pub struct SphericalJointBuilder(SphericalJoint);
+
+impl SphericalJointBuilder {
+    /// Creates a new builder for spherical joints.
+    pub fn new() -> Self {
+        Self(SphericalJoint::new())
+    }
+
+    /// Sets the joint’s anchor, expressed in the local-space of the first rigid-body.
+    #[must_use]
+    pub fn local_anchor1(mut self, anchor1: Vect) -> Self {
+        self.0.set_local_anchor1(anchor1);
+        self
+    }
+
+    /// Sets the joint’s anchor, expressed in the local-space of the second rigid-body.
+    #[must_use]
+    pub fn local_anchor2(mut self, anchor2: Vect) -> Self {
+        self.0.set_local_anchor2(anchor2);
+        self
+    }
+
+    /// Sets the joint’s basis, expressed in the first rigid-body’s local-space.
+    #[must_use]
+    pub fn local_basis1(mut self, local_basis: Rot) -> Self {
+        self.0.set_local_basis1(local_basis);
+        self
+    }
+
+    /// Sets the joint’s basis, expressed in the second rigid-body’s local-space.
+    #[must_use]
+    pub fn local_basis2(mut self, local_basis: Rot) -> Self {
+        self.0.set_local_basis2(local_basis);
+        self
+    }
+
+    /// Sets the joint’s frame (anchor and basis), expressed in the first rigid-body’s local-space.
+    #[must_use]
+    pub fn local_frame1(mut self, local_frame: Pose) -> Self {
+        self.0.set_local_frame1(local_frame);
+        self
+    }
+
+    /// Sets the joint’s frame (anchor and basis), expressed in the second rigid-body’s local-space.
+    #[must_use]
+    pub fn local_frame2(mut self, local_frame: Pose) -> Self {
+        self.0.set_local_frame2(local_frame);
+        self
+    }
+
+    /// Set the spring-like model used by the motor to reach the desired target velocity and position.
+    #[must_use]
+    pub fn motor_model(mut self, axis: JointAxis, model: MotorModel) -> Self {
+        self.0.set_motor_model(axis, model);
+        self
+    }
+
+    /// Sets the target velocity this motor needs to reach.
+    #[must_use]
+    pub fn motor_velocity(mut self, axis: JointAxis, target_vel: Real, factor: Real) -> Self {
+        self.0.set_motor_velocity(axis, target_vel, factor);
+        self
+    }
+
+    /// Sets the target angle this motor needs to reach.
+    #[must_use]
+    pub fn motor_position(
+        mut self,
+        axis: JointAxis,
+        target_pos: Real,
+        stiffness: Real,
+        damping: Real,
+    ) -> Self {
+        self.0
+            .set_motor_position(axis, target_pos, stiffness, damping);
+        self
+    }
+
+    /// Configure both the target angle and target velocity of the motor.
+    #[must_use]
+    pub fn motor(
+        mut self,
+        axis: JointAxis,
+        target_pos: Real,
+        target_vel: Real,
+        stiffness: Real,
+        damping: Real,
+    ) -> Self {
+        self.0
+            .set_motor(axis, target_pos, target_vel, stiffness, damping);
+        self
+    }
+
+    /// Sets the maximum force the motor can deliver along the specified axis.
+    #[must_use]
+    pub fn motor_max_force(mut self, axis: JointAxis, max_force: Real) -> Self {
+        self.0.set_motor_max_force(axis, max_force);
+        self
+    }
+
+    /// Sets the `[min,max]` limit distances attached bodies can rotate along the specified axis.
+    #[must_use]
+    pub fn limits(mut self, axis: JointAxis, limits: [Real; 2]) -> Self {
+        self.0.set_limits(axis, limits);
+        self
+    }
+
+    /// Sets whether contacts between the attached rigid-bodies are enabled.
+    #[must_use]
+    pub fn contacts_enabled(mut self, enabled: bool) -> Self {
+        self.0.set_contacts_enabled(enabled);
+        self
+    }
+
+    /// Sets the spring coefficients controlling the softness of this joint’s locked degrees of freedom.
+    #[must_use]
+    pub fn softness(mut self, softness: SpringCoefficients<Real>) -> Self {
+        self.0.set_softness(softness);
+        self
+    }
+
+    /// Builds the spherical joint.
+    #[must_use]
+    pub fn build(self) -> SphericalJoint {
+        self.0
+    }
+}
+
+impl From<SphericalJointBuilder> for TypedJoint {
+    fn from(joint: SphericalJointBuilder) -> TypedJoint {
+        joint.0.into()
+    }
+}
+
+impl From<SphericalJoint> for TypedJoint {
+    fn from(joint: SphericalJoint) -> TypedJoint {
+        TypedJoint::SphericalJoint(joint)
+    }
+}
diff --git a/bindings/bevy_rapier/src/dynamics/spring_joint.rs b/bindings/bevy_rapier/src/dynamics/spring_joint.rs
new file mode 100644
index 000000000..d71ecccbf
--- /dev/null
+++ b/bindings/bevy_rapier/src/dynamics/spring_joint.rs
@@ -0,0 +1,152 @@
+use crate::dynamics::{GenericJoint, GenericJointBuilder, JointAxesMask};
+use crate::dynamics::{JointAxis, MotorModel};
+use crate::math::{Real, Vect};
+
+use super::TypedJoint;
+
+#[cfg_attr(feature = "serde-serialize", derive(Serialize, Deserialize))]
+#[derive(Copy, Clone, Debug, PartialEq)]
+#[repr(transparent)]
+/// A spring-damper joint, applies a force proportional to the distance between two objects.
+///
+/// The spring is integrated implicitly, implying that even an undamped spring will be subject to some
+/// amount of numerical damping (so it will eventually come to a rest). More solver iterations, or smaller
+/// timesteps, will lower the effect of numerical damping, providing a more realistic result.
+pub struct SpringJoint {
+    /// The underlying joint data.
+    pub data: GenericJoint,
+}
+
+impl SpringJoint {
+    /// Creates a new spring joint limiting the max distance between two bodies.
+    ///
+    /// The `max_dist` must be strictly greater than 0.0.
+    pub fn new(rest_length: Real, stiffness: Real, damping: Real) -> Self {
+        let data = GenericJointBuilder::new(JointAxesMask::empty())
+            .coupled_axes(JointAxesMask::LIN_AXES)
+            .motor_position(JointAxis::LinX, rest_length, stiffness, damping)
+            .motor_model(JointAxis::LinX, MotorModel::ForceBased)
+            .build();
+        Self { data }
+    }
+
+    /// Are contacts between the attached rigid-bodies enabled?
+    pub fn contacts_enabled(&self) -> bool {
+        self.data.contacts_enabled()
+    }
+
+    /// Sets whether contacts between the attached rigid-bodies are enabled.
+    pub fn set_contacts_enabled(&mut self, enabled: bool) -> &mut Self {
+        self.data.set_contacts_enabled(enabled);
+        self
+    }
+
+    /// The joint’s anchor, expressed in the local-space of the first rigid-body.
+    #[must_use]
+    pub fn local_anchor1(&self) -> Vect {
+        self.data.local_anchor1()
+    }
+
+    /// Sets the joint’s anchor, expressed in the local-space of the first rigid-body.
+    pub fn set_local_anchor1(&mut self, anchor1: Vect) -> &mut Self {
+        self.data.set_local_anchor1(anchor1);
+        self
+    }
+
+    /// The joint’s anchor, expressed in the local-space of the second rigid-body.
+    #[must_use]
+    pub fn local_anchor2(&self) -> Vect {
+        self.data.local_anchor2()
+    }
+
+    /// Sets the joint’s anchor, expressed in the local-space of the second rigid-body.
+    pub fn set_local_anchor2(&mut self, anchor2: Vect) -> &mut Self {
+        self.data.set_local_anchor2(anchor2);
+        self
+    }
+
+    /// Set the spring model used by this joint to reach the desired target velocity and position.
+    ///
+    /// Setting this to `MotorModel::ForceBased` (which is the default value for this joint) makes the spring constants
+    /// (stiffness and damping) parameter understood as in the regular spring-mass-damper system. With
+    /// `MotorModel::AccelerationBased`, the spring constants will be automatically scaled by the attached masses,
+    /// making the spring more mass-independent.
+    pub fn set_spring_model(&mut self, model: MotorModel) -> &mut Self {
+        self.data.set_motor_model(JointAxis::LinX, model);
+        self
+    }
+}
+
+impl From<SpringJoint> for GenericJoint {
+    fn from(val: SpringJoint) -> GenericJoint {
+        val.data
+    }
+}
+
+/// A [SpringJoint] joint using the builder pattern.
+///
+/// This builds a spring-damper joint which applies a force proportional to the distance between two objects.
+/// See the documentation of [SpringJoint] for more information on its behavior.
+#[cfg_attr(feature = "serde-serialize", derive(Serialize, Deserialize))]
+#[derive(Copy, Clone, Debug, PartialEq)]
+pub struct SpringJointBuilder(pub SpringJoint);
+
+impl SpringJointBuilder {
+    /// Creates a new builder for spring joints.
+    ///
+    /// This axis is expressed in the local-space of both rigid-bodies.
+    pub fn new(rest_length: Real, stiffness: Real, damping: Real) -> Self {
+        Self(SpringJoint::new(rest_length, stiffness, damping))
+    }
+
+    /// Sets whether contacts between the attached rigid-bodies are enabled.
+    #[must_use]
+    pub fn contacts_enabled(mut self, enabled: bool) -> Self {
+        self.0.set_contacts_enabled(enabled);
+        self
+    }
+
+    /// Sets the joint’s anchor, expressed in the local-space of the first rigid-body.
+    #[must_use]
+    pub fn local_anchor1(mut self, anchor1: Vect) -> Self {
+        self.0.set_local_anchor1(anchor1);
+        self
+    }
+
+    /// Sets the joint’s anchor, expressed in the local-space of the second rigid-body.
+    #[must_use]
+    pub fn local_anchor2(mut self, anchor2: Vect) -> Self {
+        self.0.set_local_anchor2(anchor2);
+        self
+    }
+
+    /// Set the spring used by this joint to reach the desired target velocity and position.
+    ///
+    /// Setting this to `MotorModel::ForceBased` (which is the default value for this joint) makes the spring constants
+    /// (stiffness and damping) parameter understood as in the regular spring-mass-damper system. With
+    /// `MotorModel::AccelerationBased`, the spring constants will be automatically scaled by the attached masses,
+    /// making the spring more mass-independent.
+    #[must_use]
+    pub fn spring_model(mut self, model: MotorModel) -> Self {
+        self.0.set_spring_model(model);
+        self
+    }
+
+    /// Builds the spring joint.
+    #[must_use]
+    pub fn build(self) -> SpringJoint {
+        self.0
+    }
+}
+
+impl From<SpringJointBuilder> for TypedJoint {
+    fn from(joint: SpringJointBuilder) -> TypedJoint {
+        joint.0.into()
+    }
+}
+
+impl From<SpringJoint> for TypedJoint {
+    fn from(joint: SpringJoint) -> TypedJoint {
+        TypedJoint::SpringJoint(joint)
+    }
+}
diff --git a/bindings/bevy_rapier/src/geometry/collider.rs b/bindings/bevy_rapier/src/geometry/collider.rs
new file mode 100644
index 000000000..f75ae871d
--- /dev/null
+++ b/bindings/bevy_rapier/src/geometry/collider.rs
@@ -0,0 +1,741 @@
+use std::fmt;
+
+#[cfg(all(feature = "dim3", feature = "async-collider"))]
+use {
+    crate::geometry::{FillMode, MeshConverter, TriMeshFlags, VHACDParameters},
+    crate::math::Real,
+    bevy::platform::collections::HashMap,
+};
+
+use bevy::prelude::*;
+
+use bevy::platform::collections::HashSet;
+use rapier::geometry::Shape;
+use rapier::prelude::{
+    ColliderHandle, InteractionGroups, InteractionTestMode as RapierInteractionTestMode,
+    SharedShape,
+};
+
+use crate::dynamics::{CoefficientCombineRule, MassProperties};
+use crate::math::Vect;
+
+#[cfg(doc)]
+use rapier::{dynamics::RigidBody, geometry::ContactForceEvent};
+
+/// The Rapier handle of a collider that was inserted to the physics scene.
+#[derive(Copy, Clone, Debug, Component)]
+pub struct RapierColliderHandle(pub ColliderHandle);
+
+/// A component which will be replaced by the specified collider type after the referenced mesh become available.
+#[cfg(all(feature = "dim3", feature = "async-collider"))]
+#[derive(Component, Debug, Clone, Default)]
+pub struct AsyncCollider(pub ComputedColliderShape);
+
+/// A component which will be replaced the specified collider types on children with meshes after the referenced scene become available.
+#[cfg(all(feature = "dim3", feature = "async-collider"))]
+#[derive(Component, Debug, Clone)]
+pub struct AsyncSceneCollider {
+    /// Collider type for each scene mesh not included in [`Self::named_shapes`]. If [`None`], then all
+    /// shapes will be skipped for processing except [`Self::named_shapes`].
+    pub shape: Option<ComputedColliderShape>,
+    /// Shape types for meshes by name. If shape is [`None`], then it will be skipped for
+    /// processing.
+    pub named_shapes: HashMap<String, Option<ComputedColliderShape>>,
+}
+
+#[cfg(all(feature = "dim3", feature = "async-collider"))]
+impl Default for AsyncSceneCollider {
+    fn default() -> Self {
+        Self {
+            shape: Some(Default::default()),
+            named_shapes: Default::default(),
+        }
+    }
+}
+
+/// Shape type based on a Bevy mesh asset.
+#[cfg(all(feature = "dim3", feature = "async-collider"))]
+#[derive(Debug, Clone)]
+pub enum ComputedColliderShape {
+    /// Triangle-mesh.
+    TriMesh(TriMeshFlags),
+    /// Convex hull.
+    ConvexHull,
+    /// Convex decomposition.
+    ConvexDecomposition(VHACDParameters),
+    /// Voxelization of the mesh (see [`Collider::voxelized_mesh`]).
+    Voxels {
+        /// The size of each voxel along every axis.
+        voxel_size: Real,
+        /// Controls whether only the voxels intersecting the mesh boundary are kept, or if its
+        /// interior is filled too.
+        fill_mode: FillMode,
+    },
+    /// Shape obtained by converting the mesh with the given [`MeshConverter`] (see
+    /// [`Collider::converted_trimesh`]).
+    Converted(MeshConverter),
+}
+
+#[cfg(all(feature = "dim3", feature = "async-collider"))]
+impl Default for ComputedColliderShape {
+    fn default() -> Self {
+        Self::TriMesh(TriMeshFlags::MERGE_DUPLICATE_VERTICES)
+    }
+}
+
+/// A geometric entity that can be attached to a [`RigidBody`] so it can be affected by contacts
+/// and intersection queries.
+///
+/// Related components:
+/// - [`ColliderMassProperties`]
+/// - [`ReadColliderMassProperties`]
+/// - [`Friction`]
+/// - [`Restitution`]
+/// - [`Sensor`]
+/// - [`CollisionGroups`]
+/// - [`SolverGroups`]
+/// - [`ActiveCollisionTypes`]
+/// - [`ActiveEvents`]
+/// - [`ContactForceEventThreshold`]
+/// - [`CollidingEntities`]
+/// - [`ColliderScale`]
+/// - [`ColliderDisabled`]
+#[derive(Component, Clone)] // TODO: Reflect
+#[cfg_attr(feature = "serde-serialize", derive(Serialize, Deserialize))]
+#[require(ReadColliderMassProperties)]
+pub struct Collider {
+    /// The raw shape from Rapier.
+    pub raw: SharedShape,
+    pub(crate) unscaled: SharedShape,
+    pub(crate) scale: Vect,
+}
+
+impl From<SharedShape> for Collider {
+    fn from(shared_shape: SharedShape) -> Collider {
+        Collider {
+            raw: shared_shape.clone(),
+            unscaled: shared_shape,
+            scale: Vect::ONE,
+        }
+    }
+}
+
+impl<'a> From<&'a Collider> for &'a dyn Shape {
+    fn from(collider: &'a Collider) -> &'a dyn Shape {
+        &*collider.raw
+    }
+}
+
+/// A shape accepted by the scene queries (e.g. [`RapierContext::cast_shape`]) and by
+/// [`RapierContextMut::move_shape`]: a [`Collider`] (its scaled shape), a Rapier shape trait object
+/// (`&dyn Shape`, e.g. `&*shared_shape`), or any concrete Rapier shape (e.g. `Ball`).
+///
+/// [`RapierContext::cast_shape`]: crate::plugin::context::systemparams::RapierContext::cast_shape
+/// [`RapierContextMut::move_shape`]: crate::plugin::context::systemparams::RapierContextMut::move_shape
+pub trait AsShape {
+    /// The shape used by the query.
+    fn as_shape(&self) -> &dyn Shape;
+}
+
+impl AsShape for Collider {
+    fn as_shape(&self) -> &dyn Shape {
+        &*self.raw
+    }
+}
+
+impl AsShape for dyn Shape {
+    fn as_shape(&self) -> &dyn Shape {
+        self
+    }
+}
+
+impl<S: Shape> AsShape for S {
+    fn as_shape(&self) -> &dyn Shape {
+        self
+    }
+}
+
+impl fmt::Debug for Collider {
+    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+        self.as_typed_shape().fmt(f)
+    }
+}
+
+/// Overwrites the default application of [`GlobalTransform`] scale to a [`Collider`]'s shapes.
+#[derive(Copy, Clone, Debug, PartialEq, Component, Reflect)]
+pub enum ColliderScale {
+    /// This scale will be multiplied with the scale in the [`GlobalTransform`] component
+    /// before being applied to the collider.
+    Relative(Vect),
+    /// This scale will replace the one specified in the [`GlobalTransform`] component.
+    Absolute(Vect),
+}
+
+/// Indicates whether or not the [`Collider`] is a sensor.
+#[derive(Copy, Clone, Default, Debug, PartialEq, Eq, Component, Reflect)]
+#[reflect(Component, Default, PartialEq)]
+pub struct Sensor;
+
+/// Custom mass-properties of a [`Collider`].
+#[derive(Copy, Clone, Debug, PartialEq, Component, Reflect)]
+#[reflect(Component, Default, PartialEq)]
+pub enum ColliderMassProperties {
+    /// The mass-properties are computed automatically from the collider’s shape and this density.
+    Density(f32),
+    /// The mass-properties are computed automatically from the collider’s shape and this mass.
+    Mass(f32),
+    /// The mass-properties of the collider are replaced by the ones specified here.
+    MassProperties(MassProperties),
+}
+
+impl Default for ColliderMassProperties {
+    fn default() -> Self {
+        Self::Density(1.0)
+    }
+}
+
+/// The mass-related properties of a [`Collider`], as computed by Rapier.
+///
+/// This component is inserted automatically with [`Collider`], and updated whenever the collider
+/// is created or its shape or [`ColliderMassProperties`] change. Modifying this component has no
+/// effect on the simulation; modify [`ColliderMassProperties`] instead.
+#[derive(Copy, Clone, Debug, Default, PartialEq, Component, Reflect)]
+#[reflect(Component, Default, PartialEq)]
+pub struct ReadColliderMassProperties {
+    /// The volume (in 3D) or area (in 2D) of the collider's shape.
+    pub volume: f32,
+    /// The density of the collider.
+    ///
+    /// If the collider's mass was set explicitly, this is the mass divided by the volume.
+    pub density: f32,
+    /// The mass of the collider.
+    pub mass: f32,
+    /// The mass properties of the collider, expressed in the collider's local-space.
+    pub local_mass_properties: MassProperties,
+}
+
+impl ReadColliderMassProperties {
+    /// Extracts the mass-related properties of a Rapier collider.
+    pub fn from_rapier(collider: &rapier::geometry::Collider) -> Self {
+        Self {
+            volume: collider.volume(),
+            density: collider.density(),
+            mass: collider.mass(),
+            local_mass_properties: MassProperties::from_rapier(collider.mass_properties()),
+        }
+    }
+}
+
+/// The friction affecting a [`Collider`].
+#[derive(Copy, Clone, Debug, PartialEq, Component, Reflect)]
+#[reflect(Component, Default, PartialEq)]
+pub struct Friction {
+    /// The friction coefficient of a collider.
+    ///
+    /// The greater the value, the stronger the friction forces will be.
+    /// Should be `>= 0`.
+    pub coefficient: f32,
+    /// The rule applied to combine the friction coefficients of two colliders in contact.
+    pub combine_rule: CoefficientCombineRule,
+}
+
+impl Default for Friction {
+    fn default() -> Self {
+        Self {
+            coefficient: 0.5,
+            combine_rule: CoefficientCombineRule::Average,
+        }
+    }
+}
+
+impl Friction {
+    /// Creates a [`Friction`] component from the given friction coefficient, and using the default
+    /// [`CoefficientCombineRule::Average`] coefficient combine rule.
+    pub const fn new(coefficient: f32) -> Self {
+        Self {
+            coefficient,
+            combine_rule: CoefficientCombineRule::Average,
+        }
+    }
+
+    /// Creates a [`Friction`] component from the given friction coefficient, and using the default
+    /// [`CoefficientCombineRule::Average`] coefficient combine rule.
+    pub const fn coefficient(coefficient: f32) -> Self {
+        Self {
+            coefficient,
+            combine_rule: CoefficientCombineRule::Average,
+        }
+    }
+}
+
+/// The restitution affecting a [`Collider`].
+#[derive(Copy, Clone, Debug, PartialEq, Component, Reflect)]
+#[reflect(Component, Default, PartialEq)]
+pub struct Restitution {
+    /// The restitution coefficient of a collider.
+    ///
+    /// The greater the value, the stronger the restitution forces will be.
+    /// Should be `>= 0`.
+    pub coefficient: f32,
+    /// The rule applied to combine the friction coefficients of two colliders in contact.
+    pub combine_rule: CoefficientCombineRule,
+}
+
+impl Restitution {
+    /// Creates a [`Restitution`] component from the given restitution coefficient, and using the default
+    /// [`CoefficientCombineRule::Average`] coefficient combine rule.
+    pub const fn new(coefficient: f32) -> Self {
+        Self {
+            coefficient,
+            combine_rule: CoefficientCombineRule::Average,
+        }
+    }
+
+    /// Creates a [`Restitution`] component from the given restitution coefficient, and using the default
+    /// [`CoefficientCombineRule::Average`] coefficient combine rule.
+    pub const fn coefficient(coefficient: f32) -> Self {
+        Self {
+            coefficient,
+            combine_rule: CoefficientCombineRule::Average,
+        }
+    }
+}
+
+impl Default for Restitution {
+    fn default() -> Self {
+        Self {
+            coefficient: 0.0,
+            combine_rule: CoefficientCombineRule::Average,
+        }
+    }
+}
+
+#[derive(Component, Reflect, Debug, Copy, Clone, Ord, PartialOrd, Eq, PartialEq, Hash)]
+#[reflect(Component, Default, Hash, PartialEq)]
+#[cfg_attr(feature = "serde-serialize", derive(Serialize, Deserialize))]
+/// Flags affecting whether or not collision-detection happens between two colliders
+/// depending on the type of rigid-bodies they are attached to.
+pub struct ActiveCollisionTypes(u16);
+
+bitflags::bitflags! {
+    impl ActiveCollisionTypes: u16 {
+        /// Enable collision-detection between a collider attached to a dynamic body
+        /// and another collider attached to a dynamic body.
+        const DYNAMIC_DYNAMIC = 0b0000_0000_0000_0001;
+        /// Enable collision-detection between a collider attached to a dynamic body
+        /// and another collider attached to a kinematic body.
+        const DYNAMIC_KINEMATIC = 0b0000_0000_0000_1100;
+        /// Enable collision-detection between a collider attached to a dynamic body
+        /// and another collider attached to a fixed body (or not attached to any body).
+        const DYNAMIC_STATIC  = 0b0000_0000_0000_0010;
+        /// Enable collision-detection between a collider attached to a kinematic body
+        /// and another collider attached to a kinematic body.
+        const KINEMATIC_KINEMATIC = 0b1100_1100_0000_0000;
+
+        /// Enable collision-detection between a collider attached to a kinematic body
+        /// and another collider attached to a fixed body (or not attached to any body).
+        const KINEMATIC_STATIC = 0b0010_0010_0000_0000;
+
+        /// Enable collision-detection between a collider attached to a fixed body (or
+        /// not attached to any body) and another collider attached to a fixed body (or
+        /// not attached to any body).
+        const STATIC_STATIC = 0b0000_0000_0010_0000;
+    }
+}
+
+impl Default for ActiveCollisionTypes {
+    fn default() -> Self {
+        Self::DYNAMIC_DYNAMIC | Self::DYNAMIC_KINEMATIC | Self::DYNAMIC_STATIC
+    }
+}
+
+impl From<ActiveCollisionTypes> for rapier::geometry::ActiveCollisionTypes {
+    fn from(collision_types: ActiveCollisionTypes) -> rapier::geometry::ActiveCollisionTypes {
+        rapier::geometry::ActiveCollisionTypes::from_bits(collision_types.bits())
+            .expect("Internal error: invalid active events conversion.")
+    }
+}
+
+/// A bit mask identifying groups for interaction.
+#[derive(Component, Reflect, Copy, Clone, Debug, PartialEq, Eq, Hash)]
+#[reflect(Component, Default, Hash, PartialEq)]
+#[cfg_attr(feature = "serde-serialize", derive(Serialize, Deserialize))]
+pub struct Group(u32);
+
+bitflags::bitflags! {
+    impl Group: u32 {
+        /// The group n°1.
+        const GROUP_1 = 1 << 0;
+        /// The group n°2.
+        const GROUP_2 = 1 << 1;
+        /// The group n°3.
+        const GROUP_3 = 1 << 2;
+        /// The group n°4.
+        const GROUP_4 = 1 << 3;
+        /// The group n°5.
+        const GROUP_5 = 1 << 4;
+        /// The group n°6.
+        const GROUP_6 = 1 << 5;
+        /// The group n°7.
+        const GROUP_7 = 1 << 6;
+        /// The group n°8.
+        const GROUP_8 = 1 << 7;
+        /// The group n°9.
+        const GROUP_9 = 1 << 8;
+        /// The group n°10.
+        const GROUP_10 = 1 << 9;
+        /// The group n°11.
+        const GROUP_11 = 1 << 10;
+        /// The group n°12.
+        const GROUP_12 = 1 << 11;
+        /// The group n°13.
+        const GROUP_13 = 1 << 12;
+        /// The group n°14.
+        const GROUP_14 = 1 << 13;
+        /// The group n°15.
+        const GROUP_15 = 1 << 14;
+        /// The group n°16.
+        const GROUP_16 = 1 << 15;
+        /// The group n°17.
+        const GROUP_17 = 1 << 16;
+        /// The group n°18.
+        const GROUP_18 = 1 << 17;
+        /// The group n°19.
+        const GROUP_19 = 1 << 18;
+        /// The group n°20.
+        const GROUP_20 = 1 << 19;
+        /// The group n°21.
+        const GROUP_21 = 1 << 20;
+        /// The group n°22.
+        const GROUP_22 = 1 << 21;
+        /// The group n°23.
+        const GROUP_23 = 1 << 22;
+        /// The group n°24.
+        const GROUP_24 = 1 << 23;
+        /// The group n°25.
+        const GROUP_25 = 1 << 24;
+        /// The group n°26.
+        const GROUP_26 = 1 << 25;
+        /// The group n°27.
+        const GROUP_27 = 1 << 26;
+        /// The group n°28.
+        const GROUP_28 = 1 << 27;
+        /// The group n°29.
+        const GROUP_29 = 1 << 28;
+        /// The group n°30.
+        const GROUP_30 = 1 << 29;
+        /// The group n°31.
+        const GROUP_31 = 1 << 30;
+        /// The group n°32.
+        const GROUP_32 = 1 << 31;
+
+        /// All of the groups.
+        const ALL = u32::MAX;
+        /// None of the groups.
+        const NONE = 0;
+    }
+}
+
+impl Default for Group {
+    fn default() -> Self {
+        Group::ALL
+    }
+}
+
+/// Specifies how the memberships and filters of two [`CollisionGroups`] (or two
+/// [`SolverGroups`]) are tested against each other.
+///
+/// If the two groups being tested have different test modes, [`InteractionTestMode::And`]
+/// takes priority.
+#[derive(Copy, Clone, Debug, Default, PartialEq, Eq, Hash, Reflect)]
+#[reflect(Default, Hash, PartialEq)]
+#[cfg_attr(feature = "serde-serialize", derive(Serialize, Deserialize))]
+pub enum InteractionTestMode {
+    /// An interaction is allowed iff. the memberships of each group have at least one bit in
+    /// common with the filters of the other group.
+    #[default]
+    And,
+    /// An interaction is allowed iff. the memberships of either group have at least one bit in
+    /// common with the filters of the other group.
+    ///
+    /// This only applies if both groups use [`InteractionTestMode::Or`]; otherwise
+    /// [`InteractionTestMode::And`] is used.
+    Or,
+}
+
+impl From<InteractionTestMode> for RapierInteractionTestMode {
+    fn from(mode: InteractionTestMode) -> RapierInteractionTestMode {
+        match mode {
+            InteractionTestMode::And => RapierInteractionTestMode::And,
+            InteractionTestMode::Or => RapierInteractionTestMode::Or,
+        }
+    }
+}
+
+impl From<RapierInteractionTestMode> for InteractionTestMode {
+    fn from(mode: RapierInteractionTestMode) -> InteractionTestMode {
+        match mode {
+            RapierInteractionTestMode::And => InteractionTestMode::And,
+            RapierInteractionTestMode::Or => InteractionTestMode::Or,
+        }
+    }
+}
+
+/// Pairwise collision filtering using bit masks.
+///
+/// This filtering method is based on two 32-bit values:
+/// - The interaction groups memberships.
+/// - The interaction groups filter.
+///
+/// With the default [`InteractionTestMode::And`], an interaction is allowed between two filters
+/// `a` and `b` when two conditions are met simultaneously:
+/// - The groups membership of `a` has at least one bit set to `1` in common with the groups filter of `b`.
+/// - The groups membership of `b` has at least one bit set to `1` in common with the groups filter of `a`.
+///
+/// In other words, interactions are allowed between two filter iff. the following condition is met:
+/// ```ignore
+/// (self.memberships & rhs.filter) != 0 && (rhs.memberships & self.filter) != 0
+/// ```
+///
+/// If both filters use [`InteractionTestMode::Or`], meeting either condition is sufficient.
+#[derive(Copy, Clone, Debug, Default, PartialEq, Eq, Hash, Component, Reflect)]
+#[reflect(Component, Default, Hash, PartialEq)]
+#[cfg_attr(feature = "serde-serialize", derive(Serialize, Deserialize))]
+pub struct CollisionGroups {
+    /// Groups memberships.
+    pub memberships: Group,
+    /// Groups filter.
+    pub filters: Group,
+    /// How the memberships and filters are tested against another [`CollisionGroups`].
+    #[cfg_attr(feature = "serde-serialize", serde(default))]
+    pub test_mode: InteractionTestMode,
+}
+
+impl CollisionGroups {
+    /// Creates a new collision-groups with the given membership masks and filter masks.
+    ///
+    /// The test mode is set to [`InteractionTestMode::And`].
+    pub const fn new(memberships: Group, filters: Group) -> Self {
+        Self {
+            memberships,
+            filters,
+            test_mode: InteractionTestMode::And,
+        }
+    }
+
+    /// Sets the test mode used to check interactions with another [`CollisionGroups`].
+    pub const fn with_test_mode(mut self, test_mode: InteractionTestMode) -> Self {
+        self.test_mode = test_mode;
+        self
+    }
+}
+
+impl From<CollisionGroups> for InteractionGroups {
+    fn from(collision_groups: CollisionGroups) -> InteractionGroups {
+        InteractionGroups {
+            memberships: rapier::geometry::Group::from_bits(collision_groups.memberships.bits())
+                .unwrap(),
+            filter: rapier::geometry::Group::from_bits(collision_groups.filters.bits()).unwrap(),
+            test_mode: collision_groups.test_mode.into(),
+        }
+    }
+}
+
+impl From<InteractionGroups> for CollisionGroups {
+    fn from(groups: InteractionGroups) -> CollisionGroups {
+        CollisionGroups {
+            memberships: Group::from_bits_retain(groups.memberships.bits()),
+            filters: Group::from_bits_retain(groups.filter.bits()),
+            test_mode: groups.test_mode.into(),
+        }
+    }
+}
+
+/// Pairwise constraints resolution filtering using bit masks.
+///
+/// This follows the same rules as the `CollisionGroups`.
+#[derive(Copy, Clone, Default, Debug, PartialEq, Eq, Hash, Component, Reflect)]
+#[reflect(Component, Default, Hash, PartialEq)]
+#[cfg_attr(feature = "serde-serialize", derive(Serialize, Deserialize))]
+pub struct SolverGroups {
+    /// Groups memberships.
+    pub memberships: Group,
+    /// Groups filter.
+    pub filters: Group,
+    /// How the memberships and filters are tested against another [`SolverGroups`].
+    #[cfg_attr(feature = "serde-serialize", serde(default))]
+    pub test_mode: InteractionTestMode,
+}
+
+impl SolverGroups {
+    /// Creates a new solver-groups with the given membership masks and filter masks.
+    ///
+    /// The test mode is set to [`InteractionTestMode::And`].
+    pub const fn new(memberships: Group, filters: Group) -> Self {
+        Self {
+            memberships,
+            filters,
+            test_mode: InteractionTestMode::And,
+        }
+    }
+
+    /// Sets the test mode used to check interactions with another [`SolverGroups`].
+    pub const fn with_test_mode(mut self, test_mode: InteractionTestMode) -> Self {
+        self.test_mode = test_mode;
+        self
+    }
+}
+
+impl From<SolverGroups> for InteractionGroups {
+    fn from(solver_groups: SolverGroups) -> InteractionGroups {
+        InteractionGroups {
+            memberships: rapier::geometry::Group::from_bits(solver_groups.memberships.bits())
+                .unwrap(),
+            filter: rapier::geometry::Group::from_bits(solver_groups.filters.bits()).unwrap(),
+            test_mode: solver_groups.test_mode.into(),
+        }
+    }
+}
+
+impl From<InteractionGroups> for SolverGroups {
+    fn from(groups: InteractionGroups) -> SolverGroups {
+        SolverGroups {
+            memberships: Group::from_bits_retain(groups.memberships.bits()),
+            filters: Group::from_bits_retain(groups.filter.bits()),
+            test_mode: groups.test_mode.into(),
+        }
+    }
+}
+
+#[derive(Default, Component, Reflect, Debug, Copy, Clone, Ord, PartialOrd, Eq, PartialEq, Hash)]
+#[reflect(Component, Default)]
+#[cfg_attr(feature = "serde-serialize", derive(Serialize, Deserialize))]
+/// Flags affecting the behavior of the constraints solver for a given contact manifold.
+pub struct ActiveHooks(u32);
+
+bitflags::bitflags! {
+    impl ActiveHooks: u32 {
+        /// If set, Rapier will call `PhysicsHooks::filter_contact_pair` whenever relevant.
+        const FILTER_CONTACT_PAIRS = 0b0001;
+        /// If set, Rapier will call `PhysicsHooks::filter_intersection_pair` whenever relevant.
+        const FILTER_INTERSECTION_PAIR = 0b0010;
+        /// If set, Rapier will call `PhysicsHooks::modify_solver_contact` whenever relevant.
+        const MODIFY_SOLVER_CONTACTS = 0b0100;
+    }
+}
+
+impl From<ActiveHooks> for rapier::pipeline::ActiveHooks {
+    fn from(active_hooks: ActiveHooks) -> rapier::pipeline::ActiveHooks {
+        rapier::pipeline::ActiveHooks::from_bits(active_hooks.bits())
+            .expect("Internal error: invalid active events conversion.")
+    }
+}
+
+#[derive(Default, Component, Reflect, Debug, Copy, Clone, Ord, PartialOrd, Eq, PartialEq, Hash)]
+#[reflect(Component, Default)]
+#[cfg_attr(feature = "serde-serialize", derive(Serialize, Deserialize))]
+/// Flags affecting the events generated for this [`Collider`].
+pub struct ActiveEvents(u32);
+
+bitflags::bitflags! {
+    impl ActiveEvents: u32 {
+        /// If set, Rapier will call `EventHandler::handle_collision_event`
+        /// whenever relevant for this [`Collider`].
+        const COLLISION_EVENTS = 0b0001;
+        /// If set, Rapier will call `EventHandler::handle_contact_force_event`
+        /// whenever relevant for this [`Collider`].
+        const CONTACT_FORCE_EVENTS = 0b0010;
+    }
+}
+
+impl From<ActiveEvents> for rapier::pipeline::ActiveEvents {
+    fn from(active_events: ActiveEvents) -> rapier::pipeline::ActiveEvents {
+        rapier::pipeline::ActiveEvents::from_bits(active_events.bits())
+            .expect("Internal error: invalid active events conversion.")
+    }
+}
+
+/// The total force magnitude beyond which a [`ContactForceEvent`] can be emitted.
+///
+/// This requires that the [`ActiveEvents::CONTACT_FORCE_EVENTS`] flag is set on the
+/// entity.
+#[derive(Copy, Clone, PartialEq, Component, Reflect)]
+#[reflect(Component, Default)]
+#[cfg_attr(feature = "serde-serialize", derive(Serialize, Deserialize))]
+pub struct ContactForceEventThreshold(pub f32);
+
+impl Default for ContactForceEventThreshold {
+    fn default() -> Self {
+        Self(f32::MAX)
+    }
+}
+
+/// Sets the contact skin of the collider.
+///
+/// The contact skin acts as if the collider was enlarged with a skin of width `skin_thickness`
+/// around it, keeping objects further apart when colliding.
+///
+/// A non-zero contact skin can increase performance, and in some cases, stability. However
+/// it creates a small gap between colliding object (equal to the sum of their skin). If the
+/// skin is sufficiently small, this might not be visually significant or can be hidden by the
+/// rendering assets.
+#[derive(Copy, Clone, PartialEq, Default, Component, Reflect)]
+#[reflect(Component, Default)]
+#[cfg_attr(feature = "serde-serialize", derive(Serialize, Deserialize))]
+pub struct ContactSkin(pub f32);
+
+/// Component which will be filled (if present) with a list of entities with which the current
+/// entity is currently in contact.
+///
+/// This currently only updates when on an entity with a `Collider`, and if the
+/// [`ActiveEvents::COLLISION_EVENTS`] is set on this entity or the entity it
+/// collided with.
+#[derive(Component, Default, Reflect)]
+#[reflect(Component, Default)]
+pub struct CollidingEntities(pub(crate) HashSet<Entity>);
+
+impl CollidingEntities {
+    /// Returns the number of colliding entities.
+    #[must_use]
+    pub fn len(&self) -> usize {
+        self.0.len()
+    }
+
+    /// Returns `true` if there is no colliding entities.
+    #[must_use]
+    pub fn is_empty(&self) -> bool {
+        self.0.is_empty()
+    }
+
+    /// Returns `true` if the collisions contains the specified entity.
+    #[must_use]
+    pub fn contains(&self, entity: Entity) -> bool {
+        self.0.contains(&entity)
+    }
+
+    /// An iterator visiting all colliding entities in arbitrary order.
+    pub fn iter(&self) -> impl Iterator<Item = Entity> + '_ {
+        self.0.iter().copied()
+    }
+}
+
+/// Indicates whether or not the collider is disabled explicitly by the user.
+#[derive(Copy, Clone, Default, Debug, PartialEq, Eq, Component, Reflect)]
+#[reflect(Component, Default, PartialEq)]
+pub struct ColliderDisabled;
+
+/// We restrict the scaling increment to 1.0e-4, to avoid numerical jitter
+/// due to the extraction of scaling factor from the GlobalTransform matrix.
+pub fn get_snapped_scale(scale: Vect) -> Vect {
+    fn snap_value(new: f32) -> f32 {
+        const PRECISION: f32 = 1.0e4;
+        (new * PRECISION).round() / PRECISION
+    }
+
+    Vect {
+        x: snap_value(scale.x),
+        y: snap_value(scale.y),
+        #[cfg(feature = "dim3")]
+        z: snap_value(scale.z),
+    }
+}
diff --git a/bindings/bevy_rapier/src/geometry/collider_impl.rs b/bindings/bevy_rapier/src/geometry/collider_impl.rs
new file mode 100644
index 000000000..49a2702ca
--- /dev/null
+++ b/bindings/bevy_rapier/src/geometry/collider_impl.rs
@@ -0,0 +1,1478 @@
+#[cfg(all(feature = "dim3", feature = "async-collider"))]
+use {
+    bevy::mesh::{Indices, VertexAttributeValues},
+    bevy::prelude::*,
+};
+
+use rapier::{
+    geometry::{MeshConverter, MeshConverterError},
+    math::Pose,
+    parry::shape::{Compound, Polyline},
+    parry::transformation::voxelization::FillMode,
+    prelude::{FeatureId, Ray, SharedShape, Vector, Voxels, DIM},
+};
+
+use super::{get_snapped_scale, shape_views::*};
+#[cfg(all(feature = "dim3", feature = "async-collider"))]
+use crate::geometry::ComputedColliderShape;
+#[cfg(feature = "dim3")]
+use crate::geometry::HeightFieldFlags;
+use crate::math::{Real, Rot, Vect};
+#[cfg(feature = "dim2")]
+use bevy::shape::{Aabb2d as BevyAabb, BoundingCircle as BevyBoundingSphere};
+#[cfg(feature = "dim3")]
+use bevy::shape::{Aabb3d as BevyAabb, BoundingSphere as BevyBoundingSphere};
+use rapier::parry::query;
+
+use crate::dynamics::MassProperties;
+use crate::{
+    geometry::{
+        Collider, CompoundFlags, NonlinearMotion, PointProjection, PolylineFlags, RayIntersection,
+        ShapeCastHit, ShapeCastOptions, ShapeClosestPoints, ShapeContact, TriMeshFlags,
+        Unsupported, VHACDParameters,
+    },
+    math::IVect,
+};
+
+impl Collider {
+    /// The scaling factor that was applied to this collider.
+    pub fn scale(&self) -> Vect {
+        self.scale
+    }
+
+    /// This replaces the unscaled version of this collider by its scaled version,
+    /// and resets `self.scale()` to `1.0`.
+    pub fn promote_scaled_shape(&mut self) {
+        self.unscaled = self.raw.clone();
+        self.scale = Vect::ONE;
+    }
+
+    /// Initialize a new collider with a compound shape.
+    pub fn compound(shapes: Vec<(Vect, Rot, Collider)>) -> Self {
+        let shapes = shapes
+            .into_iter()
+            .map(|(t, r, s)| (crate::utils::pose_from(t, r), s.raw))
+            .collect();
+        SharedShape::compound(shapes).into()
+    }
+
+    /// Initialize a new collider with a compound shape and flags controlling its optional
+    /// pre-processing.
+    ///
+    /// `weld_tolerance` is the distance (in ULPs) under which two corners of different parts
+    /// are considered equal when detecting internal edges; `None` selects parry's default.
+    pub fn compound_with_flags(
+        shapes: Vec<(Vect, Rot, Collider)>,
+        flags: CompoundFlags,
+        weld_tolerance: Option<Real>,
+    ) -> Self {
+        let shapes = shapes
+            .into_iter()
+            .map(|(t, r, s)| (crate::utils::pose_from(t, r), s.raw))
+            .collect();
+        SharedShape::new(Compound::with_flags(shapes, flags, weld_tolerance)).into()
+    }
+
+    /// Initialize a new collider with a ball shape defined by its radius.
+    pub fn ball(radius: Real) -> Self {
+        SharedShape::ball(radius).into()
+    }
+
+    /// Initialize a new collider build with a half-space shape defined by the outward normal
+    /// of its planar boundary.
+    pub fn halfspace(outward_normal: Vect) -> Option<Self> {
+        let normal = Vector::from(outward_normal);
+        if normal.length_squared() < 1.0e-12 {
+            return None;
+        }
+        Some(SharedShape::halfspace(normal.normalize()).into())
+    }
+
+    /// Initialize a new collider with a cylindrical shape defined by its half-height
+    /// (along the y axis) and its radius.
+    #[cfg(feature = "dim3")]
+    pub fn cylinder(half_height: Real, radius: Real) -> Self {
+        SharedShape::cylinder(half_height, radius).into()
+    }
+
+    /// Initialize a new collider with a rounded cylindrical shape defined by its half-height
+    /// (along the y axis), its radius, and its roundedness (the
+    /// radius of the sphere used for dilating the cylinder).
+    #[cfg(feature = "dim3")]
+    pub fn round_cylinder(half_height: Real, radius: Real, border_radius: Real) -> Self {
+        SharedShape::round_cylinder(half_height, radius, border_radius).into()
+    }
+
+    /// Initialize a new collider with a cone shape defined by its half-height
+    /// (along the y axis) and its basis radius.
+    #[cfg(feature = "dim3")]
+    pub fn cone(half_height: Real, radius: Real) -> Self {
+        SharedShape::cone(half_height, radius).into()
+    }
+
+    /// Initialize a new collider with a rounded cone shape defined by its half-height
+    /// (along the y axis), its radius, and its roundedness (the
+    /// radius of the sphere used for dilating the cylinder).
+    #[cfg(feature = "dim3")]
+    pub fn round_cone(half_height: Real, radius: Real, border_radius: Real) -> Self {
+        SharedShape::round_cone(half_height, radius, border_radius).into()
+    }
+
+    /// Initialize a new collider with a cuboid shape defined by its half-extents.
+    #[cfg(feature = "dim2")]
+    pub fn cuboid(half_x: Real, half_y: Real) -> Self {
+        SharedShape::cuboid(half_x, half_y).into()
+    }
+
+    /// Initialize a new collider with a round cuboid shape defined by its half-extents
+    /// and border radius.
+    #[cfg(feature = "dim2")]
+    pub fn round_cuboid(half_x: Real, half_y: Real, border_radius: Real) -> Self {
+        SharedShape::round_cuboid(half_x, half_y, border_radius).into()
+    }
+
+    /// Initialize a new collider with a capsule shape.
+    pub fn capsule(start: Vect, end: Vect, radius: Real) -> Self {
+        SharedShape::capsule(start, end, radius).into()
+    }
+
+    /// Initialize a new collider with a capsule shape aligned with the `x` axis.
+    pub fn capsule_x(half_height: Real, radius: Real) -> Self {
+        let p = Vector::X * half_height;
+        SharedShape::capsule(-p, p, radius).into()
+    }
+
+    /// Initialize a new collider with a capsule shape aligned with the `y` axis.
+    pub fn capsule_y(half_height: Real, radius: Real) -> Self {
+        let p = Vector::Y * half_height;
+        SharedShape::capsule(-p, p, radius).into()
+    }
+
+    /// Initialize a new collider with a capsule shape aligned with the `z` axis.
+    #[cfg(feature = "dim3")]
+    pub fn capsule_z(half_height: Real, radius: Real) -> Self {
+        let p = Vector::Z * half_height;
+        SharedShape::capsule(-p, p, radius).into()
+    }
+
+    /// Initialize a new collider with a cuboid shape defined by its half-extents.
+    #[cfg(feature = "dim3")]
+    pub fn cuboid(hx: Real, hy: Real, hz: Real) -> Self {
+        SharedShape::cuboid(hx, hy, hz).into()
+    }
+
+    /// Initialize a new collider with a round cuboid shape defined by its half-extents
+    /// and border radius.
+    #[cfg(feature = "dim3")]
+    pub fn round_cuboid(half_x: Real, half_y: Real, half_z: Real, border_radius: Real) -> Self {
+        SharedShape::round_cuboid(half_x, half_y, half_z, border_radius).into()
+    }
+
+    /// Initializes a collider with a segment shape.
+    pub fn segment(a: Vect, b: Vect) -> Self {
+        SharedShape::segment(a, b).into()
+    }
+
+    /// Initializes a collider with a triangle shape.
+    pub fn triangle(a: Vect, b: Vect, c: Vect) -> Self {
+        SharedShape::triangle(a, b, c).into()
+    }
+
+    /// Initializes a collider with a triangle shape with round corners.
+    pub fn round_triangle(a: Vect, b: Vect, c: Vect, border_radius: Real) -> Self {
+        SharedShape::round_triangle(a, b, c, border_radius).into()
+    }
+
+    fn ivec_array_from_point_int_array(points: &[IVect]) -> Vec<IVect> {
+        points.to_vec()
+    }
+
+    fn vec_array_from_point_float_array(points: &[Vect]) -> Vec<Vect> {
+        points.to_vec()
+    }
+
+    /// Initializes a shape made of voxels.
+    ///
+    /// Each voxel has the size `voxel_size` and grid coordinate given by `grid_coords`.
+    /// The `primitive_geometry` controls the behavior of collision detection at voxels boundaries.
+    ///
+    /// For initializing a voxels shape from points in space, see [`Self::voxels_from_points`].
+    /// For initializing a voxels shape from a mesh to voxelize, see [`Self::voxelized_mesh`].
+    /// For initializing multiple voxels shape from the convex decomposition of a mesh, see
+    /// [`Self::voxelized_convex_decomposition`].
+    pub fn voxels(voxel_size: Vect, grid_coordinates: &[IVect]) -> Self {
+        let shape = Voxels::new(
+            voxel_size,
+            &Self::ivec_array_from_point_int_array(grid_coordinates),
+        );
+        SharedShape::new(shape).into()
+    }
+
+    /// Initializes a shape made of voxels.
+    ///
+    /// Each voxel has the size `voxel_size` and contains at least one point from `centers`.
+    /// The `primitive_geometry` controls the behavior of collision detection at voxels boundaries.
+    pub fn voxels_from_points(voxel_size: Vect, points: &[Vect]) -> Self {
+        SharedShape::voxels_from_points(voxel_size, &Self::vec_array_from_point_float_array(points))
+            .into()
+    }
+
+    /// Initializes a voxels shape obtained from the decomposition of the given trimesh (in 3D)
+    /// or polyline (in 2D) into voxelized convex parts.
+    pub fn voxelized_mesh(
+        vertices: &[Vect],
+        indices: &[[u32; DIM]],
+        voxel_size: Real,
+        fill_mode: FillMode,
+    ) -> Self {
+        let vertices = Self::vec_array_from_point_float_array(vertices);
+        SharedShape::voxelized_mesh(&vertices, indices, voxel_size, fill_mode).into()
+    }
+
+    /// Initializes a compound shape obtained from the decomposition of the given trimesh (in 3D)
+    /// or polyline (in 2D) into voxelized convex parts.
+    pub fn voxelized_convex_decomposition(vertices: &[Vect], indices: &[[u32; DIM]]) -> Vec<Self> {
+        Self::voxelized_convex_decomposition_with_params(
+            vertices,
+            indices,
+            &VHACDParameters::default(),
+        )
+    }
+
+    /// Initializes a compound shape obtained from the decomposition of the given trimesh (in 3D)
+    /// or polyline (in 2D) into voxelized convex parts.
+    pub fn voxelized_convex_decomposition_with_params(
+        vertices: &[Vect],
+        indices: &[[u32; DIM]],
+        params: &VHACDParameters,
+    ) -> Vec<Self> {
+        SharedShape::voxelized_convex_decomposition_with_params(
+            &Self::vec_array_from_point_float_array(vertices),
+            indices,
+            params,
+        )
+        .into_iter()
+        .map(|c| c.into())
+        .collect()
+    }
+
+    /// Initializes a collider with a polyline shape defined by its vertex and index buffers.
+    pub fn polyline(vertices: Vec<Vect>, indices: Option<Vec<[u32; 2]>>) -> Self {
+        let vertices = vertices.into_iter().collect();
+        SharedShape::polyline(vertices, indices).into()
+    }
+
+    /// Initializes a collider with a polyline shape defined by its vertex and index buffers, and
+    /// flags controlling its optional associated data (orientation, deformability).
+    pub fn polyline_with_flags(
+        vertices: Vec<Vect>,
+        indices: Option<Vec<[u32; 2]>>,
+        flags: PolylineFlags,
+    ) -> Self {
+        SharedShape::new(Polyline::with_flags(vertices, indices, flags)).into()
+    }
+
+    /// Initializes a collider with a one-sided (oriented) polyline shape.
+    ///
+    /// The segments only collide from their outward side, which is on the right of each
+    /// segment's direction: a counter-clockwise loop has a solid interior.
+    #[cfg(feature = "dim2")]
+    pub fn oriented_polyline(vertices: Vec<Vect>, indices: Option<Vec<[u32; 2]>>) -> Self {
+        Self::polyline_with_flags(vertices, indices, PolylineFlags::ORIENTED)
+    }
+
+    /// Initializes a collider with a triangle mesh shape defined by its vertex and index buffers.
+    pub fn trimesh(
+        vertices: Vec<Vect>,
+        indices: Vec<[u32; 3]>,
+    ) -> Result<Self, crate::rapier::prelude::TriMeshBuilderError> {
+        let vertices = vertices.into_iter().collect();
+        Ok(SharedShape::trimesh(vertices, indices)?.into())
+    }
+
+    /// Initializes a collider with a triangle mesh shape defined by its vertex and index buffers, and flags
+    /// controlling its pre-processing.
+    pub fn trimesh_with_flags(
+        vertices: Vec<Vect>,
+        indices: Vec<[u32; 3]>,
+        flags: TriMeshFlags,
+    ) -> Result<Self, crate::rapier::prelude::TriMeshBuilderError> {
+        let vertices = vertices.into_iter().collect();
+        Ok(SharedShape::trimesh_with_flags(vertices, indices, flags)?.into())
+    }
+
+    /// Initializes a collider with a shape converted from the given triangle mesh vertex and
+    /// index buffers, following the conversion rule described by `converter`.
+    ///
+    /// Conversions yielding a shape offset from the mesh origin ([`MeshConverter::Obb`] and
+    /// [`MeshConverter::Aabb`]) are wrapped into a single-part compound shape to keep that offset.
+    pub fn converted_trimesh(
+        vertices: Vec<Vect>,
+        indices: Vec<[u32; 3]>,
+        converter: MeshConverter,
+    ) -> Result<Self, MeshConverterError> {
+        let (shape, pose) = converter.convert(vertices, indices)?;
+        if pose == Pose::IDENTITY {
+            Ok(shape.into())
+        } else {
+            Ok(SharedShape::compound(vec![(pose, shape)]).into())
+        }
+    }
+
+    /// Initializes a collider with a Bevy Mesh.
+    ///
+    /// Returns `None` if the index buffer or vertex buffer of the mesh are in an incompatible format,
+    /// or if the shape computation failed.
+    #[cfg(all(feature = "dim3", feature = "async-collider"))]
+    pub fn from_bevy_mesh(mesh: &Mesh, collider_shape: &ComputedColliderShape) -> Option<Self> {
+        let (vtx, idx) = extract_mesh_vertices_indices(mesh)?;
+
+        match collider_shape {
+            ComputedColliderShape::TriMesh(flags) => Some(
+                SharedShape::trimesh_with_flags(vtx, idx, *flags)
+                    .ok()?
+                    .into(),
+            ),
+            ComputedColliderShape::ConvexHull => {
+                SharedShape::convex_hull(&vtx).map(|shape| shape.into())
+            }
+            ComputedColliderShape::ConvexDecomposition(params) => {
+                Some(SharedShape::convex_decomposition_with_params(&vtx, &idx, params).into())
+            }
+            ComputedColliderShape::Voxels {
+                voxel_size,
+                fill_mode,
+            } => Some(Self::voxelized_mesh(&vtx, &idx, *voxel_size, *fill_mode)),
+            ComputedColliderShape::Converted(converter) => {
+                Self::converted_trimesh(vtx, idx, *converter).ok()
+            }
+        }
+    }
+
+    /// Initializes a collider with a compound shape obtained from the decomposition of
+    /// the given trimesh (in 3D) or polyline (in 2D) into convex parts.
+    pub fn convex_decomposition(vertices: &[Vect], indices: &[[u32; DIM]]) -> Self {
+        let vertices: Vec<_> = vertices.to_vec();
+        SharedShape::convex_decomposition(&vertices, indices).into()
+    }
+
+    /// Initializes a collider with a compound shape obtained from the decomposition of
+    /// the given trimesh (in 3D) or polyline (in 2D) into convex parts dilated with round corners.
+    pub fn round_convex_decomposition(
+        vertices: &[Vect],
+        indices: &[[u32; DIM]],
+        border_radius: Real,
+    ) -> Self {
+        let vertices: Vec<_> = vertices.to_vec();
+        SharedShape::round_convex_decomposition(&vertices, indices, border_radius).into()
+    }
+
+    /// Initializes a collider with a compound shape obtained from the decomposition of
+    /// the given trimesh (in 3D) or polyline (in 2D) into convex parts.
+    pub fn convex_decomposition_with_params(
+        vertices: &[Vect],
+        indices: &[[u32; DIM]],
+        params: &VHACDParameters,
+    ) -> Self {
+        let vertices: Vec<_> = vertices.to_vec();
+        SharedShape::convex_decomposition_with_params(&vertices, indices, params).into()
+    }
+
+    /// Initializes a collider with a compound shape obtained from the decomposition of
+    /// the given trimesh (in 3D) or polyline (in 2D) into convex parts dilated with round corners.
+    pub fn round_convex_decomposition_with_params(
+        vertices: &[Vect],
+        indices: &[[u32; DIM]],
+        params: &VHACDParameters,
+        border_radius: Real,
+    ) -> Self {
+        let vertices: Vec<_> = vertices.to_vec();
+        SharedShape::round_convex_decomposition_with_params(
+            &vertices,
+            indices,
+            params,
+            border_radius,
+        )
+        .into()
+    }
+
+    /// Initializes a new collider with a 2D convex polygon or 3D convex polyhedron
+    /// obtained after computing the convex-hull of the given points.
+    pub fn convex_hull(points: &[Vect]) -> Option<Self> {
+        let points: Vec<_> = points.to_vec();
+        SharedShape::convex_hull(&points).map(Into::into)
+    }
+
+    /// Initializes a new collider with a round 2D convex polygon or 3D convex polyhedron
+    /// obtained after computing the convex-hull of the given points. The shape is dilated
+    /// by a sphere of radius `border_radius`.
+    pub fn round_convex_hull(points: &[Vect], border_radius: Real) -> Option<Self> {
+        let points: Vec<_> = points.to_vec();
+        SharedShape::round_convex_hull(&points, border_radius).map(Into::into)
+    }
+
+    /// Creates a new collider that is a convex polygon formed by the
+    /// given polyline assumed to be convex (no convex-hull will be automatically
+    /// computed).
+    #[cfg(feature = "dim2")]
+    pub fn convex_polyline(points: Vec<Vect>) -> Option<Self> {
+        SharedShape::convex_polyline(points).map(Into::into)
+    }
+
+    /// Creates a new collider that is a convex polygon formed by the given polyline assumed
+    /// to be convex and counter-clockwise.
+    ///
+    /// Unlike [`Self::convex_polyline`], no point is removed from the input even if some are
+    /// collinear. Returns `None` if `points` contains less than three points.
+    #[cfg(feature = "dim2")]
+    pub fn convex_polyline_unmodified(points: Vec<Vect>) -> Option<Self> {
+        SharedShape::convex_polyline_unmodified(points).map(Into::into)
+    }
+
+    /// Creates a new collider that is a round convex polygon formed by the
+    /// given polyline assumed to be convex (no convex-hull will be automatically
+    /// computed). The polygon shape is dilated by a sphere of radius `border_radius`.
+    #[cfg(feature = "dim2")]
+    pub fn round_convex_polyline(points: Vec<Vect>, border_radius: Real) -> Option<Self> {
+        SharedShape::round_convex_polyline(points, border_radius).map(Into::into)
+    }
+
+    /// Creates a new collider that is a convex polyhedron formed by the
+    /// given triangle-mesh assumed to be convex (no convex-hull will be automatically
+    /// computed).
+    #[cfg(feature = "dim3")]
+    pub fn convex_mesh(points: Vec<Vect>, indices: &[[u32; 3]]) -> Option<Self> {
+        let points = points.into_iter().collect();
+        SharedShape::convex_mesh(points, indices).map(Into::into)
+    }
+
+    /// Creates a new collider that is a round convex polyhedron formed by the
+    /// given triangle-mesh assumed to be convex (no convex-hull will be automatically
+    /// computed). The triangle mesh shape is dilated by a sphere of radius `border_radius`.
+    #[cfg(feature = "dim3")]
+    pub fn round_convex_mesh(
+        points: Vec<Vect>,
+        indices: &[[u32; 3]],
+        border_radius: Real,
+    ) -> Option<Self> {
+        let points = points.into_iter().collect();
+        SharedShape::round_convex_mesh(points, indices, border_radius).map(Into::into)
+    }
+
+    /// Initializes a collider with a heightfield shape defined by its set of height and a scale
+    /// factor along each coordinate axis.
+    #[cfg(feature = "dim2")]
+    pub fn heightfield(heights: Vec<Real>, scale: Vect) -> Self {
+        SharedShape::heightfield(heights, scale).into()
+    }
+
+    /// Initializes a collider with a heightfield shape defined by its set of height (in
+    /// column-major format) and a scale factor along each coordinate axis.
+    #[cfg(feature = "dim3")]
+    pub fn heightfield(heights: Vec<Real>, num_rows: usize, num_cols: usize, scale: Vect) -> Self {
+        assert_eq!(
+            heights.len(),
+            num_rows * num_cols,
+            "Invalid number of heights provided."
+        );
+        let heights = rapier::parry::utils::Array2::new(num_rows, num_cols, heights);
+        SharedShape::heightfield(heights, scale).into()
+    }
+
+    /// Initializes a collider with a heightfield shape defined by its set of height (in
+    /// column-major format), a scale factor along each coordinate axis, and flags controlling
+    /// its contact behavior.
+    #[cfg(feature = "dim3")]
+    pub fn heightfield_with_flags(
+        heights: Vec<Real>,
+        num_rows: usize,
+        num_cols: usize,
+        scale: Vect,
+        flags: HeightFieldFlags,
+    ) -> Self {
+        assert_eq!(
+            heights.len(),
+            num_rows * num_cols,
+            "Invalid number of heights provided."
+        );
+        let heights = rapier::parry::utils::Array2::new(num_rows, num_cols, heights);
+        SharedShape::heightfield_with_flags(heights, scale, flags).into()
+    }
+
+    /// Takes a strongly typed reference of this collider.
+    pub fn as_typed_shape(&self) -> ColliderView<'_> {
+        self.raw.as_typed_shape().into()
+    }
+
+    /// Takes a strongly typed reference of the unscaled version of this collider.
+    pub fn as_unscaled_typed_shape(&self) -> ColliderView<'_> {
+        self.unscaled.as_typed_shape().into()
+    }
+
+    /// Downcast this collider to a ball, if it is one.
+    pub fn as_ball(&self) -> Option<BallView<'_>> {
+        self.raw.as_ball().map(|s| BallView { raw: s })
+    }
+
+    /// Downcast this collider to a cuboid, if it is one.
+    pub fn as_cuboid(&self) -> Option<CuboidView<'_>> {
+        self.raw.as_cuboid().map(|s| CuboidView { raw: s })
+    }
+
+    /// Downcast this collider to a capsule, if it is one.
+    pub fn as_capsule(&self) -> Option<CapsuleView<'_>> {
+        self.raw.as_capsule().map(|s| CapsuleView { raw: s })
+    }
+
+    /// Downcast this collider to a segment, if it is one.
+    pub fn as_segment(&self) -> Option<SegmentView<'_>> {
+        self.raw.as_segment().map(|s| SegmentView { raw: s })
+    }
+
+    /// Downcast this collider to a triangle, if it is one.
+    pub fn as_triangle(&self) -> Option<TriangleView<'_>> {
+        self.raw.as_triangle().map(|s| TriangleView { raw: s })
+    }
+
+    /// Downcast this collider to a voxels, if it is one.
+    pub fn as_voxels(&self) -> Option<VoxelsView<'_>> {
+        self.raw.as_voxels().map(|s| VoxelsView { raw: s })
+    }
+
+    /// Downcast this collider to a triangle mesh, if it is one.
+    pub fn as_trimesh(&self) -> Option<TriMeshView<'_>> {
+        self.raw.as_trimesh().map(|s| TriMeshView { raw: s })
+    }
+
+    /// Downcast this collider to a polyline, if it is one.
+    pub fn as_polyline(&self) -> Option<PolylineView<'_>> {
+        self.raw.as_polyline().map(|s| PolylineView { raw: s })
+    }
+
+    /// Downcast this collider to a half-space, if it is one.
+    pub fn as_halfspace(&self) -> Option<HalfSpaceView<'_>> {
+        self.raw.as_halfspace().map(|s| HalfSpaceView { raw: s })
+    }
+
+    /// Downcast this collider to a heightfield, if it is one.
+    pub fn as_heightfield(&self) -> Option<HeightFieldView<'_>> {
+        self.raw
+            .as_heightfield()
+            .map(|s| HeightFieldView { raw: s })
+    }
+
+    /// Downcast this collider to a compound shape, if it is one.
+    pub fn as_compound(&self) -> Option<CompoundView<'_>> {
+        self.raw.as_compound().map(|s| CompoundView { raw: s })
+    }
+
+    /// Downcast this collider to a convex polygon, if it is one.
+    #[cfg(feature = "dim2")]
+    pub fn as_convex_polygon(&self) -> Option<ConvexPolygonView<'_>> {
+        self.raw
+            .as_convex_polygon()
+            .map(|s| ConvexPolygonView { raw: s })
+    }
+
+    /// Downcast this collider to a convex polyhedron, if it is one.
+    #[cfg(feature = "dim3")]
+    pub fn as_convex_polyhedron(&self) -> Option<ConvexPolyhedronView<'_>> {
+        self.raw
+            .as_convex_polyhedron()
+            .map(|s| ConvexPolyhedronView { raw: s })
+    }
+
+    /// Downcast this collider to a cylinder, if it is one.
+    #[cfg(feature = "dim3")]
+    pub fn as_cylinder(&self) -> Option<CylinderView<'_>> {
+        self.raw.as_cylinder().map(|s| CylinderView { raw: s })
+    }
+
+    /// Downcast this collider to a cone, if it is one.
+    #[cfg(feature = "dim3")]
+    pub fn as_cone(&self) -> Option<ConeView<'_>> {
+        self.raw.as_cone().map(|s| ConeView { raw: s })
+    }
+
+    /// Downcast this collider to a mutable ball, if it is one.
+    pub fn as_ball_mut(&mut self) -> Option<BallViewMut<'_>> {
+        self.raw
+            .make_mut()
+            .as_ball_mut()
+            .map(|s| BallViewMut { raw: s })
+    }
+
+    /// Downcast this collider to a mutable cuboid, if it is one.
+    pub fn as_cuboid_mut(&mut self) -> Option<CuboidViewMut<'_>> {
+        self.raw
+            .make_mut()
+            .as_cuboid_mut()
+            .map(|s| CuboidViewMut { raw: s })
+    }
+
+    /// Downcast this collider to a mutable capsule, if it is one.
+    pub fn as_capsule_mut(&mut self) -> Option<CapsuleViewMut<'_>> {
+        self.raw
+            .make_mut()
+            .as_capsule_mut()
+            .map(|s| CapsuleViewMut { raw: s })
+    }
+
+    /// Downcast this collider to a mutable segment, if it is one.
+    pub fn as_segment_mut(&mut self) -> Option<SegmentViewMut<'_>> {
+        self.raw
+            .make_mut()
+            .as_segment_mut()
+            .map(|s| SegmentViewMut { raw: s })
+    }
+
+    /// Downcast this collider to a mutable triangle, if it is one.
+    pub fn as_triangle_mut(&mut self) -> Option<TriangleViewMut<'_>> {
+        self.raw
+            .make_mut()
+            .as_triangle_mut()
+            .map(|s| TriangleViewMut { raw: s })
+    }
+
+    /// Downcast this collider to a mutable voxels, if it is one.
+    pub fn as_voxels_mut(&mut self) -> Option<VoxelsViewMut<'_>> {
+        self.raw
+            .make_mut()
+            .as_voxels_mut()
+            .map(|s| VoxelsViewMut { raw: s })
+    }
+
+    /// Downcast this collider to a mutable triangle mesh, if it is one.
+    pub fn as_trimesh_mut(&mut self) -> Option<TriMeshViewMut<'_>> {
+        self.raw
+            .make_mut()
+            .as_trimesh_mut()
+            .map(|s| TriMeshViewMut { raw: s })
+    }
+
+    /// Downcast this collider to a mutable polyline, if it is one.
+    pub fn as_polyline_mut(&mut self) -> Option<PolylineViewMut<'_>> {
+        self.raw
+            .make_mut()
+            .as_polyline_mut()
+            .map(|s| PolylineViewMut { raw: s })
+    }
+
+    /// Downcast this collider to a mutable half-space, if it is one.
+    pub fn as_halfspace_mut(&mut self) -> Option<HalfSpaceViewMut<'_>> {
+        self.raw
+            .make_mut()
+            .as_halfspace_mut()
+            .map(|s| HalfSpaceViewMut { raw: s })
+    }
+
+    /// Downcast this collider to a mutable heightfield, if it is one.
+    pub fn as_heightfield_mut(&mut self) -> Option<HeightFieldViewMut<'_>> {
+        self.raw
+            .make_mut()
+            .as_heightfield_mut()
+            .map(|s| HeightFieldViewMut { raw: s })
+    }
+
+    /// Downcast this collider to a mutable compound shape, if it is one.
+    ///
+    /// Like the other mutable downcasts, this clones the shape first if it is shared with
+    /// other colliders. The parts of the compound remain shared.
+    pub fn as_compound_mut(&mut self) -> Option<CompoundViewMut<'_>> {
+        self.raw
+            .make_mut()
+            .as_compound_mut()
+            .map(|s| CompoundViewMut { raw: s })
+    }
+
+    // /// Downcast this collider to a mutable convex polygon, if it is one.
+    // #[cfg(feature = "dim2")]
+    // pub fn as_convex_polygon_mut(&mut self) -> Option<ConvexPolygonViewMut> {
+    //     self.raw.make_mut()
+    //         .as_convex_polygon_mut()
+    //         .map(|s| ConvexPolygonViewMut { raw: s })
+    // }
+
+    // /// Downcast this collider to a mutable convex polyhedron, if it is one.
+    // #[cfg(feature = "dim3")]
+    // pub fn as_convex_polyhedron_mut(&mut self) -> Option<ConvexPolyhedronViewMut> {
+    //     self.raw.make_mut()
+    //         .as_convex_polyhedron_mut()
+    //         .map(|s| ConvexPolyhedronViewMut { raw: s })
+    // }
+
+    /// Downcast this collider to a mutable cylinder, if it is one.
+    #[cfg(feature = "dim3")]
+    pub fn as_cylinder_mut(&mut self) -> Option<CylinderViewMut<'_>> {
+        self.raw
+            .make_mut()
+            .as_cylinder_mut()
+            .map(|s| CylinderViewMut { raw: s })
+    }
+
+    /// Downcast this collider to a mutable cone, if it is one.
+    #[cfg(feature = "dim3")]
+    pub fn as_cone_mut(&mut self) -> Option<ConeViewMut<'_>> {
+        self.raw
+            .make_mut()
+            .as_cone_mut()
+            .map(|s| ConeViewMut { raw: s })
+    }
+
+    /// Set the scaling factor of this shape.
+    ///
+    /// If the scaling factor is non-uniform, and the scaled shape can’t be
+    /// represented as a supported smooth shape (for example scalling a Ball
+    /// with a non-uniform scale results in an ellipse which isn’t supported),
+    /// the shape is approximated by a convex polygon/convex polyhedron using
+    /// `num_subdivisions` subdivisions.
+    pub fn set_scale(&mut self, scale: Vect, num_subdivisions: u32) {
+        let scale = get_snapped_scale(scale);
+
+        if scale == self.scale {
+            // Nothing to do.
+            return;
+        }
+
+        if scale == Vect::ONE {
+            // Trivial case.
+            self.raw = self.unscaled.clone();
+            self.scale = Vect::ONE;
+            return;
+        }
+
+        if let Some(scaled) = self
+            .as_unscaled_typed_shape()
+            .raw_scale_by(scale, num_subdivisions)
+        {
+            self.raw = scaled;
+            self.scale = scale;
+        } else {
+            log::error!("Failed to create the scaled convex hull geometry.");
+        }
+    }
+
+    /// Projects a point on `self`, unless the projection lies further than the given max distance.
+    ///
+    /// The point is assumed to be expressed in the local-space of `self`.
+    pub fn project_local_point_with_max_dist(
+        &self,
+        point: Vect,
+        solid: bool,
+        max_dist: Real,
+    ) -> Option<PointProjection> {
+        self.raw
+            .project_local_point_with_max_dist(point, solid, max_dist)
+            .map(Into::into)
+    }
+
+    /// Projects a point on `self` transformed by `m`, unless the projection lies further than the given max distance.
+    pub fn project_point_with_max_dist(
+        &self,
+        translation: Vect,
+        rotation: Rot,
+        point: Vect,
+        solid: bool,
+        max_dist: Real,
+    ) -> Option<PointProjection> {
+        let pos = crate::utils::pose_from(translation, rotation);
+        self.raw
+            .project_point_with_max_dist(&pos, point, solid, max_dist)
+            .map(Into::into)
+    }
+
+    /// Projects a point on `self`.
+    ///
+    /// The point is assumed to be expressed in the local-space of `self`.
+    pub fn project_local_point(&self, point: Vect, solid: bool) -> PointProjection {
+        self.raw.project_local_point(point, solid).into()
+    }
+
+    /// Projects a point on the boundary of `self` and returns the id of the
+    /// feature the point was projected on.
+    pub fn project_local_point_and_get_feature(&self, point: Vect) -> (PointProjection, FeatureId) {
+        let (proj, feat) = self.raw.project_local_point_and_get_feature(point);
+        (proj.into(), feat)
+    }
+
+    /// Computes the minimal distance between a point and `self`.
+    pub fn distance_to_local_point(&self, point: Vect, solid: bool) -> Real {
+        self.raw.distance_to_local_point(point, solid)
+    }
+
+    /// Tests if the given point is inside of `self`.
+    pub fn contains_local_point(&self, point: Vect) -> bool {
+        self.raw.contains_local_point(point)
+    }
+
+    /// Projects a point on `self` transformed by `m`.
+    pub fn project_point(
+        &self,
+        translation: Vect,
+        rotation: Rot,
+        point: Vect,
+        solid: bool,
+    ) -> PointProjection {
+        let pos = crate::utils::pose_from(translation, rotation);
+        self.raw.project_point(&pos, point, solid).into()
+    }
+
+    /// Computes the minimal distance between a point and `self` transformed by `m`.
+    #[inline]
+    pub fn distance_to_point(
+        &self,
+        translation: Vect,
+        rotation: Rot,
+        point: Vect,
+        solid: bool,
+    ) -> Real {
+        let pos = crate::utils::pose_from(translation, rotation);
+        self.raw.distance_to_point(&pos, point, solid)
+    }
+
+    /// Projects a point on the boundary of `self` transformed by `m` and returns the id of the
+    /// feature the point was projected on.
+    pub fn project_point_and_get_feature(
+        &self,
+        translation: Vect,
+        rotation: Rot,
+        point: Vect,
+    ) -> (PointProjection, FeatureId) {
+        let pos = crate::utils::pose_from(translation, rotation);
+        let (proj, feat) = self.raw.project_point_and_get_feature(&pos, point);
+        (proj.into(), feat)
+    }
+
+    /// Tests if the given point is inside of `self` transformed by `m`.
+    pub fn contains_point(&self, translation: Vect, rotation: Rot, point: Vect) -> bool {
+        let pos = crate::utils::pose_from(translation, rotation);
+        self.raw.contains_point(&pos, point)
+    }
+
+    /// Computes the time of impact between this transform shape and a ray.
+    pub fn cast_local_ray(
+        &self,
+        ray_origin: Vect,
+        ray_dir: Vect,
+        max_time_of_impact: Real,
+        solid: bool,
+    ) -> Option<Real> {
+        let ray = Ray::new(ray_origin, ray_dir);
+        self.raw.cast_local_ray(&ray, max_time_of_impact, solid)
+    }
+
+    /// Computes the time of impact, and normal between this transformed shape and a ray.
+    pub fn cast_local_ray_and_get_normal(
+        &self,
+        ray_origin: Vect,
+        ray_dir: Vect,
+        max_time_of_impact: Real,
+        solid: bool,
+    ) -> Option<RayIntersection> {
+        let ray = Ray::new(ray_origin, ray_dir);
+        self.raw
+            .cast_local_ray_and_get_normal(&ray, max_time_of_impact, solid)
+            .map(|inter| RayIntersection::from_rapier(inter, ray_origin, ray_dir))
+    }
+
+    /// Tests whether a ray intersects this transformed shape.
+    pub fn intersects_local_ray(
+        &self,
+        ray_origin: Vect,
+        ray_dir: Vect,
+        max_time_of_impact: Real,
+    ) -> bool {
+        let ray = Ray::new(ray_origin, ray_dir);
+        self.raw.intersects_local_ray(&ray, max_time_of_impact)
+    }
+
+    /// Computes the time of impact between this transform shape and a ray.
+    pub fn cast_ray(
+        &self,
+        translation: Vect,
+        rotation: Rot,
+        ray_origin: Vect,
+        ray_dir: Vect,
+        max_time_of_impact: Real,
+        solid: bool,
+    ) -> Option<Real> {
+        let pos = crate::utils::pose_from(translation, rotation);
+        let ray = Ray::new(ray_origin, ray_dir);
+        self.raw.cast_ray(&pos, &ray, max_time_of_impact, solid)
+    }
+
+    /// Computes the time of impact, and normal between this transformed shape and a ray.
+    pub fn cast_ray_and_get_normal(
+        &self,
+        translation: Vect,
+        rotation: Rot,
+        ray_origin: Vect,
+        ray_dir: Vect,
+        max_time_of_impact: Real,
+        solid: bool,
+    ) -> Option<RayIntersection> {
+        let pos = crate::utils::pose_from(translation, rotation);
+        let ray = Ray::new(ray_origin, ray_dir);
+        self.raw
+            .cast_ray_and_get_normal(&pos, &ray, max_time_of_impact, solid)
+            .map(|inter| RayIntersection::from_rapier(inter, ray_origin, ray_dir))
+    }
+
+    /// Tests whether a ray intersects this transformed shape.
+    pub fn intersects_ray(
+        &self,
+        translation: Vect,
+        rotation: Rot,
+        ray_origin: Vect,
+        ray_dir: Vect,
+        max_time_of_impact: Real,
+    ) -> bool {
+        let pos = crate::utils::pose_from(translation, rotation);
+        let ray = Ray::new(ray_origin, ray_dir);
+        self.raw.intersects_ray(&pos, &ray, max_time_of_impact)
+    }
+
+    /// Computes the axis-aligned bounding box of `self` transformed by the given translation
+    /// and rotation.
+    pub fn aabb(&self, translation: Vect, rotation: Rot) -> BevyAabb {
+        let pos = crate::utils::pose_from(translation, rotation);
+        let aabb = self.raw.compute_aabb(&pos);
+        BevyAabb::new(aabb.center(), aabb.half_extents())
+    }
+
+    /// Computes the axis-aligned bounding box of `self` in its local-space.
+    pub fn local_aabb(&self) -> BevyAabb {
+        let aabb = self.raw.compute_local_aabb();
+        BevyAabb::new(aabb.center(), aabb.half_extents())
+    }
+
+    /// Computes a bounding sphere (or circle in 2D) of `self` transformed by the given
+    /// translation and rotation.
+    pub fn bounding_sphere(&self, translation: Vect, rotation: Rot) -> BevyBoundingSphere {
+        let pos = crate::utils::pose_from(translation, rotation);
+        let sphere = self.raw.compute_bounding_sphere(&pos);
+        BevyBoundingSphere::new(sphere.center, sphere.radius)
+    }
+
+    /// Computes a bounding sphere (or circle in 2D) of `self` in its local-space.
+    pub fn local_bounding_sphere(&self) -> BevyBoundingSphere {
+        let sphere = self.raw.compute_local_bounding_sphere();
+        BevyBoundingSphere::new(sphere.center, sphere.radius)
+    }
+
+    /// Computes the mass properties of `self`, assuming it has the given uniform density.
+    pub fn mass_properties(&self, density: Real) -> MassProperties {
+        MassProperties::from_rapier(self.raw.mass_properties(density))
+    }
+
+    /// Computes the contact between `self` and `other`, each transformed by their respective
+    /// translation and rotation.
+    ///
+    /// Returns `Ok(None)` if the colliders are separated by more than `prediction`. The contact
+    /// points and normals are expressed in world-space.
+    #[allow(clippy::too_many_arguments)]
+    pub fn contact(
+        &self,
+        translation: Vect,
+        rotation: Rot,
+        other: &Collider,
+        other_translation: Vect,
+        other_rotation: Rot,
+        prediction: Real,
+    ) -> Result<Option<ShapeContact>, Unsupported> {
+        let pos1 = crate::utils::pose_from(translation, rotation);
+        let pos2 = crate::utils::pose_from(other_translation, other_rotation);
+        Ok(
+            query::contact(&pos1, &*self.raw, &pos2, &*other.raw, prediction)?
+                .map(ShapeContact::from_rapier),
+        )
+    }
+
+    /// Computes the minimal distance between `self` and `other`, each transformed by their
+    /// respective translation and rotation.
+    ///
+    /// Returns `0.0` if the colliders are intersecting.
+    pub fn distance(
+        &self,
+        translation: Vect,
+        rotation: Rot,
+        other: &Collider,
+        other_translation: Vect,
+        other_rotation: Rot,
+    ) -> Result<Real, Unsupported> {
+        let pos1 = crate::utils::pose_from(translation, rotation);
+        let pos2 = crate::utils::pose_from(other_translation, other_rotation);
+        Ok(query::distance(&pos1, &*self.raw, &pos2, &*other.raw)?.distance)
+    }
+
+    /// Tests whether `self` and `other`, each transformed by their respective translation and
+    /// rotation, are intersecting.
+    pub fn intersection_test(
+        &self,
+        translation: Vect,
+        rotation: Rot,
+        other: &Collider,
+        other_translation: Vect,
+        other_rotation: Rot,
+    ) -> Result<bool, Unsupported> {
+        let pos1 = crate::utils::pose_from(translation, rotation);
+        let pos2 = crate::utils::pose_from(other_translation, other_rotation);
+        Ok(query::intersection_test(&pos1, &*self.raw, &pos2, &*other.raw)?.intersecting)
+    }
+
+    /// Computes the closest points between `self` and `other`, each transformed by their
+    /// respective translation and rotation.
+    ///
+    /// Returns [`ShapeClosestPoints::Disjoint`] if the colliders are separated by more than
+    /// `max_dist`. The closest points are expressed in world-space.
+    #[allow(clippy::too_many_arguments)]
+    pub fn closest_points(
+        &self,
+        translation: Vect,
+        rotation: Rot,
+        other: &Collider,
+        other_translation: Vect,
+        other_rotation: Rot,
+        max_dist: Real,
+    ) -> Result<ShapeClosestPoints, Unsupported> {
+        let pos1 = crate::utils::pose_from(translation, rotation);
+        let pos2 = crate::utils::pose_from(other_translation, other_rotation);
+        Ok(ShapeClosestPoints::from_rapier(query::closest_points(
+            &pos1,
+            &*self.raw,
+            &pos2,
+            &*other.raw,
+            max_dist,
+        )?))
+    }
+
+    /// Computes the first time of impact between `self` and `other`, each starting at their
+    /// respective translation and rotation, and moving with a constant linear velocity.
+    ///
+    /// Returns `Ok(None)` if they do not hit within [`ShapeCastOptions::max_time_of_impact`].
+    /// The witness points and normals of the result are expressed in the local-space of
+    /// each collider.
+    #[allow(clippy::too_many_arguments)]
+    pub fn cast_shape(
+        &self,
+        translation: Vect,
+        rotation: Rot,
+        velocity: Vect,
+        other: &Collider,
+        other_translation: Vect,
+        other_rotation: Rot,
+        other_velocity: Vect,
+        options: ShapeCastOptions,
+    ) -> Result<Option<ShapeCastHit>, Unsupported> {
+        let pos1 = crate::utils::pose_from(translation, rotation);
+        let pos2 = crate::utils::pose_from(other_translation, other_rotation);
+        Ok(query::cast_shapes(
+            &pos1,
+            velocity,
+            &*self.raw,
+            &pos2,
+            other_velocity,
+            &*other.raw,
+            options,
+        )?
+        .map(|hit| ShapeCastHit::from_rapier(hit, options.compute_impact_geometry_on_penetration)))
+    }
+
+    /// Computes the first time of impact between `self` and `other`, each following a
+    /// nonlinear rigid motion (with both linear and angular velocities).
+    ///
+    /// Only the time interval `[start_time, end_time]` is considered. If
+    /// `stop_at_penetration` is `true` and the colliders are initially penetrating, a hit
+    /// at `start_time` is returned. The witness points and normals of the result are
+    /// expressed in the local-space of each collider.
+    pub fn cast_shape_nonlinear(
+        &self,
+        motion: &NonlinearMotion,
+        other: &Collider,
+        other_motion: &NonlinearMotion,
+        start_time: Real,
+        end_time: Real,
+        stop_at_penetration: bool,
+    ) -> Result<Option<ShapeCastHit>, Unsupported> {
+        Ok(query::cast_shapes_nonlinear(
+            &motion.into_rapier(),
+            &*self.raw,
+            &other_motion.into_rapier(),
+            &*other.raw,
+            start_time,
+            end_time,
+            stop_at_penetration,
+        )?
+        .map(|hit| ShapeCastHit::from_rapier(hit, false)))
+    }
+}
+
+impl Default for Collider {
+    fn default() -> Self {
+        Self::ball(0.5)
+    }
+}
+
+#[cfg(all(feature = "dim3", feature = "async-collider"))]
+#[allow(clippy::type_complexity)]
+fn extract_mesh_vertices_indices(mesh: &Mesh) -> Option<(Vec<Vector>, Vec<[u32; 3]>)> {
+    let vertices = mesh.attribute(Mesh::ATTRIBUTE_POSITION)?;
+    let indices = mesh.indices()?;
+
+    let vtx: Vec<Vector> = match vertices {
+        VertexAttributeValues::Float32(vtx) => Some(
+            vtx.chunks(3)
+                .map(|v| Vector::new(v[0] as Real, v[1] as Real, v[2] as Real))
+                .collect(),
+        ),
+        VertexAttributeValues::Float32x3(vtx) => Some(
+            vtx.iter()
+                .map(|v| Vector::new(v[0] as Real, v[1] as Real, v[2] as Real))
+                .collect(),
+        ),
+        _ => None,
+    }?;
+
+    let idx = match indices {
+        Indices::U16(idx) => idx
+            .as_chunks::<3>()
+            .0
+            .iter()
+            .map(|i| i.map(u32::from))
+            .collect(),
+        Indices::U32(idx) => idx.as_chunks::<3>().0.to_vec(),
+    };
+
+    Some((vtx, idx))
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+    use crate::geometry::ShapeCastStatus;
+
+    #[cfg(feature = "dim2")]
+    const ROT_ID: Rot = 0.0;
+    #[cfg(feature = "dim3")]
+    const ROT_ID: Rot = Rot::IDENTITY;
+
+    fn assert_approx_eq(a: Real, b: Real) {
+        assert!((a - b).abs() < 1.0e-4, "{a} != {b}");
+    }
+
+    fn line_vertices() -> Vec<Vect> {
+        vec![Vect::ZERO, Vect::X, Vect::X * 2.0]
+    }
+
+    #[test]
+    fn polyline_with_flags_constructor() {
+        let collider =
+            Collider::polyline_with_flags(line_vertices(), None, PolylineFlags::DEFORMABLE);
+        let polyline = collider.as_polyline().unwrap();
+        assert_eq!(polyline.flags(), PolylineFlags::DEFORMABLE);
+        assert_eq!(polyline.num_segments(), 2);
+    }
+
+    #[test]
+    #[cfg(feature = "dim2")]
+    fn oriented_polyline_constructor() {
+        let collider = Collider::oriented_polyline(line_vertices(), None);
+        let polyline = collider.as_polyline().unwrap();
+        assert!(polyline.flags().contains(PolylineFlags::ORIENTED));
+        assert_eq!(polyline.pseudo_normals().unwrap().len(), 3);
+    }
+
+    #[test]
+    #[cfg(feature = "dim2")]
+    fn convex_polyline_unmodified_keeps_collinear_points() {
+        let points = vec![
+            Vect::new(0.0, 0.0),
+            Vect::new(1.0, 0.0),
+            Vect::new(2.0, 0.0),
+            Vect::new(2.0, 2.0),
+            Vect::new(0.0, 2.0),
+        ];
+        let unmodified = Collider::convex_polyline_unmodified(points.clone()).unwrap();
+        assert_eq!(unmodified.as_convex_polygon().unwrap().points().len(), 5);
+        let simplified = Collider::convex_polyline(points).unwrap();
+        assert_eq!(simplified.as_convex_polygon().unwrap().points().len(), 4);
+    }
+
+    #[test]
+    #[cfg(feature = "dim3")]
+    fn heightfield_with_flags_constructor() {
+        let collider = Collider::heightfield_with_flags(
+            vec![0.0; 9],
+            3,
+            3,
+            Vect::ONE,
+            HeightFieldFlags::FIX_INTERNAL_EDGES,
+        );
+        let heightfield = collider.as_heightfield().unwrap();
+        assert_eq!(heightfield.flags(), HeightFieldFlags::FIX_INTERNAL_EDGES);
+    }
+
+    #[test]
+    fn compound_with_flags_constructor_and_mutation() {
+        let parts = vec![
+            (Vect::ZERO, ROT_ID, Collider::ball(0.5)),
+            (Vect::X, ROT_ID, Collider::ball(0.5)),
+        ];
+        let mut collider =
+            Collider::compound_with_flags(parts, CompoundFlags::FIX_INTERNAL_EDGES, None);
+        assert_eq!(
+            collider.as_compound().unwrap().flags(),
+            CompoundFlags::FIX_INTERNAL_EDGES
+        );
+        assert_eq!(collider.as_compound().unwrap().shapes().len(), 2);
+
+        let shared = collider.clone();
+        collider
+            .as_compound_mut()
+            .unwrap()
+            .set_flags(CompoundFlags::empty(), None);
+        assert_eq!(
+            collider.as_compound().unwrap().flags(),
+            CompoundFlags::empty()
+        );
+        // The mutation must not leak into the clone sharing the same shape.
+        assert_eq!(
+            shared.as_compound().unwrap().flags(),
+            CompoundFlags::FIX_INTERNAL_EDGES
+        );
+    }
+
+    #[test]
+    fn converted_trimesh_constructor() {
+        let offset = Vect::ONE * 3.0;
+        let (vertices, indices) = cuboid_mesh_for_tests(offset);
+
+        let aabb =
+            Collider::converted_trimesh(vertices.clone(), indices.clone(), MeshConverter::Aabb)
+                .unwrap();
+        // The offset of the AABB is preserved by a single-part compound.
+        let compound = aabb.as_compound().unwrap();
+        let (translation, _, part) = compound.shapes().next().unwrap();
+        assert!((translation - offset).length() < 1.0e-5);
+        assert!(matches!(part, ColliderView::Cuboid(_)));
+
+        let hull = Collider::converted_trimesh(
+            vertices.clone(),
+            indices.clone(),
+            MeshConverter::ConvexHull,
+        )
+        .unwrap();
+        #[cfg(feature = "dim2")]
+        assert!(hull.as_convex_polygon().is_some());
+        #[cfg(feature = "dim3")]
+        assert!(hull.as_convex_polyhedron().is_some());
+
+        let trimesh =
+            Collider::converted_trimesh(vertices, indices, MeshConverter::TriMesh).unwrap();
+        assert!(trimesh.as_trimesh().is_some());
+    }
+
+    #[test]
+    fn trimesh_view_set_vertices() {
+        let (vertices, indices) = cuboid_mesh_for_tests(Vect::ZERO);
+        let mut collider =
+            Collider::trimesh_with_flags(vertices.clone(), indices, TriMeshFlags::DEFORMABLE)
+                .unwrap();
+        assert_eq!(
+            collider.as_trimesh().unwrap().flags(),
+            TriMeshFlags::DEFORMABLE
+        );
+
+        let shift = Vect::X * 10.0;
+        let shifted: Vec<_> = vertices.iter().map(|v| *v + shift).collect();
+        collider.as_trimesh_mut().unwrap().set_vertices(&shifted);
+        let aabb = collider.local_aabb();
+        assert_approx_eq(aabb.min.x, 9.5);
+        assert_approx_eq(aabb.max.x, 10.5);
+
+        collider
+            .as_trimesh_mut()
+            .unwrap()
+            .update_vertices(|vtx| vtx.iter_mut().for_each(|v| *v -= shift));
+        assert_approx_eq(collider.local_aabb().max.x, 0.5);
+    }
+
+    #[test]
+    fn polyline_view_set_vertices() {
+        let mut collider =
+            Collider::polyline_with_flags(line_vertices(), None, PolylineFlags::DEFORMABLE);
+        let lifted = vec![Vect::ZERO, Vect::X + Vect::Y, Vect::X * 2.0];
+        collider.as_polyline_mut().unwrap().set_vertices(&lifted);
+        assert_approx_eq(collider.local_aabb().max.y, 1.0);
+    }
+
+    #[test]
+    fn voxels_view_set_voxel_size() {
+        let mut collider = Collider::voxels(Vect::ONE, &[IVect::ZERO, IVect::X]);
+        let voxels = collider.as_voxels().unwrap();
+        assert_eq!(voxels.voxel_size(), Vect::ONE);
+        assert_eq!(voxels.voxel_center(IVect::X), Vect::X + Vect::splat(0.5));
+        assert_eq!(
+            voxels
+                .cropped(IVect::ZERO, IVect::ZERO)
+                .unwrap()
+                .voxels()
+                .count(),
+            1
+        );
+
+        collider
+            .as_voxels_mut()
+            .unwrap()
+            .set_voxel_size(Vect::splat(2.0));
+        let voxels = collider.as_voxels().unwrap();
+        assert_eq!(voxels.voxel_size(), Vect::splat(2.0));
+        assert_eq!(voxels.voxel_center(IVect::X), Vect::X * 2.0 + Vect::ONE);
+    }
+
+    #[test]
+    #[cfg(feature = "dim3")]
+    fn convex_polyhedron_topology() {
+        let (vertices, _) = cuboid_mesh_for_tests(Vect::ZERO);
+        let collider = Collider::convex_hull(&vertices).unwrap();
+        let polyhedron = collider.as_convex_polyhedron().unwrap();
+        assert_eq!(polyhedron.num_vertices(), 8);
+        assert_eq!(polyhedron.edges().count(), 12);
+        assert_eq!(polyhedron.num_faces(), 6);
+        for i in 0..polyhedron.num_faces() {
+            assert_eq!(polyhedron.face_vertices(i).len(), 4);
+            assert_eq!(polyhedron.face_edges(i).len(), 4);
+            assert_approx_eq(polyhedron.face_normal(i).length(), 1.0);
+        }
+        for i in 0..polyhedron.num_vertices() {
+            assert_eq!(polyhedron.vertex_adjacent_faces(i).len(), 3);
+        }
+        let points: Vec<_> = polyhedron.points().collect();
+        for edge in polyhedron.edges() {
+            let [a, b] = polyhedron.edge_vertices(edge as usize);
+            let dir = (points[b as usize] - points[a as usize]).normalize();
+            assert!((dir - polyhedron.edge_direction(edge as usize)).length() < 1.0e-5);
+            let [f1, f2] = polyhedron.edge_faces(edge as usize);
+            assert!(polyhedron.face_edges(f1 as usize).contains(&edge));
+            assert!(polyhedron.face_edges(f2 as usize).contains(&edge));
+        }
+    }
+
+    #[test]
+    fn custom_shape_view_does_not_panic() {
+        let collider = Collider::ball(1.0);
+        let view = ColliderView::Custom(&*collider.raw);
+        assert!(matches!(
+            view.as_typed_shape(),
+            rapier::parry::shape::TypedShape::Custom(_)
+        ));
+        let shared = view.to_shared_shape();
+        assert!(shared.as_ball().is_some());
+        assert!(view.raw_scale_by(Vect::splat(2.0), 10).is_some());
+    }
+
+    #[test]
+    fn bounding_volumes_and_mass_properties() {
+        let collider = Collider::ball(1.0);
+        let translation = Vect::X * 2.0;
+
+        let aabb = collider.aabb(translation, ROT_ID);
+        assert_approx_eq(aabb.min.x, 1.0);
+        assert_approx_eq(aabb.max.x, 3.0);
+        assert_approx_eq(aabb.max.y, 1.0);
+
+        let sphere = collider.bounding_sphere(translation, ROT_ID);
+        assert_approx_eq(sphere.center.x, 2.0);
+        assert_approx_eq(sphere.radius(), 1.0);
+
+        let mprops = collider.mass_properties(2.0);
+        #[cfg(feature = "dim2")]
+        assert_approx_eq(mprops.mass, 2.0 * core::f32::consts::PI);
+        #[cfg(feature = "dim3")]
+        assert_approx_eq(mprops.mass, 2.0 * 4.0 / 3.0 * core::f32::consts::PI);
+    }
+
+    #[test]
+    fn pairwise_queries() {
+        let ball = Collider::ball(1.0);
+        let pos1 = Vect::ZERO;
+        let pos2 = Vect::X * 3.0;
+
+        let distance = ball.distance(pos1, ROT_ID, &ball, pos2, ROT_ID).unwrap();
+        assert_approx_eq(distance, 1.0);
+
+        assert!(!ball
+            .intersection_test(pos1, ROT_ID, &ball, pos2, ROT_ID)
+            .unwrap());
+        assert!(ball
+            .intersection_test(pos1, ROT_ID, &ball, Vect::X, ROT_ID)
+            .unwrap());
+
+        let contact = ball
+            .contact(pos1, ROT_ID, &ball, pos2, ROT_ID, 2.0)
+            .unwrap()
+            .unwrap();
+        assert_approx_eq(contact.distance, 1.0);
+        assert!((contact.normal1 - Vect::X).length() < 1.0e-5);
+        assert!((contact.point1 - Vect::X).length() < 1.0e-5);
+        assert!((contact.point2 - Vect::X * 2.0).length() < 1.0e-5);
+        assert!(ball
+            .contact(pos1, ROT_ID, &ball, pos2, ROT_ID, 0.5)
+            .unwrap()
+            .is_none());
+
+        match ball
+            .closest_points(pos1, ROT_ID, &ball, pos2, ROT_ID, 2.0)
+            .unwrap()
+        {
+            ShapeClosestPoints::WithinMargin(p1, p2) => {
+                assert!((p1 - Vect::X).length() < 1.0e-5);
+                assert!((p2 - Vect::X * 2.0).length() < 1.0e-5);
+            }
+            other => panic!("Unexpected closest points: {other:?}"),
+        }
+        assert_eq!(
+            ball.closest_points(pos1, ROT_ID, &ball, pos2, ROT_ID, 0.5)
+                .unwrap(),
+            ShapeClosestPoints::Disjoint
+        );
+        assert_eq!(
+            ball.closest_points(pos1, ROT_ID, &ball, Vect::X, ROT_ID, 0.5)
+                .unwrap(),
+            ShapeClosestPoints::Intersecting
+        );
+
+        let hit = ball
+            .cast_shape(
+                pos1,
+                ROT_ID,
+                Vect::X,
+                &ball,
+                pos2,
+                ROT_ID,
+                Vect::ZERO,
+                ShapeCastOptions::with_max_time_of_impact(10.0),
+            )
+            .unwrap()
+            .unwrap();
+        assert_approx_eq(hit.time_of_impact, 1.0);
+        assert_eq!(hit.status, ShapeCastStatus::Converged);
+        let details = hit.details.unwrap();
+        assert!((details.normal1 - Vect::X).length() < 1.0e-4);
+
+        let mut motion1 = NonlinearMotion::constant_position(pos1, ROT_ID);
+        motion1.linear_velocity = Vect::X;
+        let motion2 = NonlinearMotion::constant_position(pos2, ROT_ID);
+        let hit = ball
+            .cast_shape_nonlinear(&motion1, &ball, &motion2, 0.0, 10.0, true)
+            .unwrap()
+            .unwrap();
+        assert!((hit.time_of_impact - 1.0).abs() < 1.0e-2);
+    }
+
+    /// The vertex and index buffers of a unit cube (3D) or square (2D) mesh centered at `offset`.
+    fn cuboid_mesh_for_tests(offset: Vect) -> (Vec<Vect>, Vec<[u32; 3]>) {
+        let (vtx, idx) = rapier::prelude::Cuboid::new(Vect::splat(0.5)).to_trimesh();
+        (vtx.into_iter().map(|v| v + offset).collect(), idx)
+    }
+}
diff --git a/bindings/bevy_rapier/src/geometry/mod.rs b/bindings/bevy_rapier/src/geometry/mod.rs
new file mode 100644
index 000000000..fbcda72f7
--- /dev/null
+++ b/bindings/bevy_rapier/src/geometry/mod.rs
@@ -0,0 +1,277 @@
+pub use self::collider::*;
+pub use self::shape_views::ColliderView;
+pub use rapier::geometry::SolverFlags;
+pub use rapier::geometry::{MeshConverter, MeshConverterError};
+pub use rapier::parry::query::{ShapeCastOptions, ShapeCastStatus, Unsupported};
+#[cfg(feature = "dim3")]
+pub use rapier::parry::shape::HeightFieldFlags;
+pub use rapier::parry::shape::{CompoundFlags, PolylineFlags, TriMeshFlags};
+pub use rapier::parry::transformation::{vhacd::VHACDParameters, voxelization::FillMode};
+
+use crate::math::{Real, Rot, Vect};
+use rapier::prelude::FeatureId;
+
+mod collider;
+mod collider_impl;
+/// Wrappers around Rapier shapes to access their properties.
+pub mod shape_views;
+#[cfg(feature = "to-bevy-mesh")]
+pub mod to_bevy_mesh;
+
+/// Result of the projection of a point on a shape.
+#[derive(Copy, Clone, Debug, PartialEq)]
+pub struct PointProjection {
+    /// Whether or not the point to project was inside of the shape.
+    pub is_inside: bool,
+    /// The projection result.
+    pub point: Vect,
+    /// The index of the part of the shape the point was projected on (for compound shapes,
+    /// triangle meshes, polylines, voxels, etc.), or `0` for a shape with no sub-shape.
+    pub subshape: u32,
+}
+
+impl PointProjection {
+    pub(crate) fn from_rapier(raw: rapier::parry::query::PointProjection) -> Self {
+        Self {
+            is_inside: raw.is_inside,
+            point: raw.point,
+            subshape: raw.subshape,
+        }
+    }
+}
+impl From<rapier::parry::query::PointProjection> for PointProjection {
+    fn from(projection: rapier::parry::query::PointProjection) -> PointProjection {
+        PointProjection::from_rapier(projection)
+    }
+}
+
+/// Structure containing the result of a successful ray cast.
+#[derive(Copy, Clone, Debug, PartialEq)]
+pub struct RayIntersection {
+    /// The time of impact of the ray with the object.  The exact contact point can be computed
+    /// with `origin + dir * time_of_impact` where `origin` is the origin of the ray;
+    /// `dir` is its direction and `time_of_impact` is the value of this field.
+    pub time_of_impact: Real,
+
+    /// The intersection point between the ray and the object.
+    pub point: Vect,
+
+    /// The normal at the intersection point.
+    ///
+    /// If the `toi` is exactly zero, the normal might not be reliable.
+    pub normal: Vect,
+
+    /// Feature at the intersection point.
+    pub feature: FeatureId,
+
+    /// The index of the part of the shape hit by the ray (for compound shapes, triangle meshes,
+    /// polylines, voxels, etc.), or `0` for a shape with no sub-shape.
+    pub subshape: u32,
+}
+
+impl RayIntersection {
+    pub(crate) fn from_rapier(
+        inter: rapier::parry::query::RayIntersection,
+        unscaled_origin: Vect,
+        unscaled_dir: Vect,
+    ) -> Self {
+        Self {
+            time_of_impact: inter.time_of_impact,
+            point: unscaled_origin + unscaled_dir * inter.time_of_impact,
+            normal: inter.normal,
+            feature: inter.feature,
+            subshape: inter.subshape,
+        }
+    }
+}
+
+/// The result of a shape cast.
+#[derive(Copy, Clone, Debug, PartialEq)]
+pub struct ShapeCastHit {
+    /// The time at which the objects touch.
+    pub time_of_impact: Real,
+    /// Detail about the impact points.
+    ///
+    /// `None` if `status` is `PenetratingOrWithinTargetDist` and
+    /// [`ShapeCastOptions::compute_impact_geometry_on_penetration`] was `false`.
+    pub details: Option<ShapeCastHitDetails>,
+    /// The way the time-of-impact computation algorithm terminated.
+    pub status: ShapeCastStatus,
+    /// The index of the part of the first shape that was hit (for compound shapes, triangle
+    /// meshes, polylines, voxels, etc.), or `0` for a shape with no sub-shape.
+    ///
+    /// For scene queries and character collisions, the first shape is the collider being hit.
+    pub subshape1: u32,
+    /// The index of the part of the second shape that was hit (for compound shapes, triangle
+    /// meshes, polylines, voxels, etc.), or `0` for a shape with no sub-shape.
+    ///
+    /// For scene queries and character collisions, the second shape is the shape being cast.
+    pub subshape2: u32,
+}
+
+/// In depth information about a shape-cast hit.
+///
+/// The frame of each field depends on the query:
+/// - For scene queries (e.g. [`RapierContext::cast_shape`],
+///   [`RapierContext::cast_shape_nonlinear`]) and [`CharacterCollision::hit`], the first shape is
+///   the collider hit: `witness1` and `normal1` are in world-space. The second shape is the cast
+///   shape (or the character): `witness2` and `normal2` are in its local-space, at its pose at the
+///   time of impact.
+/// - For [`Collider::cast_shape`] and [`Collider::cast_shape_nonlinear`], the first shape is `self`
+///   and the second one `other`: every field is in the local-space of its shape.
+///
+/// [`RapierContext::cast_shape`]: crate::plugin::context::systemparams::RapierContext::cast_shape
+/// [`RapierContext::cast_shape_nonlinear`]: crate::plugin::context::systemparams::RapierContext::cast_shape_nonlinear
+/// [`CharacterCollision::hit`]: crate::control::CharacterCollision::hit
+#[derive(Copy, Clone, Debug, PartialEq)]
+pub struct ShapeCastHitDetails {
+    /// The closest point on the first shape at the time of impact (world-space for scene
+    /// queries, local-space otherwise).
+    pub witness1: Vect,
+    /// The closest point on the second shape at the time of impact, in its local-space.
+    pub witness2: Vect,
+    /// The outward normal on the first shape at the time of impact (world-space for scene
+    /// queries, local-space otherwise).
+    pub normal1: Vect,
+    /// The outward normal on the second shape at the time of impact, in its local-space.
+    pub normal2: Vect,
+}
+
+impl ShapeCastHit {
+    /// Convert from internal `rapier::query::ShapeCastHit`.
+    pub fn from_rapier(
+        hit: rapier::parry::query::ShapeCastHit,
+        details_always_computed: bool,
+    ) -> Self {
+        let details = match (details_always_computed, hit.status) {
+            (_, ShapeCastStatus::Failed) => None,
+            (false, ShapeCastStatus::PenetratingOrWithinTargetDist) => None,
+            _ => Some(ShapeCastHitDetails {
+                witness1: hit.witness1,
+                witness2: hit.witness2,
+                normal1: hit.normal1,
+                normal2: hit.normal2,
+            }),
+        };
+        Self {
+            time_of_impact: hit.time_of_impact,
+            status: hit.status,
+            details,
+            subshape1: hit.subshape1,
+            subshape2: hit.subshape2,
+        }
+    }
+}
+
+/// The result of a contact query between two colliders.
+#[derive(Copy, Clone, Debug, PartialEq)]
+pub struct ShapeContact {
+    /// The contact point on the first collider, in world-space.
+    pub point1: Vect,
+    /// The contact point on the second collider, in world-space.
+    pub point2: Vect,
+    /// The contact normal, pointing outward from the first collider, in world-space.
+    pub normal1: Vect,
+    /// The contact normal, pointing outward from the second collider, in world-space.
+    ///
+    /// This is always equal to `-normal1`.
+    pub normal2: Vect,
+    /// The signed distance between the two contact points.
+    ///
+    /// It is negative if the colliders are penetrating.
+    pub distance: Real,
+    /// The index of the part of the first collider involved in the contact (for compound
+    /// shapes, triangle meshes, polylines, etc.), or `0` for a shape with no sub-shape.
+    pub subshape1: u32,
+    /// The index of the part of the second collider involved in the contact (for compound
+    /// shapes, triangle meshes, polylines, etc.), or `0` for a shape with no sub-shape.
+    pub subshape2: u32,
+}
+
+impl ShapeContact {
+    pub(crate) fn from_rapier(contact: rapier::parry::query::Contact) -> Self {
+        Self {
+            point1: contact.point1,
+            point2: contact.point2,
+            normal1: contact.normal1,
+            normal2: contact.normal2,
+            distance: contact.dist,
+            subshape1: contact.subshape1,
+            subshape2: contact.subshape2,
+        }
+    }
+}
+
+/// The result of a closest-points query between two colliders.
+#[derive(Copy, Clone, Debug, PartialEq)]
+pub enum ShapeClosestPoints {
+    /// The two colliders are intersecting.
+    Intersecting,
+    /// The two colliders are disjoint but closer than the queried maximum distance.
+    ///
+    /// Contains the closest point on the first collider, then the closest point on the second
+    /// collider, both in world-space.
+    WithinMargin(Vect, Vect),
+    /// The two colliders are further apart than the queried maximum distance.
+    Disjoint,
+}
+
+impl ShapeClosestPoints {
+    pub(crate) fn from_rapier(points: rapier::parry::query::ClosestPoints) -> Self {
+        match points {
+            rapier::parry::query::ClosestPoints::Intersecting => Self::Intersecting,
+            rapier::parry::query::ClosestPoints::WithinMargin(p1, p2) => Self::WithinMargin(p1, p2),
+            rapier::parry::query::ClosestPoints::Disjoint => Self::Disjoint,
+        }
+    }
+}
+
+/// A rigid motion combining a constant linear and a constant angular velocity, used for
+/// nonlinear shape casting with [`Collider::cast_shape_nonlinear`].
+///
+/// At time `t`, the collider is rotated by `angular_velocity * t` around the point
+/// `local_center` (expressed in the collider's local-space), and translated by
+/// `linear_velocity * t`, starting from the pose given by `translation` and `rotation`.
+#[derive(Copy, Clone, Debug, PartialEq)]
+pub struct NonlinearMotion {
+    /// The translation of the collider at time `0.0`.
+    pub translation: Vect,
+    /// The rotation of the collider at time `0.0`.
+    pub rotation: Rot,
+    /// The local-space point around which the collider rotates.
+    pub local_center: Vect,
+    /// The linear velocity of the collider.
+    pub linear_velocity: Vect,
+    /// The angular velocity of the collider.
+    #[cfg(feature = "dim2")]
+    pub angular_velocity: Real,
+    /// The angular velocity of the collider.
+    #[cfg(feature = "dim3")]
+    pub angular_velocity: Vect,
+}
+
+impl NonlinearMotion {
+    /// A motion that keeps the collider at the given position.
+    pub fn constant_position(translation: Vect, rotation: Rot) -> Self {
+        Self {
+            translation,
+            rotation,
+            local_center: Vect::ZERO,
+            linear_velocity: Vect::ZERO,
+            #[cfg(feature = "dim2")]
+            angular_velocity: 0.0,
+            #[cfg(feature = "dim3")]
+            angular_velocity: Vect::ZERO,
+        }
+    }
+
+    /// Converts this motion to Rapier's `NonlinearRigidMotion`.
+    pub fn into_rapier(self) -> rapier::parry::query::NonlinearRigidMotion {
+        rapier::parry::query::NonlinearRigidMotion::new(
+            crate::utils::pose_from(self.translation, self.rotation),
+            self.local_center,
+            self.linear_velocity,
+            self.angular_velocity,
+        )
+    }
+}
diff --git a/bindings/bevy_rapier/src/geometry/shape_views/ball.rs b/bindings/bevy_rapier/src/geometry/shape_views/ball.rs
new file mode 100644
index 000000000..f318c4afe
--- /dev/null
+++ b/bindings/bevy_rapier/src/geometry/shape_views/ball.rs
@@ -0,0 +1,37 @@
+use crate::math::Real;
+use rapier::parry::shape::Ball;
+
+/// Read-only access to the properties of a ball.
+#[derive(Copy, Clone)]
+pub struct BallView<'a> {
+    /// The raw shape from Rapier.
+    pub raw: &'a Ball,
+}
+
+macro_rules! impl_ref_methods(
+    ($View: ident) => {
+        impl<'a> $View<'a> {
+            /// The radius of the ball.
+            pub fn radius(&self) -> Real {
+                self.raw.radius
+            }
+        }
+    }
+);
+
+impl_ref_methods!(BallView);
+
+/// Read-write access to the properties of a ball.
+pub struct BallViewMut<'a> {
+    /// The raw shape from Rapier.
+    pub raw: &'a mut Ball,
+}
+
+impl_ref_methods!(BallViewMut);
+
+impl BallViewMut<'_> {
+    /// Set the radius of the ball.
+    pub fn set_radius(&mut self, radius: Real) {
+        self.raw.radius = radius;
+    }
+}
diff --git a/bindings/bevy_rapier/src/geometry/shape_views/capsule.rs b/bindings/bevy_rapier/src/geometry/shape_views/capsule.rs
new file mode 100644
index 000000000..7a238a24b
--- /dev/null
+++ b/bindings/bevy_rapier/src/geometry/shape_views/capsule.rs
@@ -0,0 +1,97 @@
+use super::SegmentView;
+use crate::math::{Real, Rot, Vect};
+use rapier::parry::shape::Capsule;
+
+/// Read-only access to the properties of a capsule.
+#[derive(Copy, Clone)]
+pub struct CapsuleView<'a> {
+    /// The raw shape from Rapier.
+    pub raw: &'a Capsule,
+}
+
+macro_rules! impl_ref_methods(
+    ($View: ident) => {
+        impl<'a> $View<'a> {
+            /// The axis and endpoint of the capsule.
+            pub fn segment(&self) -> SegmentView<'_> {
+                SegmentView {
+                    raw: &self.raw.segment,
+                }
+            }
+
+            /// The radius of the capsule.
+            pub fn radius(&self) -> Real {
+                self.raw.radius
+            }
+
+            /// The height of this capsule.
+            pub fn height(&self) -> Real {
+                self.raw.height()
+            }
+
+            /// The half-height of this capsule.
+            pub fn half_height(&self) -> Real {
+                self.raw.half_height()
+            }
+
+            /// The center of this capsule.
+            pub fn center(&self) -> Vect {
+                self.raw.center().into()
+            }
+
+            /// The transformation such that `t * Y` is collinear with `b - a` and `t * origin` equals
+            /// the capsule's center.
+            pub fn canonical_transform(&self) -> (Vect, Rot) {
+                let pose = self.raw.canonical_transform();
+                #[cfg(feature = "dim2")]
+                return (pose.translation, pose.rotation.angle());
+                #[cfg(feature = "dim3")]
+                return (pose.translation, pose.rotation);
+            }
+
+            /// The rotation `r` such that `r * Y` is collinear with `b - a`.
+            #[cfg(feature = "dim2")]
+            pub fn rotation_wrt_y(&self) -> Rot {
+                self.raw.rotation_wrt_y().angle()
+            }
+
+            /// The rotation `r` such that `r * Y` is collinear with `b - a`.
+            #[cfg(feature = "dim3")]
+            pub fn rotation_wrt_y(&self) -> Rot {
+                self.raw.rotation_wrt_y()
+            }
+
+            /// The transform `t` such that `t * Y` is collinear with `b - a` and such that `t * origin = (b + a) / 2.0`.
+            pub fn transform_wrt_y(&self) -> (Vect, Rot) {
+                let pose = self.raw.transform_wrt_y();
+                #[cfg(feature = "dim2")]
+                return (pose.translation, pose.rotation.angle());
+                #[cfg(feature = "dim3")]
+                return (pose.translation, pose.rotation);
+            }
+        }
+    }
+);
+
+impl_ref_methods!(CapsuleView);
+
+/// Read-write access to the properties of a capsule.
+pub struct CapsuleViewMut<'a> {
+    /// The raw shape from Rapier.
+    pub raw: &'a mut Capsule,
+}
+
+impl_ref_methods!(CapsuleViewMut);
+
+impl CapsuleViewMut<'_> {
+    /// Set the segment of this capsule.
+    pub fn set_segment(&mut self, start: Vect, end: Vect) {
+        self.raw.segment.a = start;
+        self.raw.segment.b = end;
+    }
+
+    /// Set the radius of this capsule.
+    pub fn set_radius(&mut self, radius: Real) {
+        self.raw.radius = radius;
+    }
+}
diff --git a/bindings/bevy_rapier/src/geometry/shape_views/collider_view.rs b/bindings/bevy_rapier/src/geometry/shape_views/collider_view.rs
new file mode 100644
index 000000000..96e88732b
--- /dev/null
+++ b/bindings/bevy_rapier/src/geometry/shape_views/collider_view.rs
@@ -0,0 +1,412 @@
+use std::fmt;
+
+use super::*;
+use crate::math::Vect;
+use rapier::geometry::{RoundShape, Shape, SharedShape};
+use rapier::parry::either::Either;
+use rapier::parry::shape::TypedShape;
+
+#[cfg(doc)]
+use rapier::parry;
+
+/// Read-only access to the properties of a collider.
+#[derive(Copy, Clone)]
+pub enum ColliderView<'a> {
+    /// A ball shape.
+    Ball(BallView<'a>),
+    /// A cuboid shape.
+    Cuboid(CuboidView<'a>),
+    /// A capsule shape.
+    Capsule(CapsuleView<'a>),
+    /// A segment shape.
+    Segment(SegmentView<'a>),
+    /// A triangle shape.
+    Triangle(TriangleView<'a>),
+    /// A Voxels shape.
+    Voxels(VoxelsView<'a>),
+    /// A triangle mesh shape.
+    TriMesh(TriMeshView<'a>),
+    /// A set of segments.
+    Polyline(PolylineView<'a>),
+    /// A shape representing a full half-space.
+    HalfSpace(HalfSpaceView<'a>),
+    /// A heightfield shape.
+    HeightField(HeightFieldView<'a>),
+    /// A Compound shape.
+    Compound(CompoundView<'a>),
+    /// A convex polygon.
+    #[cfg(feature = "dim2")]
+    ConvexPolygon(ConvexPolygonView<'a>),
+    /// A convex polyhedron.
+    #[cfg(feature = "dim3")]
+    ConvexPolyhedron(ConvexPolyhedronView<'a>),
+    #[cfg(feature = "dim3")]
+    /// A cylindrical shape.
+    Cylinder(CylinderView<'a>),
+    #[cfg(feature = "dim3")]
+    /// A cone shape.
+    Cone(ConeView<'a>),
+    /// A cuboid with rounded corners.
+    RoundCuboid(RoundCuboidView<'a>),
+    /// A triangle with rounded corners.
+    RoundTriangle(RoundTriangleView<'a>),
+    // /// A triangle-mesh with rounded corners.
+    // RoundedTriMesh,
+    // /// An heightfield with rounded corners.
+    // RoundedHeightField,
+    /// A cylinder with rounded corners.
+    #[cfg(feature = "dim3")]
+    RoundCylinder(RoundCylinderView<'a>),
+    /// A cone with rounded corners.
+    #[cfg(feature = "dim3")]
+    RoundCone(RoundConeView<'a>),
+    /// A convex polyhedron with rounded corners.
+    #[cfg(feature = "dim3")]
+    RoundConvexPolyhedron(RoundConvexPolyhedronView<'a>),
+    /// A convex polygon with rounded corners.
+    #[cfg(feature = "dim2")]
+    RoundConvexPolygon(RoundConvexPolygonView<'a>),
+    /// A user-defined shape, not known by Rapier.
+    Custom(&'a dyn Shape),
+}
+impl fmt::Debug for ColliderView<'_> {
+    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+        match self {
+            ColliderView::Ball(view) => write!(f, "{:?}", view.raw),
+            ColliderView::Cuboid(view) => write!(f, "{:?}", view.raw),
+            ColliderView::Capsule(view) => write!(f, "{:?}", view.raw),
+            ColliderView::Segment(view) => write!(f, "{:?}", view.raw),
+            ColliderView::Triangle(view) => write!(f, "{:?}", view.raw),
+            ColliderView::Voxels(view) => write!(f, "{:?}", view.raw),
+            ColliderView::TriMesh(_) => write!(f, "Trimesh (not representable)"),
+            ColliderView::Polyline(_) => write!(f, "Polyline (not representable)"),
+            ColliderView::HalfSpace(view) => write!(f, "{:?}", view.raw),
+            ColliderView::HeightField(view) => write!(f, "{:?}", view.raw),
+            ColliderView::Compound(_) => write!(f, "Compound (not representable)"),
+            #[cfg(feature = "dim2")]
+            ColliderView::ConvexPolygon(view) => write!(f, "{:?}", view.raw),
+            #[cfg(feature = "dim3")]
+            ColliderView::ConvexPolyhedron(view) => write!(f, "{:?}", view.raw),
+            #[cfg(feature = "dim3")]
+            ColliderView::Cylinder(view) => write!(f, "{:?}", view.raw),
+            #[cfg(feature = "dim3")]
+            ColliderView::Cone(view) => write!(f, "{:?}", view.raw),
+            ColliderView::RoundCuboid(view) => write!(f, "{:?}", view.raw),
+            ColliderView::RoundTriangle(view) => write!(f, "{:?}", view.raw),
+            #[cfg(feature = "dim3")]
+            ColliderView::RoundCylinder(view) => write!(f, "{:?}", view.raw),
+            #[cfg(feature = "dim3")]
+            ColliderView::RoundCone(view) => write!(f, "{:?}", view.raw),
+            #[cfg(feature = "dim3")]
+            ColliderView::RoundConvexPolyhedron(view) => write!(f, "{:?}", view.raw),
+            #[cfg(feature = "dim2")]
+            ColliderView::RoundConvexPolygon(view) => write!(f, "{:?}", view.raw),
+            ColliderView::Custom(_) => write!(f, "Custom (not representable)"),
+        }
+    }
+}
+
+impl<'a> From<TypedShape<'a>> for ColliderView<'a> {
+    fn from(typed_shape: TypedShape<'a>) -> ColliderView<'a> {
+        match typed_shape {
+            TypedShape::Ball(s) => ColliderView::Ball(BallView { raw: s }),
+            TypedShape::Cuboid(s) => ColliderView::Cuboid(CuboidView { raw: s }),
+            TypedShape::Capsule(s) => ColliderView::Capsule(CapsuleView { raw: s }),
+            TypedShape::Segment(s) => ColliderView::Segment(SegmentView { raw: s }),
+            TypedShape::Triangle(s) => ColliderView::Triangle(TriangleView { raw: s }),
+            TypedShape::Voxels(s) => ColliderView::Voxels(VoxelsView { raw: s }),
+            TypedShape::TriMesh(s) => ColliderView::TriMesh(TriMeshView { raw: s }),
+            TypedShape::Polyline(s) => ColliderView::Polyline(PolylineView { raw: s }),
+            TypedShape::HalfSpace(s) => ColliderView::HalfSpace(HalfSpaceView { raw: s }),
+            TypedShape::HeightField(s) => ColliderView::HeightField(HeightFieldView { raw: s }),
+            TypedShape::Compound(s) => ColliderView::Compound(CompoundView { raw: s }),
+            #[cfg(feature = "dim2")]
+            TypedShape::ConvexPolygon(s) => {
+                ColliderView::ConvexPolygon(ConvexPolygonView { raw: s })
+            }
+            #[cfg(feature = "dim3")]
+            TypedShape::ConvexPolyhedron(s) => {
+                ColliderView::ConvexPolyhedron(ConvexPolyhedronView { raw: s })
+            }
+            #[cfg(feature = "dim3")]
+            TypedShape::Cylinder(s) => ColliderView::Cylinder(CylinderView { raw: s }),
+            #[cfg(feature = "dim3")]
+            TypedShape::Cone(s) => ColliderView::Cone(ConeView { raw: s }),
+            TypedShape::RoundCuboid(s) => ColliderView::RoundCuboid(RoundCuboidView { raw: s }),
+            TypedShape::RoundTriangle(s) => {
+                ColliderView::RoundTriangle(RoundTriangleView { raw: s })
+            }
+            #[cfg(feature = "dim2")]
+            TypedShape::RoundConvexPolygon(s) => {
+                ColliderView::RoundConvexPolygon(RoundConvexPolygonView { raw: s })
+            }
+            #[cfg(feature = "dim3")]
+            TypedShape::RoundCylinder(s) => {
+                ColliderView::RoundCylinder(RoundCylinderView { raw: s })
+            }
+            #[cfg(feature = "dim3")]
+            TypedShape::RoundCone(s) => ColliderView::RoundCone(RoundConeView { raw: s }),
+            #[cfg(feature = "dim3")]
+            TypedShape::RoundConvexPolyhedron(s) => {
+                ColliderView::RoundConvexPolyhedron(RoundConvexPolyhedronView { raw: s })
+            }
+            TypedShape::Custom(s) => ColliderView::Custom(s),
+        }
+    }
+}
+
+impl<'a> From<ColliderView<'a>> for TypedShape<'a> {
+    fn from(collider_view: ColliderView<'a>) -> TypedShape<'a> {
+        collider_view.as_typed_shape()
+    }
+}
+
+impl<'a> From<ColliderView<'a>> for SharedShape {
+    fn from(collider_view: ColliderView<'a>) -> SharedShape {
+        collider_view.to_shared_shape()
+    }
+}
+
+impl<'a> ColliderView<'a> {
+    /// Convert to [`parry::shape::TypedShape`].
+    pub fn as_typed_shape(self) -> TypedShape<'a> {
+        match self {
+            ColliderView::Ball(BallView { raw: s }) => TypedShape::Ball(s),
+            ColliderView::Cuboid(CuboidView { raw: s }) => TypedShape::Cuboid(s),
+            ColliderView::Capsule(CapsuleView { raw: s }) => TypedShape::Capsule(s),
+            ColliderView::Segment(SegmentView { raw: s }) => TypedShape::Segment(s),
+            ColliderView::Triangle(TriangleView { raw: s }) => TypedShape::Triangle(s),
+            ColliderView::Voxels(VoxelsView { raw: s }) => TypedShape::Voxels(s),
+            ColliderView::TriMesh(TriMeshView { raw: s }) => TypedShape::TriMesh(s),
+            ColliderView::Polyline(PolylineView { raw: s }) => TypedShape::Polyline(s),
+            ColliderView::HalfSpace(HalfSpaceView { raw: s }) => TypedShape::HalfSpace(s),
+            ColliderView::HeightField(HeightFieldView { raw: s }) => TypedShape::HeightField(s),
+            ColliderView::Compound(CompoundView { raw: s }) => TypedShape::Compound(s),
+            #[cfg(feature = "dim2")]
+            ColliderView::ConvexPolygon(ConvexPolygonView { raw: s }) => {
+                TypedShape::ConvexPolygon(s)
+            }
+            #[cfg(feature = "dim3")]
+            ColliderView::ConvexPolyhedron(ConvexPolyhedronView { raw: s }) => {
+                TypedShape::ConvexPolyhedron(s)
+            }
+            #[cfg(feature = "dim3")]
+            ColliderView::Cylinder(CylinderView { raw: s }) => TypedShape::Cylinder(s),
+            #[cfg(feature = "dim3")]
+            ColliderView::Cone(ConeView { raw: s }) => TypedShape::Cone(s),
+            ColliderView::RoundCuboid(RoundCuboidView { raw: s }) => TypedShape::RoundCuboid(s),
+            ColliderView::RoundTriangle(RoundTriangleView { raw: s }) => {
+                TypedShape::RoundTriangle(s)
+            }
+            #[cfg(feature = "dim2")]
+            ColliderView::RoundConvexPolygon(RoundConvexPolygonView { raw: s }) => {
+                TypedShape::RoundConvexPolygon(s)
+            }
+            #[cfg(feature = "dim3")]
+            ColliderView::RoundCylinder(RoundCylinderView { raw: s }) => {
+                TypedShape::RoundCylinder(s)
+            }
+            #[cfg(feature = "dim3")]
+            ColliderView::RoundCone(RoundConeView { raw: s }) => TypedShape::RoundCone(s),
+            #[cfg(feature = "dim3")]
+            ColliderView::RoundConvexPolyhedron(RoundConvexPolyhedronView { raw: s }) => {
+                TypedShape::RoundConvexPolyhedron(s)
+            }
+            ColliderView::Custom(s) => TypedShape::Custom(s),
+        }
+    }
+
+    /// Convert to [`parry::shape::SharedShape`].
+    pub fn to_shared_shape(self) -> SharedShape {
+        match self {
+            ColliderView::Ball(BallView { raw }) => SharedShape::new(*raw),
+            ColliderView::Cuboid(CuboidView { raw }) => SharedShape::new(*raw),
+            ColliderView::Capsule(CapsuleView { raw }) => SharedShape::new(*raw),
+            ColliderView::Segment(SegmentView { raw }) => SharedShape::new(*raw),
+            ColliderView::Triangle(TriangleView { raw }) => SharedShape::new(*raw),
+            ColliderView::Voxels(VoxelsView { raw }) => SharedShape::new(raw.clone()),
+            ColliderView::TriMesh(TriMeshView { raw }) => SharedShape::new(raw.clone()),
+            ColliderView::Polyline(PolylineView { raw }) => SharedShape::new(raw.clone()),
+            ColliderView::HalfSpace(HalfSpaceView { raw }) => SharedShape::new(*raw),
+            ColliderView::HeightField(HeightFieldView { raw }) => SharedShape::new(raw.clone()),
+            ColliderView::Compound(CompoundView { raw }) => SharedShape::new(raw.clone()),
+            #[cfg(feature = "dim2")]
+            ColliderView::ConvexPolygon(ConvexPolygonView { raw }) => SharedShape::new(raw.clone()),
+            #[cfg(feature = "dim3")]
+            ColliderView::ConvexPolyhedron(ConvexPolyhedronView { raw }) => {
+                SharedShape::new(raw.clone())
+            }
+            #[cfg(feature = "dim3")]
+            ColliderView::Cylinder(CylinderView { raw }) => SharedShape::new(*raw),
+            #[cfg(feature = "dim3")]
+            ColliderView::Cone(ConeView { raw }) => SharedShape::new(*raw),
+            ColliderView::RoundCuboid(RoundCuboidView { raw }) => SharedShape::new(*raw),
+            ColliderView::RoundTriangle(RoundTriangleView { raw }) => SharedShape::new(*raw),
+            #[cfg(feature = "dim2")]
+            ColliderView::RoundConvexPolygon(RoundConvexPolygonView { raw }) => {
+                SharedShape::new(raw.clone())
+            }
+            #[cfg(feature = "dim3")]
+            ColliderView::RoundCylinder(RoundCylinderView { raw }) => SharedShape::new(*raw),
+            #[cfg(feature = "dim3")]
+            ColliderView::RoundCone(RoundConeView { raw }) => SharedShape::new(*raw),
+            #[cfg(feature = "dim3")]
+            ColliderView::RoundConvexPolyhedron(RoundConvexPolyhedronView { raw }) => {
+                SharedShape::new(raw.clone())
+            }
+            ColliderView::Custom(raw) => SharedShape(raw.clone_dyn().into()),
+        }
+    }
+
+    /// Compute the scaled version of `self.raw`.
+    pub fn raw_scale_by(&self, scale: Vect, num_subdivisions: u32) -> Option<SharedShape> {
+        let result = match self {
+            ColliderView::Cuboid(s) => SharedShape::new(s.raw.scaled(scale)),
+            ColliderView::RoundCuboid(s) => SharedShape::new(RoundShape {
+                border_radius: s.raw.border_radius,
+                inner_shape: s.raw.inner_shape.scaled(scale),
+            }),
+            ColliderView::Capsule(c) => match c.raw.scaled(scale, num_subdivisions) {
+                None => {
+                    log::error!("Failed to apply scale {scale} to Capsule shape.");
+                    SharedShape::ball(0.0)
+                }
+                Some(Either::Left(b)) => SharedShape::new(b),
+                Some(Either::Right(b)) => SharedShape::new(b),
+            },
+            ColliderView::Ball(b) => match b.raw.scaled(scale, num_subdivisions) {
+                None => {
+                    log::error!("Failed to apply scale {scale} to Ball shape.");
+                    SharedShape::ball(0.0)
+                }
+                Some(Either::Left(b)) => SharedShape::new(b),
+                Some(Either::Right(b)) => SharedShape::new(b),
+            },
+            ColliderView::Segment(s) => SharedShape::new(s.raw.scaled(scale)),
+            ColliderView::Triangle(t) => SharedShape::new(t.raw.scaled(scale)),
+            ColliderView::Voxels(cp) => SharedShape::new(cp.raw.clone().scaled(scale)),
+            ColliderView::RoundTriangle(t) => SharedShape::new(RoundShape {
+                border_radius: t.raw.border_radius,
+                inner_shape: t.raw.inner_shape.scaled(scale),
+            }),
+            ColliderView::TriMesh(t) => SharedShape::new(t.raw.clone().scaled(scale)),
+            ColliderView::Polyline(p) => SharedShape::new(p.raw.clone().scaled(scale)),
+            ColliderView::HalfSpace(h) => match h.raw.scaled(scale) {
+                None => {
+                    log::error!("Failed to apply scale {scale} to HalfSpace shape.");
+                    SharedShape::ball(0.0)
+                }
+                Some(scaled) => SharedShape::new(scaled),
+            },
+            ColliderView::HeightField(h) => SharedShape::new(h.raw.clone().scaled(scale)),
+            #[cfg(feature = "dim2")]
+            ColliderView::ConvexPolygon(cp) => match cp.raw.clone().scaled(scale) {
+                None => {
+                    log::error!("Failed to apply scale {scale} to ConvexPolygon shape.");
+                    SharedShape::ball(0.0)
+                }
+                Some(scaled) => SharedShape::new(scaled),
+            },
+            #[cfg(feature = "dim2")]
+            ColliderView::RoundConvexPolygon(cp) => {
+                match cp.raw.inner_shape.clone().scaled(scale) {
+                    None => {
+                        log::error!("Failed to apply scale {scale} to RoundConvexPolygon shape.");
+                        SharedShape::ball(0.0)
+                    }
+                    Some(scaled) => SharedShape::new(RoundShape {
+                        border_radius: cp.raw.border_radius,
+                        inner_shape: scaled,
+                    }),
+                }
+            }
+            #[cfg(feature = "dim3")]
+            ColliderView::ConvexPolyhedron(cp) => match cp.raw.clone().scaled(scale) {
+                None => {
+                    log::error!("Failed to apply scale {scale} to ConvexPolyhedron shape.");
+                    SharedShape::ball(0.0)
+                }
+                Some(scaled) => SharedShape::new(scaled),
+            },
+            #[cfg(feature = "dim3")]
+            ColliderView::RoundConvexPolyhedron(cp) => {
+                match cp.raw.clone().inner_shape.scaled(scale) {
+                    None => {
+                        log::error!(
+                            "Failed to apply scale {scale} to RoundConvexPolyhedron shape."
+                        );
+                        SharedShape::ball(0.0)
+                    }
+                    Some(scaled) => SharedShape::new(RoundShape {
+                        border_radius: cp.raw.border_radius,
+                        inner_shape: scaled,
+                    }),
+                }
+            }
+            #[cfg(feature = "dim3")]
+            ColliderView::Cylinder(c) => match c.raw.scaled(scale, num_subdivisions) {
+                None => {
+                    log::error!("Failed to apply scale {scale} to Cylinder shape.");
+                    SharedShape::ball(0.0)
+                }
+                Some(Either::Left(b)) => SharedShape::new(b),
+                Some(Either::Right(b)) => SharedShape::new(b),
+            },
+            #[cfg(feature = "dim3")]
+            ColliderView::RoundCylinder(c) => {
+                match c.raw.inner_shape.scaled(scale, num_subdivisions) {
+                    None => {
+                        log::error!("Failed to apply scale {scale} to RoundCylinder shape.");
+                        SharedShape::ball(0.0)
+                    }
+                    Some(Either::Left(scaled)) => SharedShape::new(RoundShape {
+                        border_radius: c.raw.border_radius,
+                        inner_shape: scaled,
+                    }),
+                    Some(Either::Right(scaled)) => SharedShape::new(RoundShape {
+                        border_radius: c.raw.border_radius,
+                        inner_shape: scaled,
+                    }),
+                }
+            }
+            #[cfg(feature = "dim3")]
+            ColliderView::Cone(c) => match c.raw.scaled(scale, num_subdivisions) {
+                None => {
+                    log::error!("Failed to apply scale {scale} to Cone shape.");
+                    SharedShape::ball(0.0)
+                }
+                Some(Either::Left(b)) => SharedShape::new(b),
+                Some(Either::Right(b)) => SharedShape::new(b),
+            },
+            #[cfg(feature = "dim3")]
+            ColliderView::RoundCone(c) => match c.raw.inner_shape.scaled(scale, num_subdivisions) {
+                None => {
+                    log::error!("Failed to apply scale {scale} to RoundCone shape.");
+                    SharedShape::ball(0.0)
+                }
+                Some(Either::Left(scaled)) => SharedShape::new(RoundShape {
+                    border_radius: c.raw.border_radius,
+                    inner_shape: scaled,
+                }),
+                Some(Either::Right(scaled)) => SharedShape::new(RoundShape {
+                    border_radius: c.raw.border_radius,
+                    inner_shape: scaled,
+                }),
+            },
+            ColliderView::Compound(c) => {
+                let mut scaled = Vec::with_capacity(c.shapes().len());
+
+                for (tra, rot, shape) in c.shapes() {
+                    scaled.push((
+                        crate::utils::pose_from(tra * scale, rot),
+                        shape.raw_scale_by(scale, num_subdivisions)?,
+                    ));
+                }
+                SharedShape::compound(scaled)
+            }
+            ColliderView::Custom(s) => SharedShape(s.scale_dyn(scale, num_subdivisions)?.into()),
+        };
+
+        Some(result)
+    }
+}
diff --git a/bindings/bevy_rapier/src/geometry/shape_views/compound.rs b/bindings/bevy_rapier/src/geometry/shape_views/compound.rs
new file mode 100644
index 000000000..c78353ae8
--- /dev/null
+++ b/bindings/bevy_rapier/src/geometry/shape_views/compound.rs
@@ -0,0 +1,56 @@
+use super::ColliderView;
+use crate::math::{Real, Rot, Vect};
+use rapier::parry::shape::{Compound, CompoundFlags};
+
+/// Read-only access to the properties of a compound shape.
+#[derive(Copy, Clone)]
+pub struct CompoundView<'a> {
+    /// The raw shape from Rapier.
+    pub raw: &'a Compound,
+}
+
+macro_rules! impl_ref_methods(
+    ($View: ident) => {
+        impl<'a> $View<'a> {
+            /// The shapes of this compound shape.
+            #[inline]
+            pub fn shapes(&self) -> impl ExactSizeIterator<Item = (Vect, Rot, ColliderView<'_>)> {
+                self.raw.shapes().iter().map(|(pos, shape)| {
+                    #[cfg(feature = "dim2")]
+                    let rot = pos.rotation.angle();
+                    #[cfg(feature = "dim3")]
+                    let rot = pos.rotation;
+                    (pos.translation, rot, shape.as_typed_shape().into())
+                })
+            }
+
+            /// The flags controlling the optional data associated to this compound shape.
+            pub fn flags(&self) -> CompoundFlags {
+                self.raw.flags()
+            }
+        }
+    }
+);
+
+impl_ref_methods!(CompoundView);
+
+/// Read-write access to the properties of a compound shape.
+///
+/// The parts of the compound shape are shared and cannot be modified through this view.
+pub struct CompoundViewMut<'a> {
+    /// The raw shape from Rapier.
+    pub raw: &'a mut Compound,
+}
+
+impl_ref_methods!(CompoundViewMut);
+
+impl CompoundViewMut<'_> {
+    /// Sets the flags of this compound shape, computing or discarding its optional
+    /// associated data.
+    ///
+    /// `weld_tolerance` is the distance (in ULPs) under which two corners of different parts
+    /// are considered equal when detecting internal edges; `None` selects parry's default.
+    pub fn set_flags(&mut self, flags: CompoundFlags, weld_tolerance: Option<Real>) {
+        self.raw.set_flags(flags, weld_tolerance)
+    }
+}
diff --git a/bindings/bevy_rapier/src/geometry/shape_views/cone.rs b/bindings/bevy_rapier/src/geometry/shape_views/cone.rs
new file mode 100644
index 000000000..3dc5798e1
--- /dev/null
+++ b/bindings/bevy_rapier/src/geometry/shape_views/cone.rs
@@ -0,0 +1,47 @@
+use crate::math::Real;
+use rapier::parry::shape::Cone;
+
+/// Read-only access to the properties of a cone.
+#[derive(Copy, Clone)]
+pub struct ConeView<'a> {
+    /// The raw shape from Rapier.
+    pub raw: &'a Cone,
+}
+
+macro_rules! impl_ref_methods(
+    ($View: ident) => {
+        impl<'a> $View<'a> {
+            /// The half-height of the cone.
+            pub fn half_height(&self) -> Real {
+                self.raw.half_height
+            }
+
+            /// The base radius of the cone.
+            pub fn radius(&self) -> Real {
+                self.raw.radius
+            }
+        }
+    }
+);
+
+impl_ref_methods!(ConeView);
+
+/// Read-write access to the properties of a cone.
+pub struct ConeViewMut<'a> {
+    /// The raw shape from Rapier.
+    pub raw: &'a mut Cone,
+}
+
+impl_ref_methods!(ConeViewMut);
+
+impl ConeViewMut<'_> {
+    /// Set the half-height of the cone.
+    pub fn set_half_height(&mut self, half_height: Real) {
+        self.raw.half_height = half_height;
+    }
+
+    /// Set the radius of the basis of the cone.
+    pub fn set_radius(&mut self, radius: Real) {
+        self.raw.radius = radius;
+    }
+}
diff --git a/bindings/bevy_rapier/src/geometry/shape_views/convex_polygon.rs b/bindings/bevy_rapier/src/geometry/shape_views/convex_polygon.rs
new file mode 100644
index 000000000..b03d4f70a
--- /dev/null
+++ b/bindings/bevy_rapier/src/geometry/shape_views/convex_polygon.rs
@@ -0,0 +1,41 @@
+use crate::math::Vect;
+use rapier::parry::shape::ConvexPolygon;
+
+/// Read-only access to the properties of a convex polygon.
+#[derive(Copy, Clone)]
+pub struct ConvexPolygonView<'a> {
+    /// The raw shape from Rapier.
+    pub raw: &'a ConvexPolygon,
+}
+
+impl ConvexPolygonView<'_> {
+    /// The vertices of this convex polygon.
+    pub fn points(&self) -> impl ExactSizeIterator<Item = Vect> + '_ {
+        self.raw.points().iter().copied()
+    }
+
+    /// The normals of the edges of this convex polygon.
+    pub fn normals(&self) -> impl ExactSizeIterator<Item = Vect> + '_ {
+        self.raw.normals().iter().copied()
+    }
+}
+
+/// Read-write access to the properties of a convex polygon.
+pub struct ConvexPolygonViewMut<'a> {
+    /// The raw shape from Rapier.
+    pub raw: &'a mut ConvexPolygon,
+}
+
+impl ConvexPolygonViewMut<'_> {
+    /// The vertices of this convex polygon.
+    pub fn points(&self) -> impl ExactSizeIterator<Item = Vect> + '_ {
+        self.raw.points().iter().copied()
+    }
+
+    /// The normals of the edges of this convex polygon.
+    pub fn normals(&self) -> impl ExactSizeIterator<Item = Vect> + '_ {
+        self.raw.normals().iter().copied()
+    }
+
+    // TODO: add modifications.
+}
diff --git a/bindings/bevy_rapier/src/geometry/shape_views/convex_polyhedron.rs b/bindings/bevy_rapier/src/geometry/shape_views/convex_polyhedron.rs
new file mode 100644
index 000000000..247f116dc
--- /dev/null
+++ b/bindings/bevy_rapier/src/geometry/shape_views/convex_polyhedron.rs
@@ -0,0 +1,106 @@
+use crate::math::Vect;
+use rapier::parry::shape::ConvexPolyhedron;
+
+/// Read-only access to the properties of a convex polyhedron.
+#[derive(Copy, Clone)]
+pub struct ConvexPolyhedronView<'a> {
+    /// The raw shape from Rapier.
+    pub raw: &'a ConvexPolyhedron,
+}
+
+macro_rules! impl_ref_methods(
+    ($View: ident) => {
+        impl<'a> $View<'a> {
+            /// The vertices of this convex polyhedron.
+            pub fn points(&self) -> impl ExactSizeIterator<Item = Vect> + '_ {
+                self.raw.points().iter().copied()
+            }
+
+            /// The number of vertices of this convex polyhedron.
+            pub fn num_vertices(&self) -> usize {
+                self.raw.vertices().len()
+            }
+
+            /// The indices of the edges of this convex polyhedron.
+            ///
+            /// The internal storage also contains edges between coplanar triangles merged into
+            /// the same polygonal face; those are skipped here.
+            pub fn edges(&self) -> impl Iterator<Item = u32> + '_ {
+                self.raw
+                    .edges()
+                    .iter()
+                    .enumerate()
+                    .filter(|(_, edge)| edge.faces[0] != edge.faces[1])
+                    .map(|(i, _)| i as u32)
+            }
+
+            /// The number of (polygonal) faces of this convex polyhedron.
+            pub fn num_faces(&self) -> usize {
+                self.raw.faces().len()
+            }
+
+            /// The indices of the faces adjacent to the `i`-th vertex.
+            pub fn vertex_adjacent_faces(&self, i: usize) -> &[u32] {
+                let vertex = &self.raw.vertices()[i];
+                let first = vertex.first_adj_face_or_edge as usize;
+                let num = vertex.num_adj_faces_or_edge as usize;
+                &self.raw.faces_adj_to_vertex()[first..first + num]
+            }
+
+            /// The indices of the two endpoints of the `i`-th edge (indexing [`Self::points`]).
+            pub fn edge_vertices(&self, i: usize) -> [u32; 2] {
+                self.raw.edges()[i].vertices
+            }
+
+            /// The indices of the two faces adjacent to the `i`-th edge.
+            pub fn edge_faces(&self, i: usize) -> [u32; 2] {
+                self.raw.edges()[i].faces
+            }
+
+            /// The unit direction of the `i`-th edge, from its first to its second vertex.
+            pub fn edge_direction(&self, i: usize) -> Vect {
+                self.raw.edges()[i].dir
+            }
+
+            /// The outward unit normal of the `i`-th face.
+            pub fn face_normal(&self, i: usize) -> Vect {
+                self.raw.faces()[i].normal
+            }
+
+            /// The indices of the vertices of the `i`-th face (indexing [`Self::points`]).
+            pub fn face_vertices(&self, i: usize) -> &[u32] {
+                let face = &self.raw.faces()[i];
+                let first = face.first_vertex_or_edge as usize;
+                let num = face.num_vertices_or_edges as usize;
+                &self.raw.vertices_adj_to_face()[first..first + num]
+            }
+
+            /// The indices of the edges of the `i`-th face.
+            pub fn face_edges(&self, i: usize) -> &[u32] {
+                let face = &self.raw.faces()[i];
+                let first = face.first_vertex_or_edge as usize;
+                let num = face.num_vertices_or_edges as usize;
+                &self.raw.edges_adj_to_face()[first..first + num]
+            }
+
+            /// Triangulates the boundary of this convex polyhedron, returning its vertex and
+            /// index buffers.
+            pub fn to_trimesh(&self) -> (Vec<Vect>, Vec<[u32; 3]>) {
+                self.raw.to_trimesh()
+            }
+        }
+    }
+);
+
+impl_ref_methods!(ConvexPolyhedronView);
+
+/// Read-write access to the properties of a convex polyhedron.
+///
+/// Parry does not offer any in-place modification of convex polyhedra, so this view is
+/// read-only in practice.
+pub struct ConvexPolyhedronViewMut<'a> {
+    /// The raw shape from Rapier.
+    pub raw: &'a mut ConvexPolyhedron,
+}
+
+impl_ref_methods!(ConvexPolyhedronViewMut);
diff --git a/bindings/bevy_rapier/src/geometry/shape_views/cuboid.rs b/bindings/bevy_rapier/src/geometry/shape_views/cuboid.rs
new file mode 100644
index 000000000..523da39ba
--- /dev/null
+++ b/bindings/bevy_rapier/src/geometry/shape_views/cuboid.rs
@@ -0,0 +1,37 @@
+use crate::math::Vect;
+use rapier::geometry::Cuboid;
+
+/// Read-only access to the properties of a cuboid.
+#[derive(Copy, Clone)]
+pub struct CuboidView<'a> {
+    /// The raw shape from Rapier.
+    pub raw: &'a Cuboid,
+}
+
+macro_rules! impl_ref_methods(
+    ($View: ident) => {
+        impl<'a> $View<'a> {
+            /// The half-extents of the cuboid.
+            pub fn half_extents(&self) -> Vect {
+                self.raw.half_extents.into()
+            }
+        }
+    }
+);
+
+impl_ref_methods!(CuboidView);
+
+/// Read-write access to the properties of a cuboid.
+pub struct CuboidViewMut<'a> {
+    /// The raw shape from Rapier.
+    pub raw: &'a mut Cuboid,
+}
+
+impl_ref_methods!(CuboidViewMut);
+
+impl CuboidViewMut<'_> {
+    /// Set the half-extents of the cuboid.
+    pub fn set_half_extents(&mut self, half_extents: Vect) {
+        self.raw.half_extents = half_extents;
+    }
+}
diff --git a/bindings/bevy_rapier/src/geometry/shape_views/cylinder.rs b/bindings/bevy_rapier/src/geometry/shape_views/cylinder.rs
new file mode 100644
index 000000000..2c2810a1f
--- /dev/null
+++ b/bindings/bevy_rapier/src/geometry/shape_views/cylinder.rs
@@ -0,0 +1,47 @@
+use crate::math::Real;
+use rapier::parry::shape::Cylinder;
+
+/// Read-only access to the properties of a cylinder.
+#[derive(Copy, Clone)]
+pub struct CylinderView<'a> {
+    /// The raw shape from Rapier.
+    pub raw: &'a Cylinder,
+}
+
+macro_rules! impl_ref_methods(
+    ($View: ident) => {
+        impl<'a> $View<'a> {
+            /// The half-height of the cylinder.
+            pub fn half_height(&self) -> Real {
+                self.raw.half_height
+            }
+
+            /// The base radius of the cylinder.
+            pub fn radius(&self) -> Real {
+                self.raw.radius
+            }
+        }
+    }
+);
+
+impl_ref_methods!(CylinderView);
+
+/// Read-write access to the properties of a cylinder.
+pub struct CylinderViewMut<'a> {
+    /// The raw shape from Rapier.
+    pub raw: &'a mut Cylinder,
+}
+
+impl_ref_methods!(CylinderViewMut);
+
+impl CylinderViewMut<'_> {
+    /// Set the half-height of the cylinder.
+    pub fn set_half_height(&mut self, half_height: Real) {
+        self.raw.half_height = half_height;
+    }
+
+    /// Set the radius of the basis of the cylinder.
+    pub fn set_radius(&mut self, radius: Real) {
+        self.raw.radius = radius;
+    }
+}
diff --git a/bindings/bevy_rapier/src/geometry/shape_views/halfspace.rs b/bindings/bevy_rapier/src/geometry/shape_views/halfspace.rs
new file mode 100644
index 000000000..4ddce2b6c
--- /dev/null
+++ b/bindings/bevy_rapier/src/geometry/shape_views/halfspace.rs
@@ -0,0 +1,40 @@
+use crate::math::Vect;
+use rapier::parry::shape::HalfSpace;
+
+/// Read-only access to the properties of a half-space.
+#[derive(Copy, Clone)]
+pub struct HalfSpaceView<'a> {
+    /// The raw shape from Rapier.
+    pub raw: &'a HalfSpace,
+}
+
+macro_rules! impl_ref_methods(
+    ($View: ident) => {
+        impl<'a> $View<'a> {
+            /// The halfspace planar boundary's outward normal.
+            pub fn normal(&self) -> Vect {
+                self.raw.normal
+            }
+        }
+    }
+);
+
+impl_ref_methods!(HalfSpaceView);
+
+/// Read-write access to the properties of a half-space.
+pub struct HalfSpaceViewMut<'a> {
+    /// The raw shape from Rapier.
+    pub raw: &'a mut HalfSpace,
+}
+
+impl_ref_methods!(HalfSpaceViewMut);
+
+impl HalfSpaceViewMut<'_> {
+    /// Set the normal of the half-space.
+    pub fn set_normal(&mut self, normal: Vect) {
+        let normal: rapier::math::Vector = normal;
+        if normal.length_squared() >= 1.0e-12 {
+            self.raw.normal = normal.normalize();
+        }
+    }
+}
diff --git a/bindings/bevy_rapier/src/geometry/shape_views/heightfield.rs b/bindings/bevy_rapier/src/geometry/shape_views/heightfield.rs
new file mode 100644
index 000000000..b321e4868
--- /dev/null
+++ b/bindings/bevy_rapier/src/geometry/shape_views/heightfield.rs
@@ -0,0 +1,197 @@
+use crate::math::{Real, Vect};
+use rapier::parry::shape::HeightField;
+pub use rapier::parry::shape::HeightFieldCellStatus;
+#[cfg(feature = "dim3")]
+use rapier::parry::shape::HeightFieldFlags;
+
+/// Read-only access to the properties of a heightfield.
+#[derive(Copy, Clone)]
+pub struct HeightFieldView<'a> {
+    /// The raw shape from Rapier.
+    pub raw: &'a HeightField,
+}
+
+macro_rules! impl_ref_methods(
+    ($View: ident) => {
+        #[cfg(feature = "dim2")]
+        impl<'a> $View<'a> {
+            /// The number of cells of this heightfield.
+            pub fn num_cells(&self) -> usize {
+                self.raw.num_cells()
+            }
+
+            /// The height at each cell endpoint.
+            pub fn heights(&self) -> &[Real] {
+                self.raw.heights().as_slice()
+            }
+
+            /// The scale factor applied to this heightfield.
+            pub fn scale(&self) -> Vect {
+                self.raw.scale()
+            }
+
+            /// The width of a single cell of this heightfield.
+            pub fn cell_width(&self) -> Real {
+                self.raw.cell_width()
+            }
+
+            /// The width of a single cell of this heightfield, without taking the scale factor into account.
+            pub fn unit_cell_width(&self) -> Real {
+                self.raw.unit_cell_width()
+            }
+
+            /// Index of the cell a point is on after vertical projection.
+            pub fn cell_at_point(&self, point: Vect) -> Option<usize> {
+                self.raw.cell_at_point(point)
+            }
+
+            /// The height of the heightfield at the given point after vertical projection, or
+            /// `None` if the point is outside of the heightfield's domain.
+            pub fn height_at_point(&self, point: Vect) -> Option<Real> {
+                self.raw.height_at_point(point)
+            }
+
+            /// Iterator through all the segments of this heightfield.
+            pub fn segments(&self) -> impl Iterator<Item = (Vect, Vect)> + '_ {
+                self.raw.segments().map(|seg| (seg.a, seg.b))
+            }
+
+            /// The i-th segment of the heightfield if it has not been removed.
+            pub fn segment_at(&self, i: usize) -> Option<(Vect, Vect)> {
+                self.raw.segment_at(i).map(|seg| (seg.a, seg.b))
+            }
+
+            /// Is the i-th segment of this heightfield removed?
+            pub fn is_segment_removed(&self, i: usize) -> bool {
+                self.raw.is_segment_removed(i)
+            }
+        }
+
+        #[cfg(feature = "dim3")]
+        impl<'a> $View<'a> {
+            /// The number of rows of this heightfield.
+            pub fn nrows(&self) -> usize {
+                self.raw.nrows()
+            }
+
+            /// The number of columns of this heightfield.
+            pub fn ncols(&self) -> usize {
+                self.raw.ncols()
+            }
+
+            /// The height at each cell endpoint.
+            pub fn heights(&self) -> &[Real] {
+                self.raw.heights().data()
+            }
+
+            /// The scale factor applied to this heightfield.
+            pub fn scale(&self) -> Vect {
+                self.raw.scale()
+            }
+
+            /// The width (extent along its local `x` axis) of each cell of this heightmap, including the scale factor.
+            pub fn cell_width(&self) -> Real {
+                self.raw.cell_width()
+            }
+
+            /// The height (extent along its local `z` axis) of each cell of this heightmap, including the scale factor.
+            pub fn cell_height(&self) -> Real {
+                self.raw.cell_height()
+            }
+
+            /// The width (extent along its local `x` axis) of each cell of this heightmap, excluding the scale factor.
+            pub fn unit_cell_width(&self) -> Real {
+                self.raw.unit_cell_width()
+            }
+
+            /// The height (extent along its local `z` axis) of each cell of this heightmap, excluding the scale factor.
+            pub fn unit_cell_height(&self) -> Real {
+                self.raw.unit_cell_height()
+            }
+
+            /// Index of the cell a point is on after vertical projection.
+            pub fn cell_at_point(&self, point: Vect) -> Option<(usize, usize)> {
+                self.raw.cell_at_point(point)
+            }
+
+            /// Iterator through all the triangles of this heightfield.
+            pub fn triangles(&self) -> impl Iterator<Item = (Vect, Vect, Vect)> + '_ {
+                self.raw.triangles().map(|tri| (tri.a, tri.b, tri.c))
+            }
+
+            /// The two triangles at the cell (i, j) of this heightfield.
+            ///
+            /// Returns `None` fore triangles that have been removed because of their user-defined status
+            /// flags (described by the `HeightFieldCellStatus` bitfield).
+            pub fn triangles_at(
+                &self,
+                i: usize,
+                j: usize,
+            ) -> (Option<(Vect, Vect, Vect)>, Option<(Vect, Vect, Vect)>) {
+                let (tri1, tri2) = self.raw.triangles_at(i, j);
+                (
+                    tri1.map(|tri| (tri.a, tri.b, tri.c)),
+                    tri2.map(|tri| (tri.a, tri.b, tri.c)),
+                )
+            }
+
+            /// The status of the `(i, j)`-th cell.
+            pub fn cell_status(&self, i: usize, j: usize) -> HeightFieldCellStatus {
+                self.raw.cell_status(i, j)
+            }
+
+            /// The statuses of all the cells of this heightfield, in column-major order.
+            pub fn cells_statuses(&self) -> &[HeightFieldCellStatus] {
+                self.raw.cells_statuses().data()
+            }
+
+            /// The flags controlling the contact behavior of this heightfield.
+            pub fn flags(&self) -> HeightFieldFlags {
+                self.raw.flags()
+            }
+        }
+    }
+);
+
+impl_ref_methods!(HeightFieldView);
+
+/// Read-write access to the properties of a heightfield.
+pub struct HeightFieldViewMut<'a> {
+    /// The raw shape from Rapier.
+    pub raw: &'a mut HeightField,
+}
+
+impl_ref_methods!(HeightFieldViewMut);
+
+impl HeightFieldViewMut<'_> {
+    /// Sets the scale factor applied to this heightfield.
+    pub fn set_scale(&mut self, new_scale: Vect) {
+        self.raw.set_scale(new_scale)
+    }
+}
+
+#[cfg(feature = "dim2")]
+impl HeightFieldViewMut<'_> {
+    /// Sets whether or not the given cell of the heightfield is deleted.
+    pub fn set_segment_removed(&mut self, i: usize, removed: bool) {
+        self.raw.set_segment_removed(i, removed)
+    }
+}
+
+#[cfg(feature = "dim3")]
+impl HeightFieldViewMut<'_> {
+    /// Set the status of the `(i, j)`-th cell.
+    pub fn set_cell_status(&mut self, i: usize, j: usize, status: HeightFieldCellStatus) {
+        self.raw.set_cell_status(i, j, status)
+    }
+
+    /// The mutable statuses of all the cells of this heightfield.
+    pub fn cells_statuses_mut(&mut self) -> &mut [HeightFieldCellStatus] {
+        self.raw.cells_statuses_mut().data_mut()
+    }
+
+    /// Sets the flags controlling the contact behavior of this heightfield.
+    pub fn set_flags(&mut self, flags: HeightFieldFlags) {
+        self.raw.set_flags(flags)
+    }
+}
diff --git a/bindings/bevy_rapier/src/geometry/shape_views/mod.rs b/bindings/bevy_rapier/src/geometry/shape_views/mod.rs
new file mode 100644
index 000000000..03885bbf2
--- /dev/null
+++ b/bindings/bevy_rapier/src/geometry/shape_views/mod.rs
@@ -0,0 +1,43 @@
+pub use self::ball::*;
+pub use self::capsule::*;
+pub use self::collider_view::*;
+pub use self::compound::*;
+pub use self::cuboid::*;
+pub use self::halfspace::*;
+pub use self::heightfield::*;
+pub use self::polyline::*;
+pub use self::round_shape::*;
+pub use self::segment::*;
+pub use self::triangle::*;
+pub use self::trimesh::*;
+pub use self::voxels::*;
+
+#[cfg(feature = "dim2")]
+pub use self::convex_polygon::*;
+
+#[cfg(feature = "dim3")]
+pub use self::{cone::*, convex_polyhedron::*, cylinder::*};
+
+mod ball;
+mod capsule;
+mod collider_view;
+mod compound;
+mod cuboid;
+mod halfspace;
+mod heightfield;
+mod polyline;
+mod round_shape;
+mod segment;
+mod triangle;
+mod trimesh;
+mod voxels;
+
+#[cfg(feature = "dim2")]
+mod convex_polygon;
+
+#[cfg(feature = "dim3")]
+mod cone;
+#[cfg(feature = "dim3")]
+mod convex_polyhedron;
+#[cfg(feature = "dim3")]
+mod cylinder;
diff --git a/bindings/bevy_rapier/src/geometry/shape_views/polyline.rs b/bindings/bevy_rapier/src/geometry/shape_views/polyline.rs
new file mode 100644
index 000000000..ad0a40e1b
--- /dev/null
+++ b/bindings/bevy_rapier/src/geometry/shape_views/polyline.rs
@@ -0,0 +1,97 @@
+use crate::math::Vect;
+use rapier::parry::shape::{Polyline, PolylineFlags};
+
+/// Read-only access to the properties of a polyline.
+#[derive(Copy, Clone)]
+pub struct PolylineView<'a> {
+    /// The raw shape from Rapier.
+    pub raw: &'a Polyline,
+}
+
+macro_rules! impl_ref_methods(
+    ($View: ident) => {
+        impl<'a> $View<'a> {
+            /// The number of segments forming this polyline.
+            pub fn num_segments(&self) -> usize {
+                self.raw.num_segments()
+            }
+
+            /// An iterator through all the segments of this mesh.
+            pub fn segments(&self) -> impl ExactSizeIterator<Item = (Vect, Vect)> + '_ {
+                self.raw.segments().map(|seg| (seg.a.into(), seg.b.into()))
+            }
+
+            /// Get the `i`-th segment of this mesh.
+            pub fn segment(&self, i: u32) -> (Vect, Vect) {
+                let seg = self.raw.segment(i);
+                (seg.a.into(), seg.b.into())
+            }
+
+            /// The vertex buffer, containing all the vertices of this polyline.
+            pub fn vertices(&self) -> impl ExactSizeIterator<Item = Vect> + '_ {
+                self.raw.vertices().iter().map(|v| (*v).into())
+            }
+
+            /// The index buffer, describing all the segments of this polyline.
+            pub fn indices(&self) -> &[[u32; 2]] {
+                self.raw.indices()
+            }
+
+            /// The flags controlling the optional data associated to this polyline.
+            pub fn flags(&self) -> PolylineFlags {
+                self.raw.flags()
+            }
+
+            /// The outward pseudo-normal of each vertex, if this polyline is oriented.
+            ///
+            /// The pseudo-normals are only computed with the [`PolylineFlags::ORIENTED`] flag.
+            /// The returned slice is indexed like [`Self::vertices`].
+            #[cfg(feature = "dim2")]
+            pub fn pseudo_normals(&self) -> Option<&[Vect]> {
+                self.raw.pseudo_normals()
+            }
+        }
+    }
+);
+
+impl_ref_methods!(PolylineView);
+
+/// Read-write access to the properties of a polyline.
+pub struct PolylineViewMut<'a> {
+    /// The raw shape from Rapier.
+    pub raw: &'a mut Polyline,
+}
+
+impl_ref_methods!(PolylineViewMut);
+
+impl PolylineViewMut<'_> {
+    /// Reverse the orientation of this polyline by swapping the indices of all
+    /// its segments and reverting its index buffer.
+    pub fn reverse(&mut self) {
+        self.raw.reverse()
+    }
+
+    /// Sets the flags of this polyline, computing or discarding its optional associated data.
+    pub fn set_flags(&mut self, flags: PolylineFlags) {
+        self.raw.set_flags(flags)
+    }
+
+    /// Replaces the vertex positions, keeping the index buffer.
+    ///
+    /// The acceleration structure is refitted and the pseudo-normals (if any) are recomputed.
+    /// This is intended for polylines built with [`PolylineFlags::DEFORMABLE`].
+    ///
+    /// # Panics
+    /// Panics if `vertices.len()` differs from the current number of vertices.
+    pub fn set_vertices(&mut self, vertices: &[Vect]) {
+        self.raw.set_vertices(vertices)
+    }
+
+    /// Modifies the vertex positions in place through `f`, then refits the acceleration
+    /// structure and recomputes the pseudo-normals (if any).
+    ///
+    /// This is intended for polylines built with [`PolylineFlags::DEFORMABLE`].
+    pub fn update_vertices(&mut self, f: impl FnOnce(&mut [Vect])) {
+        self.raw.update_vertices(f)
+    }
+}
diff --git a/bindings/bevy_rapier/src/geometry/shape_views/round_shape.rs b/bindings/bevy_rapier/src/geometry/shape_views/round_shape.rs
new file mode 100644
index 000000000..d1d2ed5ab
--- /dev/null
+++ b/bindings/bevy_rapier/src/geometry/shape_views/round_shape.rs
@@ -0,0 +1,119 @@
+use crate::geometry::shape_views::{CuboidView, CuboidViewMut, TriangleView, TriangleViewMut};
+use rapier::geometry::{RoundCuboid, RoundTriangle};
+
+#[cfg(feature = "dim2")]
+use {
+    crate::geometry::shape_views::{ConvexPolygonView, ConvexPolygonViewMut},
+    rapier::geometry::RoundConvexPolygon,
+};
+
+#[cfg(feature = "dim3")]
+use {
+    crate::geometry::shape_views::{
+        ConeView, ConeViewMut, ConvexPolyhedronView, ConvexPolyhedronViewMut, CylinderView,
+        CylinderViewMut,
+    },
+    rapier::geometry::{RoundCone, RoundConvexPolyhedron, RoundCylinder},
+};
+
+macro_rules!  round_shape_view(
+    ($RoundShape: ident, $RoundShapeView: ident, $ShapeView: ident, $RoundShapeViewMut: ident, $ShapeViewMut: ident) => {
+        /// Read-only access to the properties of a round shape.
+        #[derive(Copy, Clone)]
+        pub struct $RoundShapeView<'a> {
+            /// The raw shape from Rapier.
+            pub raw: &'a $RoundShape,
+        }
+
+        impl<'a> $RoundShapeView<'a> {
+            /// The radius of the round border of this shape.
+            pub fn border_radius(&self) -> f32 {
+                self.raw.border_radius
+            }
+
+            /// The underlying not-rounded shape.
+            pub fn inner_shape(&self) -> $ShapeView<'_> {
+                $ShapeView {
+                    raw: &self.raw.inner_shape,
+                }
+            }
+        }
+
+        /// Read-write access to the properties of a round shape.
+        pub struct $RoundShapeViewMut<'a> {
+            /// The raw shape from Rapier.
+            pub raw: &'a mut $RoundShape,
+        }
+
+        impl<'a> $RoundShapeViewMut<'a> {
+            /// The radius of the round border of this shape.
+            pub fn border_radius(&self) -> f32 {
+                self.raw.border_radius
+            }
+
+            /// Set the radius of the round border of this shape.
+            pub fn set_border_radius(&mut self, new_border_radius: f32) {
+                self.raw.border_radius = new_border_radius;
+            }
+
+            /// The underlying not-rounded shape.
+            pub fn inner_shape(&mut self) -> $ShapeViewMut<'_> {
+                $ShapeViewMut {
+                    raw: &mut self.raw.inner_shape,
+                }
+            }
+        }
+    }
+);
+
+round_shape_view!(
+    RoundCuboid,
+    RoundCuboidView,
+    CuboidView,
+    RoundCuboidViewMut,
+    CuboidViewMut
+);
+
+round_shape_view!(
+    RoundTriangle,
+    RoundTriangleView,
+    TriangleView,
+    RoundTriangleViewMut,
+    TriangleViewMut
+);
+
+#[cfg(feature = "dim2")]
+round_shape_view!(
+    RoundConvexPolygon,
+    RoundConvexPolygonView,
+    ConvexPolygonView,
+    RoundConvexPolygonViewMut,
+    ConvexPolygonViewMut
+);
+
+#[cfg(feature = "dim3")]
+round_shape_view!(
+    RoundCone,
+    RoundConeView,
+    ConeView,
+    RoundConeViewMut,
+    ConeViewMut
+);
+
+#[cfg(feature = "dim3")]
+round_shape_view!(
+    RoundCylinder,
+    RoundCylinderView,
+    CylinderView,
+    RoundCylinderViewMut,
+    CylinderViewMut
+);
+
+#[cfg(feature = "dim3")]
+round_shape_view!(
+    RoundConvexPolyhedron,
+    RoundConvexPolyhedronView,
+    ConvexPolyhedronView,
+    RoundConvexPolyhedronViewMut,
+    ConvexPolyhedronViewMut
+);
diff --git a/bindings/bevy_rapier/src/geometry/shape_views/segment.rs b/bindings/bevy_rapier/src/geometry/shape_views/segment.rs
new file mode 100644
index 000000000..33b4c0eb2
--- /dev/null
+++ b/bindings/bevy_rapier/src/geometry/shape_views/segment.rs
@@ -0,0 +1,99 @@
+use crate::math::{Real, Vect};
+use rapier::parry::shape::Segment;
+
+/// Read-only access to the properties of a segment.
+#[derive(Copy, Clone)]
+pub struct SegmentView<'a> {
+    /// The raw shape from Rapier.
+    pub raw: &'a Segment,
+}
+
+macro_rules! impl_ref_methods(
+    ($View: ident) => {
+        impl<'a> $View<'a> {
+            /// The segment first point.
+            pub fn a(&self) -> Vect {
+                self.raw.a.into()
+            }
+
+            /// The segment second point.
+            pub fn b(&self) -> Vect {
+                self.raw.b.into()
+            }
+
+            /// The direction of this segment scaled by its length.
+            ///
+            /// Points from `self.a` toward `self.b`.
+            pub fn scaled_direction(&self) -> Vect {
+                self.raw.scaled_direction().into()
+            }
+
+            /// The length of this segment.
+            pub fn length(&self) -> Real {
+                self.raw.length()
+            }
+
+            /// The unit direction of this segment.
+            ///
+            /// Points from `self.a()` toward `self.b()`.
+            /// Returns `None` is both points are equal.
+            pub fn direction(&self) -> Option<Vect> {
+                self.raw.direction()
+            }
+
+            /// In 2D, the not-normalized counterclockwise normal of this segment.
+            #[cfg(feature = "dim2")]
+            pub fn scaled_normal(&self) -> Vect {
+                self.raw.scaled_normal()
+            }
+
+            /// The not-normalized counterclockwise normal of this segment, assuming it lies on the plane
+            /// with the normal collinear to the given axis (0 = X, 1 = Y, 2 = Z).
+            #[cfg(feature = "dim3")]
+            pub fn scaled_planar_normal(&self, plane_axis: u8) -> Vect {
+                self.raw.scaled_planar_normal(plane_axis)
+            }
+
+            /// In 2D, the normalized counterclockwise normal of this segment.
+            #[cfg(feature = "dim2")]
+            pub fn normal(&self) -> Option<Vect> {
+                self.raw.normal()
+            }
+
+            /// Returns `None`. Exists only for API similarity with the 2D parry.
+            #[cfg(feature = "dim3")]
+            pub fn normal(&self) -> Option<Vect> {
+                self.raw.normal()
+            }
+
+            /// The normalized counterclockwise normal of this segment, assuming it lies on the plane
+            /// with the normal collinear to the given axis (0 = X, 1 = Y, 2 = Z).
+            #[cfg(feature = "dim3")]
+            pub fn planar_normal(&self, plane_axis: u8) -> Option<Vect> {
+                self.raw.planar_normal(plane_axis)
+            }
+        }
+    }
+);
+
+impl_ref_methods!(SegmentView);
+
+/// Read-write access to the properties of a segment.
+pub struct SegmentViewMut<'a> {
+    /// The raw shape from Rapier.
+    pub raw: &'a mut Segment,
+}
+
+impl_ref_methods!(SegmentViewMut);
+
+impl SegmentViewMut<'_> {
+    /// Set the first point of the segment.
+    pub fn set_a(&mut self, a: Vect) {
+        self.raw.a = a;
+    }
+
+    /// Set the second point of the segment.
+    pub fn set_b(&mut self, b: Vect) {
+        self.raw.b = b;
+    }
+}
diff --git a/bindings/bevy_rapier/src/geometry/shape_views/triangle.rs b/bindings/bevy_rapier/src/geometry/shape_views/triangle.rs
new file mode 100644
index 000000000..619a66c33
--- /dev/null
+++ b/bindings/bevy_rapier/src/geometry/shape_views/triangle.rs
@@ -0,0 +1,108 @@
+use crate::math::{Real, Vect};
+use rapier::parry::shape::Triangle;
+
+/// Read-only access to the properties of a triangle.
+#[derive(Copy, Clone)]
+pub struct TriangleView<'a> {
+    /// The raw shape from Rapier.
+    pub raw: &'a Triangle,
+}
+
+macro_rules! impl_ref_methods(
+    ($View: ident) => {
+        impl<'a> $View<'a> {
+            /// The triangle first point.
+            pub fn a(&self) -> Vect {
+                self.raw.a.into()
+            }
+
+            /// The triangle second point.
+            pub fn b(&self) -> Vect {
+                self.raw.b.into()
+            }
+
+            /// The triangle third point.
+            pub fn c(&self) -> Vect {
+                self.raw.c.into()
+            }
+
+            /// Reference to an array containing the three vertices of this triangle.
+            #[inline]
+            pub fn vertices(&self) -> [Vect; 3] {
+                let vtx = self.raw.vertices();
+                [vtx[0].into(), vtx[1].into(), vtx[2].into()]
+            }
+
+            /// The normal of this triangle assuming it is oriented ccw.
+            ///
+            /// The normal points such that it is collinear to `AB × AC` (where `×` denotes the cross
+            /// product).
+            #[cfg(feature = "dim3")]
+            #[inline]
+            pub fn normal(&self) -> Option<Vect> {
+                self.raw.normal()
+            }
+
+            /// A vector normal of this triangle.
+            ///
+            /// The vector points such that it is collinear to `AB × AC` (where `×` denotes the cross
+            /// product).
+            #[cfg(feature = "dim3")]
+            #[inline]
+            pub fn scaled_normal(&self) -> Vect {
+                self.raw.scaled_normal().into()
+            }
+
+            /// The area of this triangle.
+            #[inline]
+            pub fn area(&self) -> Real {
+                self.raw.area()
+            }
+
+            /// The geometric center of this triangle.
+            #[inline]
+            pub fn center(&self) -> Vect {
+                self.raw.center().into()
+            }
+
+            /// The perimeter of this triangle.
+            #[inline]
+            pub fn perimeter(&self) -> Real {
+                self.raw.perimeter()
+            }
+
+            /// The circumcircle of this triangle.
+            pub fn circumcircle(&self) -> (Vect, Real) {
+                let (center, radius) = self.raw.circumcircle();
+                (center.into(), radius)
+            }
+        }
+    }
+);
+
+impl_ref_methods!(TriangleView);
+
+/// Read-write access to the properties of a triangle.
+pub struct TriangleViewMut<'a> {
+    /// The raw shape from Rapier.
+    pub raw: &'a mut Triangle,
+}
+
+impl_ref_methods!(TriangleViewMut);
+
+impl TriangleViewMut<'_> {
+    /// Set the first point of the segment.
+    pub fn set_a(&mut self, a: Vect) {
+        self.raw.a = a;
+    }
+
+    /// Set the second point of the segment.
+    pub fn set_b(&mut self, b: Vect) {
+        self.raw.b = b;
+    }
+
+    /// Set the third point of the segment.
+    pub fn set_c(&mut self, c: Vect) {
+        self.raw.c = c;
+    }
+}
diff --git a/bindings/bevy_rapier/src/geometry/shape_views/trimesh.rs b/bindings/bevy_rapier/src/geometry/shape_views/trimesh.rs
new file mode 100644
index 000000000..2e92636d7
--- /dev/null
+++ b/bindings/bevy_rapier/src/geometry/shape_views/trimesh.rs
@@ -0,0 +1,164 @@
+use crate::geometry::Collider;
+use crate::math::{Rot, Vect};
+#[cfg(feature = "dim3")]
+use rapier::parry::shape::TriMeshPseudoNormals;
+use rapier::parry::shape::{
+    FeatureId, TopologyError, TriMesh, TriMeshBuilderError, TriMeshConnectedComponents,
+    TriMeshFlags, TriMeshTopology,
+};
+
+/// Read-only access to the properties of a triangle mesh.
+#[derive(Copy, Clone)]
+pub struct TriMeshView<'a> {
+    /// The raw shape from Rapier.
+    pub raw: &'a TriMesh,
+}
+
+macro_rules! impl_ref_methods(
+    ($View: ident) => {
+        impl<'a> $View<'a> {
+            /// The number of triangles forming this mesh.
+            pub fn num_triangles(&self) -> usize {
+                self.raw.num_triangles()
+            }
+
+            /// An iterator through all the triangles of this mesh.
+            pub fn triangles(&self) -> impl ExactSizeIterator<Item = (Vect, Vect, Vect)> + '_ {
+                self.raw
+                    .triangles()
+                    .map(|tri| (tri.a.into(), tri.b.into(), tri.c.into()))
+            }
+
+            /// Get the `i`-th triangle of this mesh.
+            pub fn triangle(&self, i: u32) -> (Vect, Vect, Vect) {
+                let tri = self.raw.triangle(i);
+                (tri.a.into(), tri.b.into(), tri.c.into())
+            }
+
+            /// The vertex buffer of this mesh.
+            pub fn vertices(&self) -> impl ExactSizeIterator<Item = Vect> + '_ {
+                self.raw.vertices().iter().map(|pt| (*pt).into())
+            }
+
+            /// The index buffer of this mesh.
+            pub fn indices(&self) -> &[[u32; 3]] {
+                self.raw.indices()
+            }
+
+            /// A flat view of the index buffer of this mesh.
+            pub fn flat_indices(&self) -> &[u32] {
+                self.raw.flat_indices()
+            }
+
+            /// The flags controlling the optional data associated to this mesh.
+            pub fn flags(&self) -> TriMeshFlags {
+                self.raw.flags()
+            }
+
+            /// The outward normal of the `i`-th triangle, or `None` if it is degenerate.
+            #[cfg(feature = "dim3")]
+            pub fn triangle_normal(&self, i: u32) -> Option<Vect> {
+                self.raw.triangle_normal(i)
+            }
+
+            /// Does the given feature (as returned by a ray-cast or point projection on one of
+            /// the triangles) identify the back face of that triangle?
+            pub fn is_backface(&self, feature: FeatureId) -> bool {
+                self.raw.is_backface(feature)
+            }
+
+            /// The half-edge topology of this mesh, if it was computed.
+            ///
+            /// This requires the [`TriMeshFlags::HALF_EDGE_TOPOLOGY`] flag.
+            pub fn topology(&self) -> Option<&TriMeshTopology> {
+                self.raw.topology()
+            }
+
+            /// The connected components of this mesh, if they were computed.
+            ///
+            /// This requires the [`TriMeshFlags::CONNECTED_COMPONENTS`] flag.
+            pub fn connected_components(&self) -> Option<&TriMeshConnectedComponents> {
+                self.raw.connected_components()
+            }
+
+            /// The number of connected components of this mesh, if they were computed.
+            pub fn num_connected_components(&self) -> Option<usize> {
+                self.raw
+                    .connected_components()
+                    .map(|cc| cc.num_connected_components())
+            }
+
+            /// Builds one triangle mesh collider per connected component of this mesh, each
+            /// built with the given `flags`.
+            ///
+            /// Returns `None` if the connected components were not computed.
+            pub fn connected_component_colliders(
+                &self,
+                flags: TriMeshFlags,
+            ) -> Option<Vec<Result<Collider, TriMeshBuilderError>>> {
+                self.raw.connected_component_meshes(flags).map(|meshes| {
+                    meshes
+                        .into_iter()
+                        .map(|mesh| mesh.map(|mesh| rapier::prelude::SharedShape::new(mesh).into()))
+                        .collect()
+                })
+            }
+
+            /// The vertex and edge pseudo-normals of this mesh, if they were computed.
+            ///
+            /// They are computed with the [`TriMeshFlags::ORIENTED`] or
+            /// [`TriMeshFlags::FIX_INTERNAL_EDGES`] flags.
+            #[cfg(feature = "dim3")]
+            pub fn pseudo_normals(&self) -> Option<&TriMeshPseudoNormals> {
+                self.raw.pseudo_normals()
+            }
+        }
+    }
+);
+
+impl_ref_methods!(TriMeshView);
+
+/// Read-write access to the properties of a triangle mesh.
+pub struct TriMeshViewMut<'a> {
+    /// The raw shape from Rapier.
+    pub raw: &'a mut TriMesh,
+}
+
+impl_ref_methods!(TriMeshViewMut);
+
+impl TriMeshViewMut<'_> {
+    /// Sets the flags of this triangle mesh, controlling its optional associated data.
+    pub fn set_flags(&mut self, flags: TriMeshFlags) -> Result<(), TopologyError> {
+        self.raw.set_flags(flags)
+    }
+
+    /// Replaces the vertex positions, keeping the index buffer and topology.
+    ///
+    /// The acceleration structure is refitted and the pseudo-normals (if any) are recomputed.
+    /// This is intended for meshes built with [`TriMeshFlags::DEFORMABLE`].
+    ///
+    /// # Panics
+    /// Panics if `vertices.len()` differs from the current number of vertices.
+    pub fn set_vertices(&mut self, vertices: &[Vect]) {
+        self.raw.set_vertices(vertices)
+    }
+
+    /// Modifies the vertex positions in place through `f`, then refits the acceleration
+    /// structure and recomputes the pseudo-normals (if any).
+    ///
+    /// This is intended for meshes built with [`TriMeshFlags::DEFORMABLE`].
+    pub fn update_vertices(&mut self, f: impl FnOnce(&mut [Vect])) {
+        self.raw.update_vertices(f)
+    }
+
+    /// Applies a rigid transformation to every vertex of this mesh.
+    pub fn transform_vertices(&mut self, translation: Vect, rotation: Rot) {
+        self.raw
+            .transform_vertices(&crate::utils::pose_from(translation, rotation))
+    }
+
+    /// Reverses the orientation of every triangle of this mesh.
+    pub fn reverse(&mut self) {
+        self.raw.reverse()
+    }
+}
diff --git a/bindings/bevy_rapier/src/geometry/shape_views/voxels.rs b/bindings/bevy_rapier/src/geometry/shape_views/voxels.rs
new file mode 100644
index 000000000..dd88082fc
--- /dev/null
+++ b/bindings/bevy_rapier/src/geometry/shape_views/voxels.rs
@@ -0,0 +1,253 @@
+use rapier::prelude::{Aabb, VoxelData, VoxelState, Voxels};
+
+use crate::math::{IVect, Vect};
+
+#[cfg(feature = "dim2")]
+use bevy::shape::Aabb2d as BevyAabb;
+#[cfg(feature = "dim3")]
+use bevy::shape::Aabb3d as BevyAabb;
+
+#[cfg(feature = "dim2")]
+fn aabb_na_from_bevy(aabb: &BevyAabb) -> Aabb {
+    rapier::parry::bounding_volume::Aabb::new(aabb.min, aabb.max)
+}
+
+#[cfg(feature = "dim3")]
+fn aabb_na_from_bevy(aabb: &BevyAabb) -> Aabb {
+    rapier::parry::bounding_volume::Aabb::new(aabb.min.into(), aabb.max.into())
+}
+
+#[cfg(feature = "dim2")]
+fn aabb_bevy_from_na(aabb: &Aabb) -> BevyAabb {
+    BevyAabb {
+        min: aabb.mins,
+        max: aabb.maxs,
+    }
+}
+
+#[cfg(feature = "dim3")]
+fn aabb_bevy_from_na(aabb: &Aabb) -> BevyAabb {
+    BevyAabb {
+        min: aabb.mins.into(),
+        max: aabb.maxs.into(),
+    }
+}
+
+/// Read-only access to the properties of a [`Voxels`] shape.
+#[derive(Copy, Clone)]
+pub struct VoxelsView<'a> {
+    /// The raw shape from Rapier.
+    pub raw: &'a Voxels,
+}
+
+// TODO: implement those on VoxelsViewMut too.
+macro_rules! impl_ref_methods(
+    ($View: ident) => {
+        impl<'a> $View<'a> {
+            /// Shortcut to [`Voxels::total_memory_size`].
+            pub fn total_memory_size(&self) -> usize {
+                self.raw.total_memory_size()
+            }
+
+            /// Shortcut to [`Voxels::heap_memory_size`].
+            pub fn heap_memory_size(&self) -> usize {
+                self.raw.heap_memory_size()
+            }
+
+            /// Shortcut to [`Voxels::voxel_size`].
+            pub fn voxel_size(&self) -> Vect {
+                self.raw.voxel_size()
+            }
+
+            /// Shortcut to [`Voxels::voxel_center`].
+            pub fn voxel_center(&self, key: IVect) -> Vect {
+                self.raw.voxel_center(key)
+            }
+
+            /// Shortcut to [`Voxels::cropped`].
+            ///
+            /// Returns `None` if no filled voxel lies in the `[domain_mins, domain_maxs]` range.
+            pub fn cropped(&self, domain_mins: IVect, domain_maxs: IVect) -> Option<Voxels> {
+                self.raw.cropped(domain_mins, domain_maxs)
+            }
+
+            /// Shortcut to [`Voxels::local_aabb`].
+            pub fn extents(&self) -> Vect {
+                self.raw.local_aabb().extents()
+            }
+
+            /// Shortcut to [`Voxels::local_aabb`].
+            pub fn domain_center(&self) -> Vect {
+                self.raw.local_aabb().center()
+            }
+
+            /// Shortcut to [`Voxels::domain`].
+            pub fn is_voxel_in_bounds(&self, key: IVect) -> bool {
+                let [mins, maxs] = self.raw.domain();
+                #[cfg(feature = "dim2")]
+                {
+                    key.x >= mins.x && key.y >= mins.y && key.x < maxs.x && key.y < maxs.y
+                }
+                #[cfg(feature = "dim3")]
+                {
+                    key.x >= mins.x
+                        && key.y >= mins.y
+                        && key.z >= mins.z
+                        && key.x < maxs.x
+                        && key.y < maxs.y
+                        && key.z < maxs.z
+                }
+            }
+
+            /// Shortcut to [`Voxels::voxel_aabb`].
+            pub fn voxel_aabb(&self, key: IVect) -> BevyAabb {
+                aabb_bevy_from_na(&self.raw.voxel_aabb(key.into()))
+            }
+
+            /// Shortcut to [`Voxels::voxel_state`].
+            pub fn voxel_state(&self, key: IVect) -> Option<VoxelState> {
+                self.raw.voxel_state(key.into())
+            }
+
+            /// Shortcut to [`Voxels::voxel_at_point`].
+            pub fn voxel_at_point_unchecked(&self, point: Vect) -> IVect {
+                self.raw.voxel_at_point(point)
+            }
+
+            /// Shortcut to [`Voxels::voxel_at_point`].
+            pub fn voxel_at_point(&self, pt: Vect) -> Option<IVect> {
+                let voxel = self.voxel_at_point_unchecked(pt);
+                if self.is_voxel_in_bounds(voxel) {
+                    Some(voxel)
+                } else {
+                    None
+                }
+            }
+
+            /// Shortcut to [`Voxels::domain`].
+            pub fn clamp_voxel(&self, key: IVect) -> IVect {
+                let [mins, maxs] = self.raw.domain();
+                #[cfg(feature = "dim2")]
+                {
+                    IVect::new(
+                        key.x.clamp(mins.x, maxs.x - 1),
+                        key.y.clamp(mins.y, maxs.y - 1),
+                    )
+                }
+                #[cfg(feature = "dim3")]
+                {
+                    IVect::new(
+                        key.x.clamp(mins.x, maxs.x - 1),
+                        key.y.clamp(mins.y, maxs.y - 1),
+                        key.z.clamp(mins.z, maxs.z - 1),
+                    )
+                }
+            }
+
+            /// Shortcut to [`Voxels::voxel_range_intersecting_local_aabb`].
+            pub fn voxel_range_intersecting_local_aabb(&self, aabb: &BevyAabb) -> [IVect; 2] {
+                let res = self
+                    .raw
+                    .voxel_range_intersecting_local_aabb(&aabb_na_from_bevy(aabb));
+                [res[0].into(), res[1].into()]
+            }
+
+            /// Shortcut to [`Voxels::voxel_range_aabb`].
+            pub fn voxel_range_aabb(&self, mins: IVect, maxs: IVect) -> BevyAabb {
+                aabb_bevy_from_na(&self.raw.voxel_range_aabb(mins.into(), maxs.into()))
+            }
+
+            /// Shortcut to [`Voxels::align_aabb_to_grid`].
+            pub fn align_aabb_to_grid(&self, aabb: &BevyAabb) -> BevyAabb {
+                aabb_bevy_from_na(&self.raw.align_aabb_to_grid(&aabb_na_from_bevy(aabb)))
+            }
+
+            /// Shortcut to [`Voxels::voxels_intersecting_local_aabb`].
+            pub fn voxels_intersecting_local_aabb(
+                &self,
+                aabb: &BevyAabb,
+            ) -> impl Iterator<Item = VoxelData> + '_ {
+                self.raw
+                    .voxels_intersecting_local_aabb(&aabb_na_from_bevy(aabb))
+            }
+
+            /// Shortcut to [`Voxels::voxels`].
+            pub fn voxels(&self) -> impl Iterator<Item = VoxelData> + '_ {
+                self.raw.voxels()
+            }
+
+            /// Shortcut to [`Voxels::split_with_box`].
+            pub fn split_with_box(&self, aabb: &BevyAabb) -> (Option<Voxels>, Option<Voxels>) {
+                self.raw.split_with_box(&aabb_na_from_bevy(aabb))
+            }
+
+            /// Shortcut to [`Voxels::voxels_in_range`].
+            pub fn voxels_in_range(
+                &self,
+                mins: IVect,
+                maxs: IVect,
+            ) -> impl Iterator<Item = VoxelData> + '_ {
+                self.raw.voxels_in_range(mins.into(), maxs.into())
+            }
+        }
+    }
+);
+
+impl_ref_methods!(VoxelsView);
+
+/// Read-write access to the properties of a [`Voxels`].
+pub struct VoxelsViewMut<'a> {
+    /// The raw shape from Rapier.
+    pub raw: &'a mut Voxels,
+}
+
+impl_ref_methods!(VoxelsViewMut);
+
+impl<'a> VoxelsViewMut<'a> {
+    /// Shortcut to set voxel state with bounds checking.
+    pub fn try_set_voxel(&mut self, key: IVect, is_filled: bool) -> Option<VoxelState> {
+        if self.is_voxel_in_bounds(key) {
+            Some(self.raw.set_voxel(key, is_filled))
+        } else {
+            None
+        }
+    }
+
+    /// Shortcut to to [`Voxels::set_voxel`].
+    pub fn set_voxel(&mut self, key: IVect, is_filled: bool) -> VoxelState {
+        self.raw.set_voxel(key, is_filled)
+    }
+
+    /// Shortcut to [`Voxels::crop`].
+    pub fn crop(&mut self, domain_mins: IVect, domain_maxs: IVect) {
+        self.raw.crop(domain_mins, domain_maxs);
+    }
+
+    /// Shortcut to [`Voxels::set_voxel_size`].
+    pub fn set_voxel_size(&mut self, new_size: Vect) {
+        self.raw.set_voxel_size(new_size);
+    }
+
+    /// Shortcut to [`Voxels::combine_voxel_states`].
+    ///
+    /// Makes the voxels of `self` and `other` aware of their neighbors from the other shape, so
+    /// that contacts transition smoothly across their boundary. A voxel with coordinates `key`
+    /// in `other` has coordinates `key + origin_shift` in `self`.
+    pub fn combine_voxel_states(&mut self, other: &mut VoxelsViewMut<'_>, origin_shift: IVect) {
+        self.raw.combine_voxel_states(other.raw, origin_shift);
+    }
+
+    /// Shortcut to [`Voxels::propagate_voxel_change`].
+    ///
+    /// Same as [`Self::combine_voxel_states`] but restricted to the given `voxel` of `self` (and
+    /// its neighbors), after it was modified with [`Self::set_voxel`].
+    pub fn propagate_voxel_change(
+        &mut self,
+        other: &mut VoxelsViewMut<'_>,
+        voxel: IVect,
+        origin_shift: IVect,
+    ) {
+        self.raw
+            .propagate_voxel_change(other.raw, voxel, origin_shift);
+    }
+}
diff --git a/bindings/bevy_rapier/src/geometry/to_bevy_mesh.rs b/bindings/bevy_rapier/src/geometry/to_bevy_mesh.rs
new file mode 100644
index 000000000..47dcc5887
--- /dev/null
+++ b/bindings/bevy_rapier/src/geometry/to_bevy_mesh.rs
@@ -0,0 +1,558 @@
+//! Module for utilities to convert from a [`rapier::prelude::Shape`] to a [`bevy::prelude::Mesh`].
+
+use super::Collider;
+use crate::rapier::prelude::Ball;
+#[cfg(feature = "dim3")]
+use crate::rapier::prelude::{Cone, Cylinder};
+#[cfg(feature = "dim2")]
+use bevy::mesh::{Capsule2dMeshBuilder, CircleMeshBuilder};
+#[cfg(feature = "dim3")]
+use bevy::mesh::{
+    Capsule3dMeshBuilder, ConeMeshBuilder, CylinderMeshBuilder, PlaneMeshBuilder, SphereMeshBuilder,
+};
+use bevy::{
+    asset::RenderAssetUsages,
+    mesh::{Indices, PrimitiveTopology},
+    prelude::{Mesh, MeshBuilder},
+};
+
+use crate::math::{Real, Vect};
+use rapier::prelude::{Capsule, TypedShape};
+
+/// Half-size of the finite square (in 3D) or segment (in 2D) generated to represent the
+/// boundary of an (infinite) half-space by [`typed_shape_to_mesh`].
+pub const HALF_SPACE_MESH_HALF_SIZE: Real = 1000.0;
+
+/// Base number of subdivisions of the circle (in 2D) or sphere (in 3D) approximating the
+/// rounded border of round shapes in [`typed_shape_to_mesh`].
+pub const ROUND_BORDER_SUBDIVISIONS: u32 = 8;
+
+/// Number of subdivisions of the circular parts of round cylinders and round cones in
+/// [`typed_shape_to_mesh`].
+#[cfg(feature = "dim3")]
+pub const ROUND_SHAPE_CIRCLE_SUBDIVISIONS: u32 = 16;
+
+fn position_attribute(vertices: &[Vect]) -> Vec<[f32; 3]> {
+    #[cfg(feature = "dim2")]
+    return vertices.iter().map(|pt| [pt.x, pt.y, 0.0]).collect();
+    #[cfg(feature = "dim3")]
+    return vertices.iter().map(|pt| [pt.x, pt.y, pt.z]).collect();
+}
+
+/// Builds a [`PrimitiveTopology::TriangleList`] mesh from a vertex and index buffer.
+fn triangle_list_mesh(vertices: &[Vect], indices: impl IntoIterator<Item = [u32; 3]>) -> Mesh {
+    Mesh::new(
+        PrimitiveTopology::TriangleList,
+        RenderAssetUsages::default(),
+    )
+    .with_inserted_indices(Indices::U32(indices.into_iter().flatten().collect()))
+    .with_inserted_attribute(Mesh::ATTRIBUTE_POSITION, position_attribute(vertices))
+}
+
+/// Builds a [`PrimitiveTopology::LineList`] mesh from a vertex and index buffer.
+fn line_list_mesh(vertices: &[Vect], indices: impl IntoIterator<Item = [u32; 2]>) -> Mesh {
+    Mesh::new(PrimitiveTopology::LineList, RenderAssetUsages::default())
+        .with_inserted_indices(Indices::U32(indices.into_iter().flatten().collect()))
+        .with_inserted_attribute(Mesh::ATTRIBUTE_POSITION, position_attribute(vertices))
+}
+
+/// Builds a [`PrimitiveTopology::LineList`] mesh from a list of disjoint segments.
+#[cfg(feature = "dim2")]
+fn segments_mesh(segments: impl IntoIterator<Item = (Vect, Vect)>) -> Mesh {
+    let mut vertices = vec![];
+    for (a, b) in segments {
+        vertices.push(a);
+        vertices.push(b);
+    }
+    let indices = (0..vertices.len() as u32 / 2).map(|i| [i * 2, i * 2 + 1]);
+    line_list_mesh(&vertices, indices)
+}
+
+/// Triangulates a convex polygon with a triangle fan.
+#[cfg(feature = "dim2")]
+fn convex_polygon_mesh(vertices: &[Vect]) -> Option<Mesh> {
+    if vertices.len() < 3 {
+        return None;
+    }
+    let indices = (1..vertices.len() as u32 - 1).map(|i| [0, i, i + 1]);
+    Some(triangle_list_mesh(vertices, indices))
+}
+
+/// Meshes the Minkowski sum of the convex hull of `inner_points` with a ball of radius
+/// `border_radius`.
+///
+/// The ball is approximated by a polygon (2D) or polyhedron (3D), so the result is the exact
+/// convex hull of the pairwise sums of the inner points and the ball approximation vertices.
+fn round_convex_mesh(inner_points: &[Vect], border_radius: Real) -> Option<Mesh> {
+    let ball = Ball::new(border_radius);
+    #[cfg(feature = "dim2")]
+    let ball_points = ball.to_polyline(ROUND_BORDER_SUBDIVISIONS * 2);
+    #[cfg(feature = "dim3")]
+    let ball_points = ball
+        .to_trimesh(ROUND_BORDER_SUBDIVISIONS, ROUND_BORDER_SUBDIVISIONS / 2)
+        .0;
+
+    let points: Vec<Vect> = inner_points
+        .iter()
+        .flat_map(|pt| ball_points.iter().map(move |b| *pt + *b))
+        .collect();
+
+    #[cfg(feature = "dim2")]
+    {
+        let hull = rapier::parry::transformation::convex_hull(&points);
+        convex_polygon_mesh(&hull)
+    }
+    #[cfg(feature = "dim3")]
+    {
+        let (vertices, indices) = rapier::parry::transformation::try_convex_hull(&points).ok()?;
+        Some(triangle_list_mesh(&vertices, indices))
+    }
+}
+
+/// Converts a [`TypedShape`] to a [`Mesh`].
+///
+/// Shapes convertible to a bevy builtin [`bevy::prelude::Meshable`] use it. Other shapes are
+/// converted into a new mesh with [`PrimitiveTopology::TriangleList`], or
+/// [`PrimitiveTopology::LineList`] for one-dimensional shapes (segments, polylines, and 2D
+/// heightfields). In 2D, meshes lie on the `z = 0` plane.
+///
+/// Some shapes are approximated:
+/// - half-spaces are represented by a finite square (3D) or segment (2D) with a half-size of
+///   [`HALF_SPACE_MESH_HALF_SIZE`], centered at the shape's origin.
+/// - round shapes use a polygonal (2D) or polyhedral (3D) approximation of their rounded border
+///   controlled by [`ROUND_BORDER_SUBDIVISIONS`].
+///
+/// Returns `None` for custom shapes, and for compound shapes with no convertible part.
+pub fn typed_shape_to_mesh(typed_shape: &TypedShape) -> Option<Mesh> {
+    Some(match typed_shape {
+        TypedShape::Ball(ball) => ball.mesh_builder().build(),
+        TypedShape::Cuboid(cuboid) => {
+            // FIXME: bevy 0.16 will expose a builder for cuboids: https://github.com/bevyengine/bevy/pull/17454
+            let half_extents = cuboid.half_extents;
+            #[cfg(feature = "dim2")]
+            let mesh = bevy::prelude::Rectangle::new(half_extents.x * 2.0, half_extents.y * 2.0);
+            #[cfg(feature = "dim3")]
+            let mesh = bevy::prelude::Cuboid::new(
+                half_extents.x * 2.0,
+                half_extents.y * 2.0,
+                half_extents.z * 2.0,
+            );
+            Mesh::from(mesh)
+        }
+        TypedShape::Capsule(capsule) => capsule.mesh_builder().build(),
+        TypedShape::Segment(segment) => line_list_mesh(&[segment.a, segment.b], [[0, 1]]),
+        TypedShape::Triangle(triangle) => {
+            // FIXME: bevy 0.16 will expose a builder for triangles: https://github.com/bevyengine/bevy/pull/17454
+            let a = triangle.a;
+            let b = triangle.b;
+            let c = triangle.c;
+            #[cfg(feature = "dim2")]
+            let mesh = bevy::prelude::Triangle3d::new(
+                bevy::prelude::Vec3::new(a.x, a.y, 0.0),
+                bevy::prelude::Vec3::new(b.x, b.y, 0.0),
+                bevy::prelude::Vec3::new(c.x, c.y, 0.0),
+            );
+            #[cfg(feature = "dim3")]
+            let mesh = bevy::prelude::Triangle3d::new(a, b, c);
+
+            mesh.into()
+        }
+        TypedShape::Voxels(voxels) => {
+            #[cfg(feature = "dim3")]
+            {
+                let (vtx, idx) = voxels.to_trimesh();
+                triangle_list_mesh(&vtx, idx)
+            }
+
+            #[cfg(feature = "dim2")]
+            {
+                // One quad per filled voxel.
+                let half_size = voxels.voxel_size() / 2.0;
+                let mut vtx = vec![];
+                let mut idx = vec![];
+                for vox in voxels.voxels().filter(|vox| !vox.state.is_empty()) {
+                    let base = vtx.len() as u32;
+                    vtx.push(vox.center - half_size);
+                    vtx.push(vox.center + Vect::new(half_size.x, -half_size.y));
+                    vtx.push(vox.center + half_size);
+                    vtx.push(vox.center + Vect::new(-half_size.x, half_size.y));
+                    idx.push([base, base + 1, base + 2]);
+                    idx.push([base, base + 2, base + 3]);
+                }
+                triangle_list_mesh(&vtx, idx)
+            }
+        }
+        TypedShape::TriMesh(tri_mesh) => {
+            triangle_list_mesh(tri_mesh.vertices(), tri_mesh.indices().iter().copied())
+        }
+        TypedShape::Polyline(polyline) => {
+            line_list_mesh(polyline.vertices(), polyline.indices().iter().copied())
+        }
+        TypedShape::HalfSpace(half_space) => {
+            #[cfg(feature = "dim2")]
+            {
+                let tangent = half_space.normal.perp() * HALF_SPACE_MESH_HALF_SIZE;
+                line_list_mesh(&[-tangent, tangent], [[0, 1]])
+            }
+            #[cfg(feature = "dim3")]
+            {
+                PlaneMeshBuilder::new(
+                    bevy::prelude::Dir3::new(half_space.normal).unwrap_or(bevy::prelude::Dir3::Y),
+                    bevy::prelude::Vec2::splat(HALF_SPACE_MESH_HALF_SIZE * 2.0),
+                )
+                .build()
+            }
+        }
+        TypedShape::HeightField(height_field) => {
+            #[cfg(feature = "dim2")]
+            {
+                segments_mesh(height_field.segments().map(|seg| (seg.a, seg.b)))
+            }
+            #[cfg(feature = "dim3")]
+            {
+                // FIXME: we could use TriMesh::From(height_field), but that would clone, we should fix that in parry.
+                let (vtx, idx) = height_field.to_trimesh();
+                triangle_list_mesh(&vtx, idx)
+            }
+        }
+        TypedShape::Compound(compound) => {
+            let meshes: Vec<Mesh> = compound
+                .shapes()
+                .iter()
+                .filter_map(|(pose, shape)| {
+                    let mesh = typed_shape_to_mesh(&shape.as_typed_shape());
+                    if mesh.is_none() {
+                        log::warn!("Skipping a compound part that cannot be converted to a mesh.");
+                    }
+                    Some(mesh?.transformed_by(crate::utils::iso_to_transform(pose)))
+                })
+                .collect();
+            merge_meshes(meshes)?
+        }
+        #[cfg(feature = "dim2")]
+        TypedShape::ConvexPolygon(convex_polygon) => convex_polygon_mesh(convex_polygon.points())?,
+        #[cfg(feature = "dim3")]
+        TypedShape::ConvexPolyhedron(convex_polyhedron) => {
+            let (vtx, idx) = convex_polyhedron.to_trimesh();
+            triangle_list_mesh(&vtx, idx)
+        }
+        #[cfg(feature = "dim3")]
+        TypedShape::Cone(cone) => cone.mesh_builder().build(),
+        #[cfg(feature = "dim3")]
+        TypedShape::Cylinder(cylinder) => cylinder.mesh_builder().build(),
+        #[cfg(feature = "dim3")]
+        TypedShape::RoundCone(round_cone) => {
+            let inner = round_cone
+                .inner_shape
+                .to_trimesh(ROUND_SHAPE_CIRCLE_SUBDIVISIONS)
+                .0;
+            round_convex_mesh(&inner, round_cone.border_radius)?
+        }
+        #[cfg(feature = "dim3")]
+        TypedShape::RoundCylinder(round_cylinder) => {
+            let inner = round_cylinder
+                .inner_shape
+                .to_trimesh(ROUND_SHAPE_CIRCLE_SUBDIVISIONS)
+                .0;
+            round_convex_mesh(&inner, round_cylinder.border_radius)?
+        }
+        #[cfg(feature = "dim2")]
+        TypedShape::RoundConvexPolygon(round_shape) => {
+            round_convex_mesh(round_shape.inner_shape.points(), round_shape.border_radius)?
+        }
+        #[cfg(feature = "dim3")]
+        TypedShape::RoundConvexPolyhedron(round_shape) => {
+            round_convex_mesh(round_shape.inner_shape.points(), round_shape.border_radius)?
+        }
+        TypedShape::RoundCuboid(round_shape) => {
+            #[cfg(feature = "dim2")]
+            let inner = round_shape.inner_shape.to_polyline();
+            #[cfg(feature = "dim3")]
+            let inner = round_shape.inner_shape.to_trimesh().0;
+            round_convex_mesh(&inner, round_shape.border_radius)?
+        }
+        TypedShape::RoundTriangle(round_shape) => {
+            let tri = &round_shape.inner_shape;
+            round_convex_mesh(&[tri.a, tri.b, tri.c], round_shape.border_radius)?
+        }
+        TypedShape::Custom(_shape) => {
+            log::warn!("Custom shapes cannot be converted to a mesh.");
+            return None;
+        }
+    })
+}
+
+/// Merges meshes into a single one, keeping only the vertex attributes shared by all of them.
+///
+/// Meshes with a primitive topology different from the first one are skipped.
+fn merge_meshes(mut meshes: Vec<Mesh>) -> Option<Mesh> {
+    let first = meshes.first()?;
+    let topology = first.primitive_topology();
+    meshes.retain(|mesh| {
+        let same_topology = mesh.primitive_topology() == topology;
+        if !same_topology {
+            log::warn!("Skipping a compound part with an incompatible mesh topology.");
+        }
+        same_topology
+    });
+
+    let common_attributes: Vec<_> = meshes[0]
+        .attributes()
+        .map(|(attribute, _)| attribute.id)
+        .filter(|id| meshes.iter().all(|mesh| mesh.contains_attribute(*id)))
+        .collect();
+
+    let mut meshes = meshes.into_iter().map(|mut mesh| {
+        let to_remove: Vec<_> = mesh
+            .attributes()
+            .map(|(attribute, _)| attribute.id)
+            .filter(|id| !common_attributes.contains(id))
+            .collect();
+        for id in to_remove {
+            mesh.remove_attribute(id);
+        }
+        mesh
+    });
+
+    let mut result = meshes.next()?;
+    for mesh in meshes {
+        // FIXME: Error is simply "peeked" and ignored. Handle it properly by returning a Result from this function.
+        let _ = result.merge(&mesh).inspect_err(|e| {
+            log::warn!("Error merging mesh data: {e}");
+        });
+    }
+    Some(result)
+}
+
+impl TryFrom<&Collider> for Mesh {
+    type Error = ();
+
+    fn try_from(collider: &Collider) -> Result<Self, Self::Error> {
+        let typed_shape = collider.raw.as_typed_shape();
+        typed_shape_to_mesh(&typed_shape).ok_or(())
+    }
+}
+
+/// Trait to convert a parry shape to a [`MeshBuilder`].
+pub trait ToMeshBuilder {
+    /// Specific [`MeshBuilder`] being returned.
+    type MeshBuilder: bevy::mesh::prelude::MeshBuilder;
+    /// Returns a dedicated [`MeshBuilder`].
+    fn mesh_builder(&self) -> Self::MeshBuilder;
+}
+
+#[cfg(feature = "dim2")]
+impl ToMeshBuilder for &Ball {
+    type MeshBuilder = CircleMeshBuilder;
+
+    fn mesh_builder(&self) -> Self::MeshBuilder {
+        CircleMeshBuilder::new(self.radius, 16)
+    }
+}
+
+#[cfg(feature = "dim3")]
+impl ToMeshBuilder for &Ball {
+    type MeshBuilder = SphereMeshBuilder;
+
+    fn mesh_builder(&self) -> Self::MeshBuilder {
+        SphereMeshBuilder::new(self.radius, bevy::mesh::SphereKind::Ico { subdivisions: 1 })
+    }
+}
+
+#[cfg(feature = "dim3")]
+impl ToMeshBuilder for &rapier3d::prelude::HalfSpace {
+    type MeshBuilder = PlaneMeshBuilder;
+
+    fn mesh_builder(&self) -> Self::MeshBuilder {
+        PlaneMeshBuilder::new(
+            bevy::prelude::Dir3::new(self.normal).unwrap_or(bevy::prelude::Dir3::Y),
+            bevy::prelude::Vec2::ONE,
+        )
+    }
+}
+
+#[cfg(feature = "dim2")]
+impl ToMeshBuilder for &Capsule {
+    type MeshBuilder = Capsule2dMeshBuilder;
+
+    fn mesh_builder(&self) -> Self::MeshBuilder {
+        bevy::mesh::Capsule2dMeshBuilder::new(self.radius, self.height(), 10)
+    }
+}
+
+#[cfg(feature = "dim3")]
+impl ToMeshBuilder for &Capsule {
+    type MeshBuilder = Capsule3dMeshBuilder;
+
+    fn mesh_builder(&self) -> Self::MeshBuilder {
+        bevy::mesh::Capsule3dMeshBuilder::new(self.radius, self.height(), 10, 10)
+    }
+}
+#[cfg(feature = "dim3")]
+impl ToMeshBuilder for &Cone {
+    type MeshBuilder = ConeMeshBuilder;
+
+    fn mesh_builder(&self) -> Self::MeshBuilder {
+        bevy::mesh::ConeMeshBuilder::new(self.radius, self.half_height * 2.0, 16)
+    }
+}
+
+#[cfg(feature = "dim3")]
+impl ToMeshBuilder for &Cylinder {
+    type MeshBuilder = CylinderMeshBuilder;
+
+    fn mesh_builder(&self) -> Self::MeshBuilder {
+        bevy::mesh::CylinderMeshBuilder::new(self.radius, self.half_height * 2.0, 16)
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+    use bevy::mesh::VertexAttributeValues;
+
+    #[cfg(feature = "dim2")]
+    const ROT_ID: crate::math::Rot = 0.0;
+    #[cfg(feature = "dim3")]
+    const ROT_ID: crate::math::Rot = crate::math::Rot::IDENTITY;
+
+    fn to_mesh(collider: &Collider) -> Mesh {
+        Mesh::try_from(collider).expect("the collider should be convertible to a mesh")
+    }
+
+    fn num_indices(mesh: &Mesh) -> usize {
+        mesh.indices().unwrap().len()
+    }
+
+    fn positions(mesh: &Mesh) -> Vec<[f32; 3]> {
+        match mesh.attribute(Mesh::ATTRIBUTE_POSITION).unwrap() {
+            VertexAttributeValues::Float32x3(pos) => pos.clone(),
+            _ => panic!("unexpected position format"),
+        }
+    }
+
+    fn max_coord(mesh: &Mesh, axis: usize) -> f32 {
+        positions(mesh)
+            .iter()
+            .map(|p| p[axis])
+            .fold(f32::MIN, f32::max)
+    }
+
+    #[test]
+    fn voxels_mesh() {
+        let single = to_mesh(&Collider::voxels(Vect::ONE, &[crate::math::IVect::ZERO]));
+        assert_eq!(single.primitive_topology(), PrimitiveTopology::TriangleList);
+        let pair = to_mesh(&Collider::voxels(
+            Vect::ONE,
+            &[crate::math::IVect::ZERO, crate::math::IVect::X],
+        ));
+
+        #[cfg(feature = "dim3")]
+        {
+            // Six faces of two triangles, minus the two faces shared by adjacent voxels.
+            assert_eq!(num_indices(&single), 12 * 3);
+            assert_eq!(num_indices(&pair), 20 * 3);
+        }
+        #[cfg(feature = "dim2")]
+        {
+            // One quad per voxel.
+            assert_eq!(num_indices(&single), 2 * 3);
+            assert_eq!(num_indices(&pair), 4 * 3);
+        }
+        assert!((max_coord(&pair, 0) - 2.0).abs() < 1.0e-5);
+    }
+
+    #[test]
+    fn line_meshes() {
+        let segment = to_mesh(&Collider::segment(Vect::ZERO, Vect::X));
+        assert_eq!(segment.primitive_topology(), PrimitiveTopology::LineList);
+        assert_eq!(num_indices(&segment), 2);
+
+        let polyline = to_mesh(&Collider::polyline(
+            vec![Vect::ZERO, Vect::X, Vect::X + Vect::Y],
+            None,
+        ));
+        assert_eq!(polyline.primitive_topology(), PrimitiveTopology::LineList);
+        assert_eq!(num_indices(&polyline), 4);
+    }
+
+    #[test]
+    #[cfg(feature = "dim2")]
+    fn heightfield_2d_mesh() {
+        let mesh = to_mesh(&Collider::heightfield(vec![0.0, 1.0, 0.0, 1.0], Vect::ONE));
+        assert_eq!(mesh.primitive_topology(), PrimitiveTopology::LineList);
+        assert_eq!(num_indices(&mesh), 3 * 2);
+    }
+
+    #[test]
+    fn halfspace_mesh() {
+        let mesh = to_mesh(&Collider::halfspace(Vect::Y).unwrap());
+        assert!((max_coord(&mesh, 0) - HALF_SPACE_MESH_HALF_SIZE).abs() < 1.0e-3);
+        assert!(max_coord(&mesh, 1).abs() < 1.0e-3);
+    }
+
+    #[test]
+    fn round_shape_meshes() {
+        #[cfg(feature = "dim2")]
+        let round_cuboid = Collider::round_cuboid(1.0, 2.0, 0.5);
+        #[cfg(feature = "dim3")]
+        let round_cuboid = Collider::round_cuboid(1.0, 2.0, 3.0, 0.5);
+        let mesh = to_mesh(&round_cuboid);
+        assert_eq!(mesh.primitive_topology(), PrimitiveTopology::TriangleList);
+        assert!((max_coord(&mesh, 0) - 1.5).abs() < 1.0e-3);
+        assert!((max_coord(&mesh, 1) - 2.5).abs() < 1.0e-3);
+
+        let round_triangle = Collider::round_triangle(Vect::ZERO, Vect::X, Vect::Y, 0.1);
+        let mesh = to_mesh(&round_triangle);
+        assert!((max_coord(&mesh, 0) - 1.1).abs() < 1.0e-3);
+
+        #[cfg(feature = "dim3")]
+        {
+            let mesh = to_mesh(&Collider::round_cylinder(1.0, 0.5, 0.1));
+            assert!((max_coord(&mesh, 1) - 1.1).abs() < 1.0e-3);
+            let mesh = to_mesh(&Collider::round_cone(1.0, 0.5, 0.1));
+            assert!((max_coord(&mesh, 1) - 1.1).abs() < 1.0e-3);
+            let hull =
+                Collider::round_convex_hull(&[Vect::ZERO, Vect::X, Vect::Y, Vect::Z], 0.1).unwrap();
+            assert!(num_indices(&to_mesh(&hull)) > 0);
+        }
+        #[cfg(feature = "dim2")]
+        {
+            let hull = Collider::round_convex_hull(&[Vect::ZERO, Vect::X, Vect::Y], 0.1).unwrap();
+            assert!(num_indices(&to_mesh(&hull)) > 0);
+        }
+    }
+
+    #[test]
+    fn compound_mesh_applies_part_poses() {
+        let compound = Collider::compound(vec![
+            (Vect::X * 10.0, ROT_ID, Collider::ball(1.0)),
+            (Vect::ZERO, ROT_ID, Collider::cuboid_for_tests()),
+        ]);
+        let mesh = to_mesh(&compound);
+        // The ball mesh is an approximation that may not reach its exact radius along `x`.
+        let max_x = max_coord(&mesh, 0);
+        assert!(max_x > 10.5 && max_x < 11.0 + 1.0e-3, "{max_x}");
+        // The ball mesh has normals but not the convex hull mesh, so they must be dropped
+        // for all the remaining attributes to have one value per vertex.
+        assert!(!mesh.contains_attribute(Mesh::ATTRIBUTE_NORMAL));
+        for (_, values) in mesh.attributes() {
+            assert_eq!(values.len(), positions(&mesh).len());
+        }
+    }
+
+    #[cfg(feature = "dim3")]
+    #[test]
+    fn convex_polyhedron_mesh() {
+        let (vtx, _) = rapier::prelude::Cuboid::new(Vect::splat(0.5)).to_trimesh();
+        let mesh = to_mesh(&Collider::convex_hull(&vtx).unwrap());
+        assert_eq!(num_indices(&mesh), 12 * 3);
+    }
+
+    impl Collider {
+        fn cuboid_for_tests() -> Collider {
+            let (vtx, _) = rapier::prelude::Cuboid::new(Vect::splat(0.5)).to_trimesh();
+            Collider::convex_hull(&vtx).unwrap()
+        }
+    }
+}
diff --git a/bindings/bevy_rapier/src/lib.rs b/bindings/bevy_rapier/src/lib.rs
new file mode 100644
index 000000000..4cf5bf970
--- /dev/null
+++ b/bindings/bevy_rapier/src/lib.rs
@@ -0,0 +1,101 @@
+//!
+//! # Official integration of Rapier to the Bevy game engine
+//!
+//! Rapier is a set of two Rust crates `rapier2d` and `rapier3d` for efficient cross-platform
+//! physics simulation. Its target application include video games, animation, robotics, etc.
+//!
+//! The `bevy_rapier` project implements two crates `bevy_rapier2d` and `bevy_rapier3d` which
+//! define physics plugins for the Bevy game engine.
+//!
+//! User documentation for `bevy_rapier` is on [the official Rapier site](https://rapier.rs/docs/).
+//!
+#![warn(missing_docs)]
+
+#[macro_use]
+#[cfg(feature = "serde-serialize")]
+extern crate serde;
+
+pub extern crate nalgebra as na;
+#[cfg(feature = "dim2")]
+pub extern crate rapier2d as rapier;
+#[cfg(feature = "dim3")]
+pub extern crate rapier3d as rapier;
+pub use rapier::parry;
+/// Type aliases to select the right vector/rotation types based
+/// on the dimension used by the engine.
+#[cfg(feature = "dim2")]
+pub mod math {
+    use bevy::math::Vec2;
+    /// The real type (f32 or f64).
+    pub type Real = rapier::math::Real;
+    /// The vector type.
+    pub type Vect = Vec2;
+    /// The integer vector type.
+    pub type IVect = bevy::math::IVec2;
+    /// The rotation type (in 2D this is an angle in radians).
+    pub type Rot = Real;
+    /// The angular vector type (in 2D this is a scalar).
+    pub type AngVector = Real;
+}
+
+/// Type aliases to select the right vector/rotation types based
+/// on the dimension used by the engine.
+#[cfg(feature = "dim3")]
+pub mod math {
+    use bevy::math::{Quat, Vec3};
+    /// The real type (f32 or f64).
+    pub type Real = rapier::math::Real;
+    /// The vector type.
+    pub type Vect = Vec3;
+    /// The integer vector type.
+    pub type IVect = bevy::math::IVec3;
+    /// The rotation type.
+    pub type Rot = Quat;
+    /// The angular vector type.
+    pub type AngVector = Vec3;
+}
+
+/// Components related to physics dynamics (rigid-bodies, velocities, etc.)
+pub mod dynamics;
+/// Components related to physics geometry (colliders, collision-groups, etc.)
+pub mod geometry;
+/// Components and resources related to the physics simulation workflow (events, hooks, etc.)
+pub mod pipeline;
+/// The physics plugin and systems.
+pub mod plugin;
+
+/// Reflection utilities.
+pub mod reflect;
+
+#[cfg(feature = "picking-backend")]
+pub mod picking_backend;
+
+/// Components related to character control.
+pub mod control;
+/// The debug-renderer.
+#[cfg(any(feature = "debug-render-3d", feature = "debug-render-2d"))]
+pub mod render;
+/// Miscellaneous helper functions.
+pub mod utils;
+
+#[cfg(all(
+    feature = "dim3",
+    any(feature = "urdf", feature = "mjcf", feature = "meshloader")
+))]
+pub mod loaders;
+
+/// Groups the most often used types.
+pub mod prelude {
+    pub use crate::control::*;
+    pub use crate::dynamics::*;
+    pub use crate::geometry::*;
+    pub use crate::math::*;
+    #[cfg(feature = "picking-backend")]
+    pub use crate::picking_backend::*;
+    pub use crate::pipeline::*;
+    pub use crate::plugin::context::systemparams::*;
+    pub use crate::plugin::context::*;
+    pub use crate::plugin::*;
+    #[cfg(any(feature = "debug-render-3d", feature = "debug-render-2d"))]
+    pub use crate::render::*;
+}
diff --git a/bindings/bevy_rapier/src/loaders/common.rs b/bindings/bevy_rapier/src/loaders/common.rs
new file mode 100644
index 000000000..952f7c90a
--- /dev/null
+++ b/bindings/bevy_rapier/src/loaders/common.rs
@@ -0,0 +1,141 @@
+//! Conversions from Rapier objects built by the robot loaders into `bevy_rapier` components.
+
+use crate::dynamics::{
+    AdditionalMassProperties, AdditionalPgsIterations, AdditionalSolverIterations,
+    AllowFastRotation, Ccd, Damping, Dominance, GravityScale, GyroscopicForces, LockedAxes,
+    MassProperties, RigidBody, RigidBodyDisabled, Sleeping, SoftCcd, Velocity,
+};
+use crate::geometry::{
+    ActiveCollisionTypes, ActiveEvents, ActiveHooks, Collider, ColliderDisabled,
+    ColliderMassProperties, CollisionGroups, ContactForceEventThreshold, ContactSkin, Friction,
+    Restitution, Sensor, SolverGroups,
+};
+use crate::plugin::context::RapierContextEntityLink;
+use crate::utils::iso_to_transform;
+use bevy::ecs::system::EntityCommands;
+use bevy::prelude::*;
+use rapier::dynamics::{JointAxis, RigidBody as RapierRigidBody, RigidBodyAdditionalMassProps};
+use rapier::geometry::Collider as RapierCollider;
+
+/// The error returned when a robot description fails to load.
+pub type LoaderError = Box<dyn std::error::Error + Send + Sync>;
+
+/// Converts an axis index (`0..6`) into a [`JointAxis`].
+pub(crate) fn joint_axis(axis: usize) -> JointAxis {
+    match axis {
+        0 => JointAxis::LinX,
+        1 => JointAxis::LinY,
+        2 => JointAxis::LinZ,
+        3 => JointAxis::AngX,
+        4 => JointAxis::AngY,
+        _ => JointAxis::AngZ,
+    }
+}
+
+/// Inserts the components describing the given Rapier rigid-body (except its pose).
+pub(crate) fn insert_rigid_body(entity: &mut EntityCommands, rb: &RapierRigidBody) {
+    let activation = rb.activation();
+    entity.insert((
+        RigidBody::from(rb.body_type()),
+        Velocity {
+            linear: rb.linvel(),
+            angular: rb.angvel(),
+        },
+        Damping {
+            linear_damping: rb.linear_damping(),
+            angular_damping: rb.angular_damping(),
+        },
+        GravityScale(rb.gravity_scale()),
+        Ccd {
+            enabled: rb.is_ccd_enabled(),
+        },
+        SoftCcd {
+            prediction: rb.soft_ccd_prediction(),
+        },
+        Dominance::group(rb.dominance_group()),
+        Sleeping {
+            normalized_linear_threshold: activation.normalized_linear_threshold,
+            angular_threshold: activation.angular_threshold,
+            time_until_sleep: activation.time_until_sleep,
+            sleeping: activation.sleeping,
+        },
+        LockedAxes::from_bits_retain(rb.locked_axes().bits()),
+        AdditionalSolverIterations(rb.additional_solver_iterations()),
+        AdditionalPgsIterations(rb.additional_pgs_iterations()),
+        GyroscopicForces {
+            enabled: rb.gyroscopic_forces_enabled(),
+        },
+    ));
+
+    if let Some(mprops) = rb.mass_properties().additional_local_mprops.as_deref() {
+        entity.insert(match mprops {
+            RigidBodyAdditionalMassProps::MassProps(mprops) => {
+                AdditionalMassProperties::MassProperties(MassProperties::from_rapier(*mprops))
+            }
+            RigidBodyAdditionalMassProps::Mass(mass) => AdditionalMassProperties::Mass(*mass),
+        });
+    }
+    if !rb.is_enabled() {
+        entity.insert(RigidBodyDisabled);
+    }
+    if rb.is_fast_rotation_allowed() {
+        entity.insert(AllowFastRotation);
+    }
+}
+
+/// Inserts the components describing the given Rapier collider, including its local pose
+/// relative to its rigid-body.
+///
+/// The [`ActiveHooks`] of the collider are replaced by `hooks`.
+pub(crate) fn insert_collider(
+    entity: &mut EntityCommands,
+    co: &RapierCollider,
+    hooks: ActiveHooks,
+) {
+    // A collider with a zero density doesn't contribute to its body's mass. Other colliders keep
+    // their exact mass properties, whatever the way they were specified.
+    let mprops = if co.mass() == 0.0 {
+        ColliderMassProperties::Density(0.0)
+    } else {
+        ColliderMassProperties::MassProperties(MassProperties::from_rapier(co.mass_properties()))
+    };
+
+    entity.insert((
+        Collider::from(co.shared_shape().clone()),
+        iso_to_transform(co.position()),
+        mprops,
+        Friction {
+            coefficient: co.friction(),
+            combine_rule: co.friction_combine_rule().into(),
+        },
+        Restitution {
+            coefficient: co.restitution(),
+            combine_rule: co.restitution_combine_rule().into(),
+        },
+        CollisionGroups::from(co.collision_groups()),
+        SolverGroups::from(co.solver_groups()),
+        hooks,
+        ActiveEvents::from_bits_retain(co.active_events().bits()),
+        ActiveCollisionTypes::from_bits_retain(co.active_collision_types().bits()),
+        ContactSkin(co.contact_skin()),
+        ContactForceEventThreshold(co.contact_force_event_threshold()),
+    ));
+    if co.is_sensor() {
+        entity.insert(Sensor);
+    }
+    if !co.is_enabled() {
+        entity.insert(ColliderDisabled);
+    }
+}
+
+/// The [`ActiveHooks`] set on the given Rapier collider.
+pub(crate) fn active_hooks(co: &RapierCollider) -> ActiveHooks {
+    ActiveHooks::from_bits_retain(co.active_hooks().bits())
+}
+
+/// Inserts the [`RapierContextEntityLink`] of `context`, if any.
+pub(crate) fn insert_context_link(entity: &mut EntityCommands, context: Option<Entity>) {
+    if let Some(context) = context {
+        entity.insert(RapierContextEntityLink(context));
+    }
+}
diff --git a/bindings/bevy_rapier/src/loaders/meshloader.rs b/bindings/bevy_rapier/src/loaders/meshloader.rs
new file mode 100644
index 000000000..0c9c2823d
--- /dev/null
+++ b/bindings/bevy_rapier/src/loaders/meshloader.rs
@@ -0,0 +1,109 @@
+//! Building colliders from mesh files (STL, Collada and Wavefront OBJ) with `rapier3d-meshloader`.
+
+use crate::geometry::{Collider, MeshConverter};
+use crate::math::Vect;
+use crate::utils::iso_to_transform;
+use bevy::prelude::*;
+use rapier::geometry::SharedShape;
+use std::path::Path;
+
+pub use rapier3d_meshloader::{self, mesh_loader, MeshLoaderError};
+
+/// A collider built from one of the meshes of a mesh file.
+#[derive(Clone, Debug)]
+pub struct MeshFileCollider {
+    /// The collider computed from the mesh by the [`MeshConverter`].
+    pub collider: Collider,
+    /// The pose of the collider relative to the frame of the mesh file.
+    ///
+    /// This is the identity except for converters like [`MeshConverter::Obb`] which produce a
+    /// shape offset from the origin of the mesh.
+    pub transform: Transform,
+    /// The mesh read from the file, without any scaling.
+    pub raw_mesh: mesh_loader::Mesh,
+    /// The material of the mesh read from the file (default for STL files).
+    pub material: mesh_loader::Material,
+}
+
+/// Loads every mesh of a file, and converts each of them into a collider.
+///
+/// The file format is deduced from its extension. The `scale` is applied to the vertices before
+/// the `converter` computes the collider shape.
+pub fn load_mesh_file_colliders(
+    path: impl AsRef<Path>,
+    converter: &MeshConverter,
+    scale: Vect,
+) -> Result<Vec<MeshFileCollider>, MeshLoaderError> {
+    rapier3d_meshloader::load_from_path(path, converter, scale)?
+        .into_iter()
+        .map(|loaded| {
+            let loaded = loaded?;
+            Ok(MeshFileCollider {
+                collider: loaded.shape.into(),
+                transform: iso_to_transform(&loaded.pose),
+                raw_mesh: loaded.raw_mesh,
+                material: loaded.material,
+            })
+        })
+        .collect()
+}
+
+impl Collider {
+    /// Loads a collider from a mesh file (STL, Collada or Wavefront OBJ).
+    ///
+    /// The file format is deduced from its extension. The `scale` is applied to the vertices
+    /// before the `converter` computes the collider shape. If the file contains several meshes,
+    /// or if the converter offsets the shape from the mesh origin, the result is a compound
+    /// shape. See [`load_mesh_file_colliders`] to get the individual meshes instead.
+    pub fn from_mesh_file(
+        path: impl AsRef<Path>,
+        converter: &MeshConverter,
+        scale: Vect,
+    ) -> Result<Collider, MeshLoaderError> {
+        let mut parts: Vec<_> = rapier3d_meshloader::load_from_path(path, converter, scale)?
+            .into_iter()
+            .map(|loaded| loaded.map(|loaded| (loaded.pose, loaded.shape)))
+            .collect::<Result<_, _>>()?;
+
+        match parts.len() {
+            0 => Err(MeshLoaderError::Io(std::io::Error::new(
+                std::io::ErrorKind::InvalidData,
+                "the mesh file doesn't contain any mesh",
+            ))),
+            1 if parts[0].0 == rapier::math::Pose::IDENTITY => Ok(parts.remove(0).1.into()),
+            _ => Ok(SharedShape::compound(parts).into()),
+        }
+    }
+}
+
+/// Converts a mesh read by `mesh_loader` into a Bevy triangle mesh.
+///
+/// The `scale` is applied to the vertex positions. Normals are computed if the file doesn't
+/// provide them, and the first set of texture coordinates is kept.
+#[cfg(feature = "to-bevy-mesh")]
+pub fn raw_mesh_to_bevy_mesh(mesh: &mesh_loader::Mesh, scale: Vect) -> Mesh {
+    use bevy::asset::RenderAssetUsages;
+    use bevy::mesh::{Indices, PrimitiveTopology};
+
+    let positions: Vec<[f32; 3]> = mesh
+        .vertices
+        .iter()
+        .map(|v| (Vect::from(*v) * scale).into())
+        .collect();
+    let mut result = Mesh::new(
+        PrimitiveTopology::TriangleList,
+        RenderAssetUsages::default(),
+    )
+    .with_inserted_indices(Indices::U32(mesh.faces.iter().flatten().copied().collect()))
+    .with_inserted_attribute(Mesh::ATTRIBUTE_POSITION, positions);
+
+    if mesh.texcoords[0].len() == mesh.vertices.len() {
+        result.insert_attribute(Mesh::ATTRIBUTE_UV_0, mesh.texcoords[0].clone());
+    }
+    if mesh.normals.len() == mesh.vertices.len() && scale.x == scale.y && scale.y == scale.z {
+        result.insert_attribute(Mesh::ATTRIBUTE_NORMAL, mesh.normals.clone());
+    } else {
+        result.compute_normals();
+    }
+    result
+}
diff --git a/bindings/bevy_rapier/src/loaders/mjcf.rs b/bindings/bevy_rapier/src/loaders/mjcf.rs
new file mode 100644
index 000000000..5c8162b46
--- /dev/null
+++ b/bindings/bevy_rapier/src/loaders/mjcf.rs
@@ -0,0 +1,716 @@
+//! Spawning models described by MuJoCo MJCF files as `bevy_rapier` entities.
+//!
+//! Load a model with [`MjcfRobot::from_file`] or [`MjcfRobot::from_str`], then spawn it with
+//! [`spawn_mjcf_model`]:
+//!
+//! ```no_run
+//! # use bevy::prelude::*;
+//! use bevy_rapier3d::loaders::mjcf::{spawn_mjcf_model, MjcfLoaderOptions, MjcfRobot, MjcfSpawnOptions};
+//!
+//! fn setup(mut commands: Commands) {
+//!     let (robot, _) = MjcfRobot::from_file("model.xml", MjcfLoaderOptions::default()).unwrap();
+//!     let model = spawn_mjcf_model(&mut commands, &robot, &MjcfSpawnOptions::default());
+//!     println!("Spawned {} actuators.", model.actuators.len());
+//! }
+//! ```
+//!
+//! # What is translated
+//!
+//! - Each body becomes a rigid-body entity (child of [`SpawnedMjcfModel::root`]) with its mass
+//!   properties, and `gravcomp` as a [`GravityScale`](crate::dynamics::GravityScale). The implicit
+//!   world body is spawned as a fixed rigid-body when something is attached to it.
+//! - Each geom becomes a collider entity child of its body, with `contype`/`conaffinity` converted
+//!   to [`CollisionGroups`](crate::geometry::CollisionGroups) by `rapier3d-mjcf` (see
+//!   [`ContactFilterMode`]).
+//! - Joints become [`MultibodyJoint`]s (the default, matching MuJoCo's reduced coordinates) or
+//!   [`ImpulseJoint`]s, on the entity of their child body. With multibody joints, `damping`,
+//!   `armature`, `frictionloss`, `stiffness`/`springref`, `springdamper` and `<equality><joint>` /
+//!   fixed tendon couplings are converted into [`MultibodyJointDamping`],
+//!   [`MultibodyJointArmature`], [`MultibodyJointFriction`], [`MultibodyJointSprings`] and
+//!   [`MultibodyJointCouplings`]. With impulse joints, they are approximated by joint motors.
+//! - `<equality><connect>` and `<equality><weld>` become [`ImpulseJoint`]s on child entities of
+//!   their second body (multibodies can't form loops).
+//! - Each actuator becomes an entity with an [`MjcfActuator`] component, driving the motor of its
+//!   joint (with [`MotorModel::ForceBased`](crate::dynamics::MotorModel::ForceBased)) once
+//!   [`MjcfPlugin`] is added.
+//! - `<contact><exclude>` and the friction of `<contact><pair>` are registered in the
+//!   [`MjcfContactFilters`] resource, applied by the [`MjcfPhysicsHooks`] physics hooks.
+//!
+//! Keyframes, sensors, `solref`/`solimp`, `<contact><pair>` margins and the actuator types not
+//! handled by `rapier3d-mjcf` (e.g. `intvelocity`, muscles) are not translated. Visual-only geoms
+//! are exposed through the [`MjcfVisualMeshes`] component so they can be rendered.
+
+use crate::dynamics::{
+    free_joint_dofs, GenericJoint, ImpulseJoint, KinematicMultibodyJoint, MultibodyJoint,
+    MultibodyJointArmature, MultibodyJointCoupling, MultibodyJointCouplings, MultibodyJointDamping,
+    MultibodyJointFriction, MultibodyJointSprings, MultibodySelfContactsDisabled, JOINT_DOFS,
+};
+use crate::geometry::ActiveHooks;
+use crate::loaders::common::{
+    active_hooks, insert_collider, insert_context_link, insert_rigid_body, joint_axis,
+};
+use crate::math::{Real, Vect};
+use crate::pipeline::{BevyPhysicsHooks, ContactModificationContextView, PairFilterContextView};
+use crate::plugin::PhysicsSet;
+use crate::utils::iso_to_transform;
+use bevy::ecs::intern::Interned;
+use bevy::ecs::schedule::ScheduleLabel;
+use bevy::ecs::system::SystemParam;
+use bevy::platform::collections::{HashMap, HashSet};
+use bevy::prelude::*;
+use rapier::dynamics::{
+    GenericJoint as RapierGenericJoint, ImpulseJointSet, MultibodyJointHandle, MultibodyJointSet,
+    RigidBodyHandle, RigidBodySet,
+};
+use rapier::geometry::{ColliderSet, SolverFlags};
+use rapier3d_mjcf::{MjcfActuatorHandle, MjcfRobotHandles};
+
+pub use rapier3d_mjcf::{
+    self, mjcf_rs, ContactFilterMode, MjcfLoaderOptions, MjcfMultibodyOptions, MjcfRenderMaterial,
+    MjcfRobot, MjcfVisualMesh,
+};
+
+/// Options controlling how an [`MjcfRobot`] is spawned by [`spawn_mjcf_model`].
+#[derive(Clone, Debug)]
+pub struct MjcfSpawnOptions {
+    /// If `true` (default), the joints are spawned as [`MultibodyJoint`]s (reduced coordinates,
+    /// like MuJoCo). Otherwise, they are spawned as [`ImpulseJoint`]s.
+    pub multibody: bool,
+    /// Options applied to the multibody joints, if [`Self::multibody`] is `true`.
+    pub multibody_options: MjcfMultibodyOptions,
+    /// The transform of the root entity of the model, which all its bodies are children of
+    /// (default: identity).
+    pub root_transform: Transform,
+    /// The physics context the model is added to (default: `None`, the default context).
+    pub context: Option<Entity>,
+}
+
+impl Default for MjcfSpawnOptions {
+    fn default() -> Self {
+        Self {
+            multibody: true,
+            multibody_options: MjcfMultibodyOptions::empty(),
+            root_transform: Transform::IDENTITY,
+            context: None,
+        }
+    }
+}
+
+/// The entities spawned by [`spawn_mjcf_model`].
+///
+/// The vectors are indexed like the bodies, joints and actuators of the [`MjcfRobot`].
+#[derive(Clone, Debug)]
+pub struct SpawnedMjcfModel {
+    /// The entity every body is a child of. Despawning it despawns the whole model.
+    pub root: Entity,
+    /// The rigid-body entity of each body (`None` for the world body if nothing is attached to
+    /// it).
+    pub bodies: Vec<Option<Entity>>,
+    /// The collider entities of each body (children of the body entity).
+    pub colliders: Vec<Vec<Entity>>,
+    /// The entity containing each joint (the entity of its child body), or `None` if the joint
+    /// couldn't be created (e.g. a multibody joint closing a loop).
+    pub joints: Vec<Option<Entity>>,
+    /// The entity containing the impulse joint of each equality constraint, or `None` if it
+    /// wasn't created (see [`MjcfMultibodyOptions::SKIP_LOOP_CLOSURES`]).
+    pub equality_joints: Vec<Option<Entity>>,
+    /// The entity containing the [`MjcfActuator`] of each actuator.
+    pub actuators: Vec<Entity>,
+    /// The body entities, by MJCF body name.
+    pub bodies_by_name: HashMap<String, Entity>,
+    /// The joint entities, by MJCF joint name.
+    pub joints_by_name: HashMap<String, Entity>,
+    /// The collider entities, by MJCF geom name.
+    pub colliders_by_name: HashMap<String, Entity>,
+    /// The actuator entities, by MJCF actuator name.
+    pub actuators_by_name: HashMap<String, Entity>,
+    /// The gravity declared by the model (`<option gravity>`), expressed in the frame of the
+    /// parent of [`Self::root`].
+    ///
+    /// This isn't applied automatically: it can be copied into the
+    /// [`RapierConfiguration`](crate::plugin::RapierConfiguration) of the physics context.
+    pub gravity: Vect,
+}
+
+/// The index of the [`MjcfRobot`] body a rigid-body entity was spawned from by
+/// [`spawn_mjcf_model`].
+#[derive(Copy, Clone, Debug, PartialEq, Eq, Component)]
+pub struct MjcfBodyId(pub usize);
+
+/// The visual-only geoms of the body a rigid-body entity was spawned from.
+///
+/// This is added by [`spawn_mjcf_model`] to the body entities with visual geoms (when
+/// [`MjcfLoaderOptions::create_colliders_from_visual_shapes`] is `false`), so that rendering
+/// meshes can be attached to them. The mesh poses are relative to the body entity.
+#[derive(Clone, Debug, Component)]
+pub struct MjcfVisualMeshes(pub Vec<MjcfVisualMesh>);
+
+/// An MJCF actuator driving the motor of a joint.
+///
+/// This is spawned by [`spawn_mjcf_model`], and applied to the [`MultibodyJoint`] or
+/// [`ImpulseJoint`] of [`Self::joint`] by the [`apply_mjcf_actuators`] system (added by
+/// [`MjcfPlugin`]) whenever this component changes. Set [`Self::ctrl`] to control the actuator.
+#[derive(Clone, Debug, Component)]
+pub struct MjcfActuator {
+    /// The actuator description.
+    pub actuator: mjcf_rs::extras::Actuator,
+    /// The entity containing the joint driven by this actuator, if it was created.
+    pub joint: Option<Entity>,
+    /// The control input of the actuator (MuJoCo's `ctrl`, default: `0`).
+    pub ctrl: Real,
+    /// A uniform scale applied to the gains and force limits of the actuator (default: `1`).
+    pub gain_scale: Real,
+}
+
+impl MjcfActuator {
+    /// Configures the motor of the given joint as this actuator does with its current control.
+    ///
+    /// The motors use the [`MotorModel::ForceBased`](crate::dynamics::MotorModel::ForceBased)
+    /// model, and their target and gains depend on the actuator type, following
+    /// `rapier3d-mjcf`'s `MjcfRobotHandles::apply_controls`.
+    pub fn configure_joint(&self, joint: &mut RapierGenericJoint) {
+        // Reuse `rapier3d-mjcf`'s actuator semantics by running them on a single-joint set.
+        let mut joints = ImpulseJointSet::new();
+        let handle = joints.insert(
+            RigidBodyHandle::from_raw_parts(0, 0),
+            RigidBodyHandle::from_raw_parts(1, 0),
+            *joint,
+            false,
+        );
+        let handles = MjcfRobotHandles {
+            bodies: vec![],
+            joints: vec![],
+            equality_joints: vec![],
+            actuators: vec![MjcfActuatorHandle {
+                actuator: self.actuator.clone(),
+                joint: Some(handle),
+            }],
+        };
+        handles.apply_controls_scaled(&mut joints, &[self.ctrl], self.gain_scale);
+        if let Some(configured) = joints.get(handle) {
+            *joint = configured.data;
+        }
+    }
+}
+
+/// System applying the [`MjcfActuator`]s that changed to the joints they drive.
+pub fn apply_mjcf_actuators(
+    actuators: Query<&MjcfActuator, Changed<MjcfActuator>>,
+    mut multibody_joints: Query<&mut MultibodyJoint>,
+    mut impulse_joints: Query<&mut ImpulseJoint, Without<MultibodyJoint>>,
+) {
+    for actuator in actuators.iter() {
+        let Some(entity) = actuator.joint else {
+            continue;
+        };
+        if let Ok(mut joint) = multibody_joints.get_mut(entity) {
+            actuator.configure_joint(&mut joint.data.as_mut().raw);
+        } else if let Ok(mut joint) = impulse_joints.get_mut(entity) {
+            actuator.configure_joint(&mut joint.data.as_mut().raw);
+        }
+    }
+}
+
+/// Plugin running the [`apply_mjcf_actuators`] system and initializing the
+/// [`MjcfContactFilters`] resource.
+///
+/// Its schedule must match the one of the
+/// [`RapierPhysicsPlugin`](crate::plugin::RapierPhysicsPlugin) (`PostUpdate` by default).
+pub struct MjcfPlugin {
+    schedule: Interned<dyn ScheduleLabel>,
+}
+
+impl MjcfPlugin {
+    /// Runs the actuator system in the given schedule, before [`PhysicsSet::SyncBackend`].
+    pub fn in_schedule(schedule: impl ScheduleLabel) -> Self {
+        Self {
+            schedule: schedule.intern(),
+        }
+    }
+}
+
+impl Default for MjcfPlugin {
+    fn default() -> Self {
+        Self::in_schedule(PostUpdate)
+    }
+}
+
+impl Plugin for MjcfPlugin {
+    fn build(&self, app: &mut App) {
+        app.init_resource::<MjcfContactFilters>().add_systems(
+            self.schedule,
+            apply_mjcf_actuators.before(PhysicsSet::SyncBackend),
+        );
+    }
+}
+
+/// The contact filtering rules of MJCF models: `<contact><exclude>` and the friction overrides of
+/// `<contact><pair>`, between collider entities.
+///
+/// [`spawn_mjcf_model`] registers the rules of each model in this resource. They are applied by
+/// the [`MjcfPhysicsHooks`] physics hooks, or by custom hooks calling
+/// [`Self::filter_contact_pair`] and [`Self::modify_solver_contacts`]. The colliders involved in
+/// these rules have their [`ActiveHooks`] set accordingly.
+#[derive(Clone, Debug, Default, Resource)]
+pub struct MjcfContactFilters {
+    /// Pairs of colliders that never generate contacts (both orders are stored).
+    pub excluded: HashSet<(Entity, Entity)>,
+    /// Friction coefficient overrides of pairs of colliders (both orders are stored).
+    pub friction: HashMap<(Entity, Entity), Real>,
+}
+
+impl MjcfContactFilters {
+    /// Prevents contacts between two colliders.
+    pub fn exclude(&mut self, collider1: Entity, collider2: Entity) {
+        self.excluded.insert((collider1, collider2));
+        self.excluded.insert((collider2, collider1));
+    }
+
+    /// Overrides the friction coefficient of the contacts between two colliders.
+    pub fn set_friction(&mut self, collider1: Entity, collider2: Entity, friction: Real) {
+        self.friction.insert((collider1, collider2), friction);
+        self.friction.insert((collider2, collider1), friction);
+    }
+
+    /// Removes all the rules involving the given collider.
+    pub fn remove(&mut self, collider: Entity) {
+        self.excluded
+            .retain(|(a, b)| *a != collider && *b != collider);
+        self.friction
+            .retain(|(a, b), _| *a != collider && *b != collider);
+    }
+
+    /// Filters a contact pair according to these rules.
+    pub fn filter_contact_pair(&self, context: &PairFilterContextView) -> Option<SolverFlags> {
+        let pair = (context.collider1(), context.collider2());
+        (!self.excluded.contains(&pair)).then_some(SolverFlags::COMPUTE_RIGID_IMPULSES)
+    }
+
+    /// Modifies the solver contacts of a contact pair according to these rules.
+    pub fn modify_solver_contacts(&self, context: &mut ContactModificationContextView) {
+        let pair = (context.collider1(), context.collider2());
+        if let Some(friction) = self.friction.get(&pair) {
+            context.set_friction(*friction);
+        }
+    }
+}
+
+/// Physics hooks applying the [`MjcfContactFilters`] resource.
+///
+/// Use it as the hooks of the physics plugin: `RapierPhysicsPlugin::<MjcfPhysicsHooks>`.
+#[derive(SystemParam)]
+pub struct MjcfPhysicsHooks<'w> {
+    filters: Option<Res<'w, MjcfContactFilters>>,
+}
+
+impl BevyPhysicsHooks for MjcfPhysicsHooks<'_> {
+    fn filter_contact_pair(&self, context: PairFilterContextView) -> Option<SolverFlags> {
+        match &self.filters {
+            Some(filters) => filters.filter_contact_pair(&context),
+            None => Some(SolverFlags::COMPUTE_RIGID_IMPULSES),
+        }
+    }
+
+    fn modify_solver_contacts(&self, mut context: ContactModificationContextView) {
+        if let Some(filters) = &self.filters {
+            filters.modify_solver_contacts(&mut context);
+        }
+    }
+}
+
+/// The per-joint multibody properties computed by `rapier3d-mjcf`, read from a scratch insertion
+/// of the model into Rapier.
+struct MultibodyJointProperties {
+    data: RapierGenericJoint,
+    kinematic: bool,
+    damping: MultibodyJointDamping,
+    armature: MultibodyJointArmature,
+    friction: MultibodyJointFriction,
+    springs: MultibodyJointSprings,
+}
+
+/// The result of inserting the model with `rapier3d-mjcf`'s multibody path, which resolves the
+/// joint properties depending on the assembled multibody (e.g. `springdamper`).
+struct MultibodyScratch {
+    handles: MjcfRobotHandles<Option<MultibodyJointHandle>>,
+    joints: MultibodyJointSet,
+}
+
+impl MultibodyScratch {
+    fn new(robot: &MjcfRobot, options: MjcfMultibodyOptions) -> Self {
+        let mut joints = MultibodyJointSet::new();
+        let handles = robot.clone().insert_using_multibody_joints(
+            &mut RigidBodySet::new(),
+            &mut ColliderSet::new(),
+            &mut joints,
+            &mut ImpulseJointSet::new(),
+            options,
+        );
+        Self { handles, joints }
+    }
+
+    fn joint_properties(&self, handle: MultibodyJointHandle) -> Option<MultibodyJointProperties> {
+        let (mb, link_id) = self.joints.get(handle)?;
+        let link = mb.link(link_id)?;
+        let joint = link.joint();
+        let offset = link.assembly_id();
+        let data = joint.data;
+        let mut result = MultibodyJointProperties {
+            data,
+            kinematic: joint.kinematic,
+            damping: default(),
+            armature: default(),
+            friction: default(),
+            springs: default(),
+        };
+        for (dof, axis) in free_joint_dofs(joint.data.locked_axes) {
+            result.damping.0[axis] = mb.damping()[offset + dof];
+            result.armature.0[axis] = mb.armature()[offset + dof];
+            result.friction.0[axis] = mb.frictions()[offset + dof];
+        }
+        for axis in 0..JOINT_DOFS {
+            let (stiffness, rest) = joint.spring(axis);
+            result.springs.stiffness[axis] = stiffness;
+            result.springs.rest[axis] = rest;
+        }
+        Some(result)
+    }
+
+    /// The index of the body of `handle` in the model.
+    fn body_index(&self, handle: RigidBodyHandle) -> Option<usize> {
+        self.handles
+            .bodies
+            .iter()
+            .position(|b| b.as_ref().is_some_and(|b| b.body == handle))
+    }
+}
+
+/// Spawns the bodies, colliders, joints and actuators of an MJCF model.
+///
+/// See the [module documentation](self) for details.
+pub fn spawn_mjcf_model(
+    commands: &mut Commands,
+    robot: &MjcfRobot,
+    options: &MjcfSpawnOptions,
+) -> SpawnedMjcfModel {
+    let multibody_options = options.multibody_options;
+    let skip_loop_closures =
+        options.multibody && multibody_options.contains(MjcfMultibodyOptions::SKIP_LOOP_CLOSURES);
+    let scratch = options
+        .multibody
+        .then(|| MultibodyScratch::new(robot, multibody_options));
+
+    let name = robot
+        .name
+        .clone()
+        .unwrap_or_else(|| "mjcf model".to_string());
+    let mut root = commands.spawn((options.root_transform, Name::new(name)));
+    insert_context_link(&mut root, options.context);
+    let root = root.id();
+
+    // The world body is only needed when something is attached to it.
+    let world_needed = match &scratch {
+        Some(scratch) => scratch.handles.bodies.first().is_some_and(|b| b.is_some()),
+        None => {
+            robot.joints.iter().any(|j| j.link1 == 0 || j.link2 == 0)
+                || robot
+                    .equality_joints
+                    .iter()
+                    .any(|j| j.link1 == 0 || j.link2 == 0)
+                || robot
+                    .bodies
+                    .first()
+                    .is_some_and(|b| !b.colliders.is_empty())
+        }
+    };
+
+    // Collect the colliders involved in contact rules, which are the only ones needing hooks.
+    let body_colliders = |body_name: &str| {
+        robot
+            .body_name_to_idx
+            .get(body_name)
+            .map(|b| (0..robot.bodies[*b].colliders.len()).map(move |k| (*b, k)))
+            .into_iter()
+            .flatten()
+    };
+    let mut excluded = vec![];
+    for exclude in &robot.contact_excludes {
+        for c1 in body_colliders(&exclude.body1) {
+            for c2 in body_colliders(&exclude.body2) {
+                excluded.push((c1, c2));
+            }
+        }
+    }
+    let mut friction_overrides = vec![];
+    for pair in &robot.contact_pairs {
+        let c1 = robot.geom_name_to_collider.get(&pair.geom1);
+        let c2 = robot.geom_name_to_collider.get(&pair.geom2);
+        if let (Some(c1), Some(c2), Some(friction)) = (c1, c2, pair.friction) {
+            friction_overrides.push((*c1, *c2, friction[0] as Real));
+        }
+    }
+    let with_hooks: HashSet<(usize, usize)> = excluded
+        .iter()
+        .flat_map(|(c1, c2)| [*c1, *c2])
+        .chain(friction_overrides.iter().flat_map(|(c1, c2, _)| [*c1, *c2]))
+        .collect();
+    let geom_names: HashMap<(usize, usize), &String> = robot
+        .geom_name_to_collider
+        .iter()
+        .map(|(name, id)| (*id, name))
+        .collect();
+
+    let mut result = SpawnedMjcfModel {
+        root,
+        bodies: vec![],
+        colliders: vec![],
+        joints: vec![],
+        equality_joints: vec![],
+        actuators: vec![],
+        bodies_by_name: default(),
+        joints_by_name: default(),
+        colliders_by_name: default(),
+        actuators_by_name: default(),
+        gravity: options.root_transform.rotation * (robot.base_shift.rotation * robot.gravity),
+    };
+
+    for (i, body) in robot.bodies.iter().enumerate() {
+        if i == 0 && !world_needed {
+            result.bodies.push(None);
+            result.colliders.push(vec![]);
+            continue;
+        }
+
+        let name = body.name.clone().unwrap_or_else(|| {
+            if i == 0 {
+                "world".into()
+            } else {
+                format!("body {i}")
+            }
+        });
+        let mut entity = commands.spawn((
+            ChildOf(root),
+            iso_to_transform(body.body.position()),
+            Name::new(name.clone()),
+            MjcfBodyId(i),
+        ));
+        insert_rigid_body(&mut entity, &body.body);
+        insert_context_link(&mut entity, options.context);
+        if !body.visual_meshes.is_empty() {
+            entity.insert(MjcfVisualMeshes(body.visual_meshes.clone()));
+        }
+        let body_entity = entity.id();
+
+        let colliders: Vec<_> = body
+            .colliders
+            .iter()
+            .enumerate()
+            .map(|(k, co)| {
+                let geom_name = geom_names.get(&(i, k));
+                let name = geom_name.map_or_else(|| format!("{name} geom {k}"), |n| n.to_string());
+                let hooks = if with_hooks.contains(&(i, k)) {
+                    active_hooks(co)
+                } else {
+                    active_hooks(co)
+                        - (ActiveHooks::FILTER_CONTACT_PAIRS | ActiveHooks::MODIFY_SOLVER_CONTACTS)
+                };
+                let mut entity = commands.spawn((ChildOf(body_entity), Name::new(name)));
+                insert_collider(&mut entity, co, hooks);
+                insert_context_link(&mut entity, options.context);
+                if let Some(geom_name) = geom_name {
+                    result
+                        .colliders_by_name
+                        .insert(geom_name.to_string(), entity.id());
+                }
+                entity.id()
+            })
+            .collect();
+
+        if let Some(name) = &body.name {
+            result.bodies_by_name.insert(name.clone(), body_entity);
+        }
+        result.bodies.push(Some(body_entity));
+        result.colliders.push(colliders);
+    }
+
+    // Joints are added to the entity of their child body, or to a new child entity of that body
+    // if it already contains a joint.
+    let mut has_joint = vec![false; robot.bodies.len()];
+    let mut joint_entity = |commands: &mut Commands, link2: usize, body2: Entity| {
+        if std::mem::replace(&mut has_joint[link2], true) {
+            let mut entity = commands.spawn(ChildOf(body2));
+            insert_context_link(&mut entity, options.context);
+            entity.id()
+        } else {
+            body2
+        }
+    };
+
+    for (i, joint) in robot.joints.iter().enumerate() {
+        let bodies = (
+            result.bodies.get(joint.link1).copied().flatten(),
+            result.bodies.get(joint.link2).copied().flatten(),
+        );
+        let (Some(body1), Some(body2)) = bodies else {
+            result.joints.push(None);
+            continue;
+        };
+
+        let entity = if let Some(scratch) = &scratch {
+            let Some(props) = scratch
+                .handles
+                .joints
+                .get(i)
+                .and_then(|h| h.joint)
+                .and_then(|h| scratch.joint_properties(h))
+            else {
+                result.joints.push(None);
+                continue;
+            };
+            let entity = joint_entity(commands, joint.link2, body2);
+            let mut entity_commands = commands.entity(entity);
+            entity_commands.insert(MultibodyJoint::new(body1, GenericJoint { raw: props.data }));
+            if props.kinematic {
+                entity_commands.insert(KinematicMultibodyJoint);
+            }
+            if props.damping != MultibodyJointDamping::default() {
+                entity_commands.insert(props.damping);
+            }
+            if props.armature != MultibodyJointArmature::default() {
+                entity_commands.insert(props.armature);
+            }
+            if props.friction != MultibodyJointFriction::default() {
+                entity_commands.insert(props.friction);
+            }
+            if props.springs != MultibodyJointSprings::default() {
+                entity_commands.insert(props.springs);
+            }
+            entity
+        } else {
+            let entity = joint_entity(commands, joint.link2, body2);
+            commands
+                .entity(entity)
+                .insert(ImpulseJoint::new(body1, GenericJoint { raw: joint.joint }));
+            entity
+        };
+
+        if let Some(name) = &joint.name {
+            result.joints_by_name.insert(name.clone(), entity);
+        }
+        result.joints.push(Some(entity));
+    }
+
+    if let Some(scratch) = &scratch {
+        // DoF couplings, stored on the joint of their second link.
+        let mut couplings: HashMap<Entity, Vec<MultibodyJointCoupling>> = default();
+        let link_entity = |mb: &rapier::dynamics::Multibody, link: usize| {
+            let handle = mb.link(link)?.rigid_body_handle();
+            result
+                .bodies
+                .get(scratch.body_index(handle)?)
+                .copied()
+                .flatten()
+        };
+        for mb in scratch.joints.multibodies() {
+            for c in mb.couplings() {
+                let (Some(source), Some(target)) =
+                    (link_entity(mb, c.link1), link_entity(mb, c.link2))
+                else {
+                    continue;
+                };
+                couplings
+                    .entry(target)
+                    .or_default()
+                    .push(MultibodyJointCoupling::new(
+                        joint_axis(c.axis2),
+                        source,
+                        joint_axis(c.axis1),
+                        c.coeff,
+                        c.offset,
+                    ));
+            }
+            if !mb.self_contacts_enabled() {
+                if let Some(root) = link_entity(mb, 0) {
+                    commands.entity(root).insert(MultibodySelfContactsDisabled);
+                }
+            }
+        }
+        for (entity, couplings) in couplings {
+            commands
+                .entity(entity)
+                .insert(MultibodyJointCouplings(couplings));
+        }
+    }
+
+    for eq in &robot.equality_joints {
+        let bodies = (
+            result.bodies.get(eq.link1).copied().flatten(),
+            result.bodies.get(eq.link2).copied().flatten(),
+        );
+        let (Some(body1), Some(body2), false) = (bodies.0, bodies.1, skip_loop_closures) else {
+            result.equality_joints.push(None);
+            continue;
+        };
+        let mut data = eq.joint;
+        data.set_enabled(eq.active);
+        let name = eq.name.clone().unwrap_or_else(|| "equality".into());
+        let mut entity = commands.spawn((
+            ChildOf(body2),
+            Name::new(name),
+            ImpulseJoint::new(body1, GenericJoint { raw: data }),
+        ));
+        insert_context_link(&mut entity, options.context);
+        result.equality_joints.push(Some(entity.id()));
+    }
+
+    for (i, binding) in robot.actuators.iter().enumerate() {
+        let name = binding
+            .actuator
+            .name
+            .clone()
+            .unwrap_or_else(|| format!("actuator {i}"));
+        let joint = binding
+            .joint_index
+            .and_then(|j| result.joints.get(j).copied().flatten());
+        let entity = commands
+            .spawn((
+                ChildOf(root),
+                Name::new(name.clone()),
+                MjcfActuator {
+                    actuator: binding.actuator.clone(),
+                    joint,
+                    ctrl: 0.0,
+                    gain_scale: 1.0,
+                },
+            ))
+            .id();
+        if binding.actuator.name.is_some() {
+            result.actuators_by_name.insert(name, entity);
+        }
+        result.actuators.push(entity);
+    }
+
+    // Register the contact rules between the spawned collider entities.
+    let collider = |(b, k): (usize, usize)| result.colliders.get(b)?.get(k).copied();
+    let excluded: Vec<_> = excluded
+        .into_iter()
+        .filter_map(|(c1, c2)| Some((collider(c1)?, collider(c2)?)))
+        .collect();
+    let friction_overrides: Vec<_> = friction_overrides
+        .into_iter()
+        .filter_map(|(c1, c2, f)| Some((collider(c1)?, collider(c2)?, f)))
+        .collect();
+    if !excluded.is_empty() || !friction_overrides.is_empty() {
+        commands.queue(move |world: &mut World| {
+            let mut filters = world.get_resource_or_init::<MjcfContactFilters>();
+            for (c1, c2) in excluded {
+                filters.exclude(c1, c2);
+            }
+            for (c1, c2, friction) in friction_overrides {
+                filters.set_friction(c1, c2, friction);
+            }
+        });
+    }
+
+    result
+}
diff --git a/bindings/bevy_rapier/src/loaders/mod.rs b/bindings/bevy_rapier/src/loaders/mod.rs
new file mode 100644
index 000000000..1e05b7d95
--- /dev/null
+++ b/bindings/bevy_rapier/src/loaders/mod.rs
@@ -0,0 +1,27 @@
+//! Loaders creating `bevy_rapier` entities from robot descriptions (URDF, MJCF) and colliders
+//! from mesh files.
+//!
+//! Each loader is enabled by the cargo feature of the same name:
+//! - `urdf`: [`urdf::spawn_urdf_robot`] spawns a robot loaded from an URDF file.
+//! - `mjcf`: [`mjcf::spawn_mjcf_model`] spawns a model loaded from a MuJoCo MJCF file.
+//! - `meshloader`: [`Collider::from_mesh_file`](crate::geometry::Collider::from_mesh_file)
+//!   builds colliders from STL, Collada or Wavefront files.
+//!
+//! The robot loaders don't insert anything into the physics scene directly: they spawn entities
+//! with regular `bevy_rapier` components (rigid-bodies, colliders, joints), so the usual
+//! component synchronization stays authoritative.
+
+#[cfg(any(feature = "urdf", feature = "mjcf"))]
+mod common;
+#[cfg(feature = "meshloader")]
+pub mod meshloader;
+#[cfg(feature = "mjcf")]
+pub mod mjcf;
+#[cfg(feature = "urdf")]
+pub mod urdf;
+
+#[cfg(any(feature = "urdf", feature = "mjcf"))]
+pub use common::LoaderError;
+
+#[cfg(test)]
+mod tests;
diff --git a/bindings/bevy_rapier/src/loaders/tests.rs b/bindings/bevy_rapier/src/loaders/tests.rs
new file mode 100644
index 000000000..a07caf3c6
--- /dev/null
+++ b/bindings/bevy_rapier/src/loaders/tests.rs
@@ -0,0 +1,649 @@
+//! Tests of the URDF, MJCF and mesh loaders.
+
+use bevy::prelude::*;
+#[cfg(any(feature = "urdf", feature = "mjcf"))]
+use bevy::time::{TimePlugin, TimeUpdateStrategy};
+
+use crate::prelude::*;
+
+/// An app with the given physics plugins, running the physics at a fixed 60Hz timestep.
+#[cfg(any(feature = "urdf", feature = "mjcf"))]
+fn test_app<M>(plugins: impl bevy::app::Plugins<M>) -> App {
+    let mut app = App::new();
+    app.add_plugins((TransformPlugin, TimePlugin));
+    app.add_plugins(plugins);
+    app.insert_resource(TimestepMode::Fixed {
+        dt: 1.0 / 60.0,
+        substeps: 1,
+    });
+    app.insert_resource(TimeUpdateStrategy::ManualDuration(
+        std::time::Duration::from_secs_f32(1.0 / 60.0),
+    ));
+    app.finish();
+    app
+}
+
+/// The world-space translation of a rigid-body in the default context.
+#[cfg(any(feature = "urdf", feature = "mjcf"))]
+fn body_translation(app: &mut App, entity: Entity) -> Vect {
+    let bodies = app
+        .world_mut()
+        .query::<&RapierRigidBodySet>()
+        .single(app.world())
+        .unwrap();
+    let handle = bodies.entity2body()[&entity];
+    bodies.bodies[handle].translation()
+}
+
+#[cfg(feature = "urdf")]
+mod urdf {
+    use super::*;
+    use crate::loaders::urdf::*;
+    use std::path::Path;
+
+    const ARM: &str = r#"
+<robot name="arm">
+  <link name="world"/>
+  <link name="base">
+    <inertial>
+      <mass value="1"/>
+      <inertia ixx="0.1" ixy="0" ixz="0" iyy="0.1" iyz="0" izz="0.1"/>
+    </inertial>
+    <collision><geometry><box size="0.2 0.2 0.2"/></geometry></collision>
+  </link>
+  <link name="arm">
+    <inertial>
+      <origin xyz="0 0 0.25"/>
+      <mass value="0.5"/>
+      <inertia ixx="0.01" ixy="0" ixz="0" iyy="0.01" iyz="0" izz="0.001"/>
+    </inertial>
+    <visual><geometry><cylinder radius="0.05" length="0.5"/></geometry></visual>
+    <collision>
+      <origin xyz="0 0 0.25"/>
+      <geometry><cylinder radius="0.05" length="0.5"/></geometry>
+    </collision>
+  </link>
+  <link name="finger">
+    <inertial>
+      <mass value="0.1"/>
+      <inertia ixx="0.001" ixy="0" ixz="0" iyy="0.001" iyz="0" izz="0.001"/>
+    </inertial>
+    <collision><geometry><sphere radius="0.05"/></geometry></collision>
+  </link>
+  <joint name="anchor" type="fixed">
+    <parent link="world"/><child link="base"/>
+  </joint>
+  <joint name="shoulder" type="revolute">
+    <parent link="base"/><child link="arm"/>
+    <origin xyz="0 0 0.1" rpy="0.5 0 0"/>
+    <axis xyz="0 1 0"/>
+    <limit lower="-1" upper="1" effort="10" velocity="1"/>
+    <dynamics damping="0.3" friction="0.2"/>
+  </joint>
+  <joint name="finger_joint" type="revolute">
+    <parent link="arm"/><child link="finger"/>
+    <origin xyz="0 0 0.5"/>
+    <axis xyz="0 1 0"/>
+    <limit lower="-1" upper="1" effort="10" velocity="1"/>
+    <mimic joint="shoulder" multiplier="2" offset="0.1"/>
+  </joint>
+</robot>
+"#;
+
+    fn load() -> UrdfModel {
+        UrdfModel::from_str(ARM, UrdfLoaderOptions::default(), Path::new(".")).unwrap()
+    }
+
+    #[test]
+    fn empty_links_are_tracked() {
+        let model = load();
+        // The empty `world` link is removed, and `base` is fixed in its place.
+        assert_eq!(model.robot.links.len(), 3);
+        let names: Vec<_> = (0..3)
+            .map(|i| model.urdf_link(i).unwrap().name.as_str())
+            .collect();
+        assert_eq!(names, ["base", "arm", "finger"]);
+        let joints: Vec<_> = (0..model.robot.joints.len())
+            .map(|i| model.urdf_joint(i).unwrap().name.as_str())
+            .collect();
+        assert_eq!(joints, ["shoulder", "finger_joint"]);
+    }
+
+    /// `mount` is an empty link between `hinge` and `mount_joint`, which are merged when it is
+    /// removed.
+    const MOUNTED: &str = r#"
+<robot name="mounted">
+  <link name="base">
+    <inertial>
+      <mass value="1"/>
+      <inertia ixx="0.1" ixy="0" ixz="0" iyy="0.1" iyz="0" izz="0.1"/>
+    </inertial>
+  </link>
+  <link name="mount"/>
+  <link name="arm">
+    <inertial>
+      <mass value="0.5"/>
+      <inertia ixx="0.01" ixy="0" ixz="0" iyy="0.01" iyz="0" izz="0.01"/>
+    </inertial>
+  </link>
+  <link name="finger">
+    <inertial>
+      <mass value="0.1"/>
+      <inertia ixx="0.001" ixy="0" ixz="0" iyy="0.001" iyz="0" izz="0.001"/>
+    </inertial>
+  </link>
+  <joint name="hinge" type="revolute">
+    <parent link="base"/><child link="mount"/>
+    <axis xyz="0 1 0"/>
+    <limit lower="-1" upper="1" effort="10" velocity="1"/>
+    <dynamics damping="0.3" friction="0.2"/>
+  </joint>
+  <joint name="mount_joint" type="fixed">
+    <origin xyz="0 0 0.5"/>
+    <parent link="mount"/><child link="arm"/>
+  </joint>
+  <joint name="finger_joint" type="revolute">
+    <parent link="arm"/><child link="finger"/>
+    <origin xyz="0 0 0.5"/>
+    <axis xyz="0 1 0"/>
+    <limit lower="-1" upper="1" effort="10" velocity="1"/>
+    <mimic joint="hinge" multiplier="2"/>
+  </joint>
+</robot>
+"#;
+
+    #[test]
+    fn merged_joints_are_tracked() {
+        let model =
+            UrdfModel::from_str(MOUNTED, UrdfLoaderOptions::default(), Path::new(".")).unwrap();
+        let names: Vec<_> = (0..model.robot.links.len())
+            .map(|i| model.urdf_link(i).unwrap().name.as_str())
+            .collect();
+        assert_eq!(names, ["base", "arm", "finger"]);
+        assert_eq!(model.urdf_joint(0).unwrap().name, "mount_joint");
+        assert_eq!(model.source_urdf_joint(0).unwrap().name, "hinge");
+        assert_eq!(model.source_urdf_joint(1).unwrap().name, "finger_joint");
+
+        let mut app = test_app(RapierPhysicsPlugin::<NoUserData>::default());
+        app.update();
+        let robot = spawn_urdf_robot(
+            &mut app.world_mut().commands(),
+            &model,
+            &UrdfSpawnOptions {
+                multibody: true,
+                ..default()
+            },
+        );
+        app.world_mut().flush();
+
+        let arm = robot.links_by_name["arm"];
+        assert_eq!(robot.joints_by_name["hinge"], arm);
+        assert_eq!(robot.joints_by_name["mount_joint"], arm);
+        assert_eq!(app.world().get::<UrdfLinkId>(arm), Some(&UrdfLinkId(2)));
+        // The merged joint gets the dynamics of the revolute joint, which drives the mimic.
+        let damping = app.world().get::<MultibodyJointDamping>(arm).unwrap();
+        assert_eq!(damping.0[JointAxis::AngX as usize], 0.3);
+        let finger = robot.links_by_name["finger"];
+        let couplings = app.world().get::<MultibodyJointCouplings>(finger).unwrap();
+        assert_eq!(couplings.0[0].source, arm);
+    }
+
+    fn spawn(multibody: bool) -> (App, SpawnedUrdfRobot) {
+        let model = load();
+        let mut app = test_app(RapierPhysicsPlugin::<NoUserData>::default());
+        app.update();
+        let robot = spawn_urdf_robot(
+            &mut app.world_mut().commands(),
+            &model,
+            &UrdfSpawnOptions {
+                multibody,
+                root_transform: Transform::from_xyz(1.0, 2.0, 3.0),
+                ..default()
+            },
+        );
+        app.world_mut().flush();
+        (app, robot)
+    }
+
+    fn check_robot(app: &mut App, robot: &SpawnedUrdfRobot) {
+        assert_eq!(robot.links.len(), 3);
+        assert_eq!(robot.joints.len(), 2);
+        assert_eq!(robot.joints_by_name["shoulder"], robot.links_by_name["arm"]);
+        for (link, colliders) in robot.links.iter().zip(&robot.colliders) {
+            assert!(app.world().get::<RapierRigidBodyHandle>(*link).is_some());
+            assert_eq!(colliders.len(), 1);
+            assert!(app
+                .world()
+                .get::<RapierColliderHandle>(colliders[0])
+                .is_some());
+        }
+        let base = robot.links_by_name["base"];
+        let arm = robot.links_by_name["arm"];
+        assert_eq!(app.world().get::<RigidBody>(base), Some(&RigidBody::Fixed));
+        assert_eq!(app.world().get::<RigidBody>(arm), Some(&RigidBody::Dynamic));
+        assert!(app.world().get::<UrdfLinkVisuals>(arm).is_some());
+        assert_eq!(
+            app.world().get::<Name>(arm).map(|n| n.as_str()),
+            Some("arm")
+        );
+
+        // The arm swings around its joint, which stays attached to the base.
+        let base_pos = body_translation(app, base);
+        assert!((base_pos - Vect::new(1.0, 2.0, 3.0)).length() < 1.0e-5);
+        let arm_pos0 = body_translation(app, arm);
+        assert!((arm_pos0 - base_pos - Vect::new(0.0, 0.0, 0.1)).length() < 1.0e-4);
+        for _ in 0..30 {
+            app.update();
+        }
+        let arm_pos = body_translation(app, arm);
+        assert!((arm_pos - arm_pos0).length() < 1.0e-2);
+        let finger_pos = body_translation(app, robot.links_by_name["finger"]);
+        assert!(((finger_pos - arm_pos).length() - 0.5).abs() < 1.0e-2);
+        assert!(finger_pos.is_finite());
+    }
+
+    #[test]
+    fn spawn_with_impulse_joints() {
+        let (mut app, robot) = spawn(false);
+        for _ in 0..2 {
+            app.update();
+        }
+        for joint in &robot.joints {
+            assert!(app
+                .world()
+                .get::<RapierImpulseJointHandle>(*joint)
+                .is_some());
+            assert!(app.world().get::<MultibodyJoint>(*joint).is_none());
+        }
+        check_robot(&mut app, &robot);
+    }
+
+    #[test]
+    fn spawn_with_multibody_joints() {
+        let (mut app, robot) = spawn(true);
+        for _ in 0..2 {
+            app.update();
+        }
+        for joint in &robot.joints {
+            assert!(app
+                .world()
+                .get::<RapierMultibodyJointHandle>(*joint)
+                .is_some());
+        }
+        let shoulder = robot.joints_by_name["shoulder"];
+        let damping = app.world().get::<MultibodyJointDamping>(shoulder).unwrap();
+        assert_eq!(damping.0[JointAxis::AngX as usize], 0.3);
+        let friction = app.world().get::<MultibodyJointFriction>(shoulder).unwrap();
+        assert_eq!(friction.0[JointAxis::AngX as usize], 0.2);
+
+        let finger = robot.joints_by_name["finger_joint"];
+        let couplings = app.world().get::<MultibodyJointCouplings>(finger).unwrap();
+        assert_eq!(
+            couplings.0,
+            vec![MultibodyJointCoupling::new(
+                JointAxis::AngX,
+                shoulder,
+                JointAxis::AngX,
+                2.0,
+                0.1
+            )]
+        );
+        check_robot(&mut app, &robot);
+
+        // The mimic coupling holds.
+        let coord = |app: &App, e| app.world().get::<MultibodyJointState>(e).unwrap().coords[3];
+        let (q1, q2) = (coord(&app, shoulder), coord(&app, finger));
+        assert!(q1.abs() > 1.0e-3);
+        assert!((q2 - (2.0 * q1 + 0.1)).abs() < 1.0e-2);
+    }
+
+    #[test]
+    fn spawn_sample_robot() {
+        let path = concat!(env!("CARGO_MANIFEST_DIR"), "/assets/robots/arm.urdf");
+        let model = UrdfModel::from_file(path, UrdfLoaderOptions::default(), None).unwrap();
+        for multibody in [true, false] {
+            let mut app = test_app(RapierPhysicsPlugin::<NoUserData>::default());
+            app.update();
+            let robot = spawn_urdf_robot(
+                &mut app.world_mut().commands(),
+                &model,
+                &UrdfSpawnOptions {
+                    multibody,
+                    ..default()
+                },
+            );
+            app.world_mut().flush();
+            // The empty `world` and `tool_center_point` links are removed.
+            assert_eq!(robot.links.len(), 7);
+            assert_eq!(robot.joints.len(), 6);
+            assert!(!robot.links_by_name.contains_key("world"));
+            for _ in 0..30 {
+                app.update();
+            }
+            for link in &robot.links {
+                assert!(body_translation(&mut app, *link).is_finite());
+            }
+            let fingers = robot.joints_by_name["right_finger_joint"];
+            assert_eq!(
+                app.world()
+                    .get::<MultibodyJointCouplings>(fingers)
+                    .is_some(),
+                multibody
+            );
+        }
+    }
+
+    #[test]
+    fn despawning_the_root_removes_the_robot() {
+        let (mut app, robot) = spawn(true);
+        app.update();
+        app.world_mut().despawn(robot.root.unwrap());
+        app.update();
+        let bodies = app
+            .world_mut()
+            .query::<&RapierRigidBodySet>()
+            .single(app.world())
+            .unwrap();
+        assert_eq!(bodies.bodies.len(), 0);
+    }
+}
+
+#[cfg(feature = "mjcf")]
+mod mjcf {
+    use super::*;
+    use crate::loaders::mjcf::*;
+
+    const PENDULUM: &str = r#"
+<mujoco model="pendulum">
+  <option gravity="0 0 -9.81"/>
+  <worldbody>
+    <geom name="floor" type="plane" size="5 5 0.1"/>
+    <body name="pole" pos="0 0 1">
+      <joint name="hinge" type="hinge" axis="0 1 0" damping="0.5" armature="0.01"
+             frictionloss="0.1" stiffness="2"/>
+      <geom name="pole_geom" type="capsule" fromto="0 0 0 0.2 0 -0.5" size="0.05" mass="1"/>
+      <body name="tip" pos="0.2 0 -0.5">
+        <joint name="hinge2" type="hinge" axis="0 1 0"/>
+        <geom name="tip_geom" type="sphere" size="0.1" mass="0.5"/>
+      </body>
+    </body>
+    <body name="free_ball" pos="0 0 3">
+      <freejoint/>
+      <geom name="ball1" type="sphere" size="0.2" mass="1"/>
+    </body>
+    <body name="free_ball2" pos="0.1 0 3">
+      <freejoint/>
+      <geom name="ball2" type="sphere" size="0.2" mass="1"/>
+    </body>
+  </worldbody>
+  <contact>
+    <exclude body1="pole" body2="tip"/>
+    <exclude body1="free_ball" body2="free_ball2"/>
+  </contact>
+  <actuator>
+    <motor name="torque" joint="hinge" gear="1"/>
+  </actuator>
+</mujoco>
+"#;
+
+    fn spawn(multibody: bool) -> (App, SpawnedMjcfModel) {
+        let (robot, _) = MjcfRobot::from_str(PENDULUM, MjcfLoaderOptions::default(), ".").unwrap();
+        spawn_robot(&robot, multibody)
+    }
+
+    fn spawn_robot(robot: &MjcfRobot, multibody: bool) -> (App, SpawnedMjcfModel) {
+        let mut app = test_app((
+            RapierPhysicsPlugin::<MjcfPhysicsHooks>::default(),
+            MjcfPlugin::default(),
+        ));
+        app.update();
+        let model = spawn_mjcf_model(
+            &mut app.world_mut().commands(),
+            robot,
+            &MjcfSpawnOptions {
+                multibody,
+                ..default()
+            },
+        );
+        app.world_mut().flush();
+        // The model is Z-up.
+        let mut config = app
+            .world_mut()
+            .query::<&mut RapierConfiguration>()
+            .single_mut(app.world_mut())
+            .unwrap();
+        config.gravity = model.gravity;
+        app.update();
+        (app, model)
+    }
+
+    fn check_model(app: &mut App, model: &SpawnedMjcfModel) {
+        // The world body is spawned since the pole is attached to it.
+        let world = model.bodies[0].unwrap();
+        assert_eq!(app.world().get::<RigidBody>(world), Some(&RigidBody::Fixed));
+        let pole = model.bodies_by_name["pole"];
+        let tip = model.bodies_by_name["tip"];
+        assert!(app.world().get::<RapierRigidBodyHandle>(pole).is_some());
+        assert!(app
+            .world()
+            .get::<RapierColliderHandle>(model.colliders_by_name["tip_geom"])
+            .is_some());
+        assert_eq!(model.gravity, Vect::new(0.0, 0.0, -9.81));
+
+        // The contact rules are registered, with the hooks enabled on the involved colliders.
+        let ball1 = model.colliders_by_name["ball1"];
+        let ball2 = model.colliders_by_name["ball2"];
+        let filters = app.world().resource::<MjcfContactFilters>();
+        assert!(filters.excluded.contains(&(ball1, ball2)));
+        assert!(filters.excluded.contains(&(
+            model.colliders_by_name["tip_geom"],
+            model.colliders_by_name["pole_geom"]
+        )));
+        assert!(app
+            .world()
+            .get::<ActiveHooks>(ball1)
+            .unwrap()
+            .contains(ActiveHooks::FILTER_CONTACT_PAIRS));
+
+        let actuator = model.actuators_by_name["torque"];
+        assert_eq!(
+            app.world().get::<MjcfActuator>(actuator).unwrap().joint,
+            Some(model.joints_by_name["hinge"])
+        );
+
+        let tip0 = body_translation(app, tip);
+        let ball0 = body_translation(app, model.bodies_by_name["free_ball"]);
+        for _ in 0..30 {
+            app.update();
+        }
+        // The pendulum swings, and the excluded overlapping balls fall through each other.
+        assert!((body_translation(app, tip) - tip0).length() > 1.0e-3);
+        let ball = body_translation(app, model.bodies_by_name["free_ball"]);
+        let ball2_pos = body_translation(app, model.bodies_by_name["free_ball2"]);
+        assert!((ball.x - ball0.x).abs() < 1.0e-4);
+        assert!(ball.z < ball0.z - 0.5);
+        assert!((ball2_pos.x - 0.1).abs() < 1.0e-4);
+    }
+
+    #[test]
+    fn spawn_with_multibody_joints() {
+        let (mut app, model) = spawn(true);
+        let hinge = model.joints_by_name["hinge"];
+        assert!(app
+            .world()
+            .get::<RapierMultibodyJointHandle>(hinge)
+            .is_some());
+        assert_eq!(hinge, model.bodies_by_name["pole"]);
+
+        let axis = JointAxis::AngX as usize;
+        let world = app.world();
+        assert_eq!(
+            world.get::<MultibodyJointDamping>(hinge).unwrap().0[axis],
+            0.5
+        );
+        assert_eq!(
+            world.get::<MultibodyJointArmature>(hinge).unwrap().0[axis],
+            0.01
+        );
+        assert_eq!(
+            world.get::<MultibodyJointFriction>(hinge).unwrap().0[axis],
+            0.1
+        );
+        assert_eq!(
+            world.get::<MultibodyJointSprings>(hinge).unwrap().stiffness[axis],
+            2.0
+        );
+        check_model(&mut app, &model);
+
+        // Driving the actuator enables a force-based motor on the joint.
+        let actuator = model.actuators_by_name["torque"];
+        app.world_mut()
+            .get_mut::<MjcfActuator>(actuator)
+            .unwrap()
+            .ctrl = 3.0;
+        app.update();
+        let joint = app.world().get::<MultibodyJoint>(hinge).unwrap();
+        let motor = joint.data.as_ref().motor(JointAxis::AngX).unwrap();
+        assert_eq!(motor.max_force, 3.0);
+        assert_eq!(motor.model, MotorModel::ForceBased);
+    }
+
+    #[test]
+    fn spawn_sample_scene() {
+        for multibody in [true, false] {
+            let path = concat!(env!("CARGO_MANIFEST_DIR"), "/assets/robots/cart_pole.xml");
+            let (robot, _) = MjcfRobot::from_file(path, MjcfLoaderOptions::default()).unwrap();
+            let (mut app, model) = spawn_robot(&robot, multibody);
+            assert_eq!(model.actuators.len(), 2);
+            // Zero-length timesteps (e.g. the first frame with a variable timestep) are skipped, so
+            // the infinite motor forces of `rapier3d-mjcf` don't produce NaN impulse bounds.
+            app.insert_resource(TimestepMode::Fixed {
+                dt: 0.0,
+                substeps: 1,
+            });
+            app.update();
+            app.insert_resource(TimestepMode::Fixed {
+                dt: 1.0 / 60.0,
+                substeps: 1,
+            });
+            for actuator in &model.actuators {
+                let mut actuator = app.world_mut().get_mut::<MjcfActuator>(*actuator).unwrap();
+                assert!(actuator.joint.is_some());
+                actuator.ctrl = 0.5;
+            }
+            for _ in 0..60 {
+                app.update();
+            }
+            for body in model.bodies.iter().flatten() {
+                assert!(body_translation(&mut app, *body).is_finite());
+            }
+        }
+    }
+
+    #[test]
+    fn spawn_with_impulse_joints() {
+        let (mut app, model) = spawn(false);
+        let hinge = model.joints_by_name["hinge"];
+        assert!(app.world().get::<RapierImpulseJointHandle>(hinge).is_some());
+        assert!(app.world().get::<MultibodyJointDamping>(hinge).is_none());
+        check_model(&mut app, &model);
+    }
+}
+
+#[cfg(feature = "meshloader")]
+mod meshloader {
+    use super::*;
+    use crate::loaders::meshloader::*;
+
+    const CUBE_OBJ: &str = "
+v -1 -1 -1
+v 1 -1 -1
+v 1 1 -1
+v -1 1 -1
+v -1 -1 1
+v 1 -1 1
+v 1 1 1
+v -1 1 1
+f 1 3 2
+f 1 4 3
+f 5 6 7
+f 5 7 8
+f 1 2 6
+f 1 6 5
+f 2 3 7
+f 2 7 6
+f 3 4 8
+f 3 8 7
+f 4 1 5
+f 4 5 8
+";
+
+    const TRIANGLE_STL: &str = "solid tri
+facet normal 0 0 1
+  outer loop
+    vertex 0 0 0
+    vertex 1 0 0
+    vertex 0 1 0
+  endloop
+endfacet
+endsolid tri
+";
+
+    fn write_temp(name: &str, content: &str) -> std::path::PathBuf {
+        let dir =
+            std::env::temp_dir().join(format!("bevy_rapier_meshloader_{}", std::process::id()));
+        std::fs::create_dir_all(&dir).unwrap();
+        let path = dir.join(name);
+        std::fs::write(&path, content).unwrap();
+        path
+    }
+
+    #[test]
+    fn collider_from_obj_file() {
+        let path = write_temp("cube.obj", CUBE_OBJ);
+        let hull =
+            Collider::from_mesh_file(&path, &MeshConverter::ConvexHull, Vect::splat(0.5)).unwrap();
+        let aabb = hull.raw.compute_local_aabb();
+        assert!((aabb.maxs - Vect::splat(0.5)).length() < 1.0e-5);
+        assert!(hull.as_convex_polyhedron().is_some());
+
+        let colliders =
+            load_mesh_file_colliders(&path, &MeshConverter::TriMesh, Vect::new(1.0, 2.0, 3.0))
+                .unwrap();
+        assert_eq!(colliders.len(), 1);
+        let trimesh = colliders[0].collider.as_trimesh().unwrap();
+        assert_eq!(trimesh.raw.indices().len(), 12);
+        assert_eq!(colliders[0].transform, Transform::IDENTITY);
+        // The OBJ loader duplicates the vertices of each face.
+        assert_eq!(colliders[0].raw_mesh.vertices.len(), 36);
+
+        // Offset shapes are kept as compound shapes.
+        let obb = Collider::from_mesh_file(&path, &MeshConverter::Obb, Vect::ONE).unwrap();
+        assert!(obb.as_compound().is_some());
+    }
+
+    #[test]
+    fn collider_from_stl_file() {
+        let path = write_temp("triangle.stl", TRIANGLE_STL);
+        let collider = Collider::from_mesh_file(&path, &MeshConverter::TriMesh, Vect::ONE).unwrap();
+        assert_eq!(collider.as_trimesh().unwrap().raw.indices().len(), 1);
+
+        assert!(Collider::from_mesh_file(
+            path.with_extension("missing.stl"),
+            &MeshConverter::TriMesh,
+            Vect::ONE
+        )
+        .is_err());
+    }
+
+    #[cfg(feature = "to-bevy-mesh")]
+    #[test]
+    fn raw_mesh_to_bevy() {
+        let path = write_temp("cube_mesh.obj", CUBE_OBJ);
+        let colliders =
+            load_mesh_file_colliders(&path, &MeshConverter::TriMesh, Vect::ONE).unwrap();
+        let mesh = raw_mesh_to_bevy_mesh(&colliders[0].raw_mesh, Vect::splat(2.0));
+        assert_eq!(mesh.count_vertices(), 36);
+        assert!(mesh.attribute(Mesh::ATTRIBUTE_NORMAL).is_some());
+    }
+}
diff --git a/bindings/bevy_rapier/src/loaders/urdf.rs b/bindings/bevy_rapier/src/loaders/urdf.rs
new file mode 100644
index 000000000..37886a5bf
--- /dev/null
+++ b/bindings/bevy_rapier/src/loaders/urdf.rs
@@ -0,0 +1,354 @@
+//! Spawning robots described by URDF files as `bevy_rapier` entities.
+//!
+//! Load a robot with [`UrdfModel::from_file`] or [`UrdfModel::from_str`], then spawn it with
+//! [`spawn_urdf_robot`]:
+//!
+//! ```no_run
+//! # use bevy::prelude::*;
+//! use bevy_rapier3d::loaders::urdf::{spawn_urdf_robot, UrdfLoaderOptions, UrdfModel, UrdfSpawnOptions};
+//!
+//! fn setup(mut commands: Commands) {
+//!     let model = UrdfModel::from_file("robot.urdf", UrdfLoaderOptions::default(), None).unwrap();
+//!     let robot = spawn_urdf_robot(&mut commands, &model, &UrdfSpawnOptions::default());
+//!     println!("Spawned {} links.", robot.links.len());
+//! }
+//! ```
+//!
+//! Each URDF link becomes a rigid-body entity (a child of [`SpawnedUrdfRobot::root`]), each of its
+//! shapes a collider entity child of the link, and each URDF joint an [`ImpulseJoint`] or a
+//! [`MultibodyJoint`] on the entity of its child link.
+//!
+//! On top of what `rapier3d-urdf` converts, the joint `<dynamics>` (damping and friction) and
+//! `<mimic>` elements are applied to multibody joints (as [`MultibodyJointDamping`],
+//! [`MultibodyJointFriction`] and [`MultibodyJointCouplings`]). They are ignored by impulse
+//! joints, as are the joint effort and velocity limits and the safety controllers.
+
+use crate::dynamics::{
+    GenericJoint, ImpulseJoint, KinematicMultibodyJoint, MultibodyJoint, MultibodyJointCoupling,
+    MultibodyJointCouplings, MultibodyJointDamping, MultibodyJointFriction,
+    MultibodySelfContactsDisabled,
+};
+use crate::loaders::common::{
+    active_hooks, insert_collider, insert_context_link, insert_rigid_body, joint_axis, LoaderError,
+};
+use crate::math::Real;
+use crate::utils::iso_to_transform;
+use bevy::platform::collections::HashMap;
+use bevy::prelude::*;
+use rapier::dynamics::{JointAxesMask, JointAxis};
+use rapier::geometry::SharedShape;
+use rapier::math::SPATIAL_DIM;
+use std::path::Path;
+
+pub use rapier3d_urdf::{
+    self, urdf_rs, UrdfCollider, UrdfJoint, UrdfLink, UrdfLoaderOptions, UrdfMultibodyOptions,
+    UrdfRobot, UrdfVisual,
+};
+
+/// A robot loaded from an URDF file, ready to be spawned with [`spawn_urdf_robot`].
+///
+/// This pairs the Rapier objects built by `rapier3d-urdf` with the original URDF description.
+/// Their links and joints can differ since empty links are removed when
+/// [`UrdfLoaderOptions::squeeze_empty_fixed_links`] is enabled: see [`UrdfLink::urdf_link_index`]
+/// and [`UrdfJoint::urdf_joint_index`] to match them.
+#[derive(Clone, Debug)]
+pub struct UrdfModel {
+    /// The rigid-bodies, colliders and joints built from the URDF file.
+    pub robot: UrdfRobot,
+    /// The original URDF description.
+    pub urdf: urdf_rs::Robot,
+}
+
+impl UrdfModel {
+    /// Loads a robot from an URDF file.
+    ///
+    /// Meshes referenced by the file are looked for in `mesh_dir`, or in the directory
+    /// containing the URDF file if `mesh_dir` is `None`.
+    pub fn from_file(
+        path: impl AsRef<Path>,
+        options: UrdfLoaderOptions,
+        mesh_dir: Option<&Path>,
+    ) -> Result<Self, LoaderError> {
+        let path = path.as_ref().canonicalize()?;
+        let mesh_dir = mesh_dir
+            .or_else(|| path.parent())
+            .unwrap_or_else(|| Path::new("./"));
+        let (robot, urdf) = UrdfRobot::from_file(&path, options, Some(mesh_dir))?;
+        Ok(Self { robot, urdf })
+    }
+
+    /// Loads a robot from the content of an URDF file.
+    ///
+    /// Meshes referenced by the file are looked for in `mesh_dir`.
+    pub fn from_str(
+        urdf: &str,
+        options: UrdfLoaderOptions,
+        mesh_dir: &Path,
+    ) -> Result<Self, LoaderError> {
+        let (robot, urdf) = UrdfRobot::from_str(urdf, options, mesh_dir)?;
+        Ok(Self { robot, urdf })
+    }
+
+    /// Builds a robot from an already parsed URDF description.
+    ///
+    /// Meshes referenced by the description are looked for in `mesh_dir`.
+    pub fn from_urdf(urdf: urdf_rs::Robot, options: UrdfLoaderOptions, mesh_dir: &Path) -> Self {
+        let robot = UrdfRobot::from_robot(&urdf, options, mesh_dir);
+        Self { robot, urdf }
+    }
+
+    /// The URDF description of the `i`-th link of [`Self::robot`].
+    pub fn urdf_link(&self, i: usize) -> Option<&urdf_rs::Link> {
+        self.urdf
+            .links
+            .get(self.robot.links.get(i)?.urdf_link_index)
+    }
+
+    /// The URDF description of the `i`-th joint of [`Self::robot`], i.e., the URDF joint attached
+    /// to its child link (see [`UrdfJoint::urdf_joint_index`]).
+    pub fn urdf_joint(&self, i: usize) -> Option<&urdf_rs::Joint> {
+        self.urdf
+            .joints
+            .get(self.robot.joints.get(i)?.urdf_joint_index)
+    }
+
+    /// The URDF joint the `i`-th joint of [`Self::robot`] inherited its type, dynamics and mimic
+    /// from (see [`UrdfJoint::source_urdf_joint_index`]).
+    ///
+    /// This differs from [`Self::urdf_joint`] when joints leading to removed empty links were
+    /// merged into this one.
+    pub fn source_urdf_joint(&self, i: usize) -> Option<&urdf_rs::Joint> {
+        let index = self.robot.joints.get(i)?.source_urdf_joint_index();
+        self.urdf.joints.get(index)
+    }
+}
+
+/// The first axis left free by `locked_axes`, if any.
+fn first_free_axis(locked_axes: JointAxesMask) -> Option<JointAxis> {
+    (0..SPATIAL_DIM)
+        .find(|axis| locked_axes.bits() & (1 << axis) == 0)
+        .map(joint_axis)
+}
+
+/// Options controlling how an [`UrdfModel`] is spawned by [`spawn_urdf_robot`].
+#[derive(Clone, Debug)]
+pub struct UrdfSpawnOptions {
+    /// If `true`, the joints are spawned as [`MultibodyJoint`]s (reduced coordinates). Otherwise,
+    /// they are spawned as [`ImpulseJoint`]s (default: `false`).
+    pub multibody: bool,
+    /// Options applied to the multibody joints, if [`Self::multibody`] is `true`.
+    pub multibody_options: UrdfMultibodyOptions,
+    /// The transform of the root entity of the robot, which all its links are children of
+    /// (default: identity).
+    pub root_transform: Transform,
+    /// The physics context the robot is added to (default: `None`, the default context).
+    pub context: Option<Entity>,
+}
+
+impl Default for UrdfSpawnOptions {
+    fn default() -> Self {
+        Self {
+            multibody: false,
+            multibody_options: UrdfMultibodyOptions::empty(),
+            root_transform: Transform::IDENTITY,
+            context: None,
+        }
+    }
+}
+
+/// The entities spawned by [`spawn_urdf_robot`].
+///
+/// The vectors are indexed like the links and joints of [`UrdfModel::robot`].
+#[derive(Clone, Debug, Default)]
+pub struct SpawnedUrdfRobot {
+    /// The entity every link is a child of. Despawning it despawns the whole robot.
+    pub root: Option<Entity>,
+    /// The rigid-body entity of each link.
+    pub links: Vec<Entity>,
+    /// The collider entities of each link (children of the link entity).
+    pub colliders: Vec<Vec<Entity>>,
+    /// The entity containing each joint (the entity of its child link).
+    pub joints: Vec<Entity>,
+    /// The link entities, by URDF link name.
+    pub links_by_name: HashMap<String, Entity>,
+    /// The joint entities, by URDF joint name.
+    ///
+    /// This includes the URDF joints merged into another joint when empty links were removed
+    /// (see [`UrdfJoint::merged_urdf_joint_indices`]).
+    pub joints_by_name: HashMap<String, Entity>,
+}
+
+/// The index of the URDF link a rigid-body entity was spawned from by [`spawn_urdf_robot`].
+#[derive(Copy, Clone, Debug, PartialEq, Eq, Component)]
+pub struct UrdfLinkId(pub usize);
+
+/// The visual elements of the URDF link a rigid-body entity was spawned from.
+///
+/// This is added by [`spawn_urdf_robot`] to the link entities with visual elements, so that
+/// rendering meshes can be attached to them. The visual poses are relative to the link entity.
+#[derive(Clone, Debug, Component)]
+pub struct UrdfLinkVisuals(pub Vec<urdf_rs::Visual>);
+
+/// The original mesh of a collider which was approximated by a simpler shape.
+///
+/// This is added by [`spawn_urdf_robot`] to the collider entities built from a mesh when a
+/// [`UrdfLoaderOptions::mesh_converter`] other than a triangle mesh is used.
+#[derive(Clone, Debug, Component)]
+pub struct UrdfColliderVisual {
+    /// The triangle mesh of the original shape.
+    pub shape: SharedShape,
+    /// The pose of the triangle mesh relative to the collider entity.
+    pub transform: Transform,
+}
+
+/// Spawns the links, colliders and joints of an URDF robot.
+///
+/// See the [module documentation](self) for details.
+pub fn spawn_urdf_robot(
+    commands: &mut Commands,
+    model: &UrdfModel,
+    options: &UrdfSpawnOptions,
+) -> SpawnedUrdfRobot {
+    let robot_name = model.urdf.name.clone();
+    let mut root = commands.spawn((options.root_transform, Name::new(robot_name)));
+    insert_context_link(&mut root, options.context);
+    let root = root.id();
+
+    let mut result = SpawnedUrdfRobot {
+        root: Some(root),
+        ..default()
+    };
+
+    for (i, link) in model.robot.links.iter().enumerate() {
+        let urdf_link = model.urdf_link(i);
+        let name = urdf_link.map(|l| l.name.clone()).unwrap_or_default();
+        let mut entity = commands.spawn((
+            ChildOf(root),
+            iso_to_transform(link.body.position()),
+            Name::new(name.clone()),
+            UrdfLinkId(link.urdf_link_index),
+        ));
+        insert_rigid_body(&mut entity, &link.body);
+        insert_context_link(&mut entity, options.context);
+        if let Some(visuals) = urdf_link.filter(|l| !l.visual.is_empty()) {
+            entity.insert(UrdfLinkVisuals(visuals.visual.clone()));
+        }
+        let link_entity = entity.id();
+
+        let colliders = link
+            .colliders
+            .iter()
+            .enumerate()
+            .map(|(k, co)| {
+                let mut entity = commands.spawn((
+                    ChildOf(link_entity),
+                    Name::new(format!("{name} collider {k}")),
+                ));
+                insert_collider(&mut entity, &co.collider, active_hooks(&co.collider));
+                insert_context_link(&mut entity, options.context);
+                if let Some(visual) = &co.visual {
+                    entity.insert(UrdfColliderVisual {
+                        shape: visual.shape.clone(),
+                        transform: iso_to_transform(&visual.local_pose),
+                    });
+                }
+                entity.id()
+            })
+            .collect();
+
+        result.links.push(link_entity);
+        result.colliders.push(colliders);
+        result.links_by_name.insert(name, link_entity);
+    }
+
+    let multibody_options = options.multibody_options;
+    for (i, joint) in model.robot.joints.iter().enumerate() {
+        let parent = result.links[joint.link1];
+        let entity = result.links[joint.link2];
+        let data = GenericJoint { raw: joint.joint };
+        let mut entity_commands = commands.entity(entity);
+        let source = model.source_urdf_joint(i);
+
+        if options.multibody {
+            entity_commands.insert(MultibodyJoint::new(parent, data));
+            if multibody_options.contains(UrdfMultibodyOptions::JOINTS_ARE_KINEMATIC) {
+                entity_commands.insert(KinematicMultibodyJoint);
+            }
+            if multibody_options.contains(UrdfMultibodyOptions::DISABLE_SELF_CONTACTS) {
+                entity_commands.insert(MultibodySelfContactsDisabled);
+            }
+            if let (Some(dynamics), Some(axis)) = (
+                source.and_then(|j| j.dynamics.as_ref()),
+                first_free_axis(joint.joint.locked_axes),
+            ) {
+                entity_commands.insert((
+                    MultibodyJointDamping::default().with(axis, dynamics.damping as Real),
+                    MultibodyJointFriction::default().with(axis, dynamics.friction as Real),
+                ));
+            }
+        } else {
+            entity_commands.insert(ImpulseJoint::new(parent, data));
+        }
+
+        result.joints.push(entity);
+        let merged = joint.merged_urdf_joint_indices.iter();
+        for k in std::iter::once(&joint.urdf_joint_index).chain(merged) {
+            if let Some(urdf_joint) = model.urdf.joints.get(*k) {
+                result
+                    .joints_by_name
+                    .insert(urdf_joint.name.clone(), entity);
+            }
+        }
+    }
+
+    // Mimic joints are coupled to the joint they follow once all the joint entities are known.
+    if options.multibody {
+        for (i, joint) in model.robot.joints.iter().enumerate() {
+            let Some(mimic) = model.source_urdf_joint(i).and_then(|j| j.mimic.as_ref()) else {
+                continue;
+            };
+            let Some(source) = result.joints_by_name.get(&mimic.joint).copied() else {
+                log::warn!("URDF mimic joint `{}` not found.", mimic.joint);
+                continue;
+            };
+            let source_axis = result
+                .joints
+                .iter()
+                .position(|e| *e == source)
+                .and_then(|k| first_free_axis(model.robot.joints[k].joint.locked_axes));
+            let (Some(axis), Some(source_axis)) =
+                (first_free_axis(joint.joint.locked_axes), source_axis)
+            else {
+                continue;
+            };
+            commands
+                .entity(result.joints[i])
+                .insert(MultibodyJointCouplings(vec![MultibodyJointCoupling::new(
+                    axis,
+                    source,
+                    source_axis,
+                    mimic.multiplier.unwrap_or(1.0) as Real,
+                    mimic.offset.unwrap_or(0.0) as Real,
+                )]));
+        }
+    }
+
+    result
+}
+
+/// Converts a pose read from an URDF file into a Bevy transform.
+///
+/// This can be used to place the visual elements of [`UrdfLinkVisuals`] relative to their link.
+/// Note that the [`UrdfLoaderOptions::scale`] isn't applied to these poses.
+pub fn urdf_pose_to_transform(pose: &urdf_rs::Pose) -> Transform {
+    Transform {
+        translation: Vec3::new(pose.xyz[0] as f32, pose.xyz[1] as f32, pose.xyz[2] as f32),
+        rotation: Quat::from_euler(
+            EulerRot::XYZ,
+            pose.rpy[0] as f32,
+            pose.rpy[1] as f32,
+            pose.rpy[2] as f32,
+        ),
+        ..default()
+    }
+}
diff --git a/bindings/bevy_rapier/src/picking_backend/mod.rs b/bindings/bevy_rapier/src/picking_backend/mod.rs
new file mode 100644
index 000000000..e36daa636
--- /dev/null
+++ b/bindings/bevy_rapier/src/picking_backend/mod.rs
@@ -0,0 +1,178 @@
+//! A picking backend for Rapier physics entities.
+//!
+//! By default, all colliders are pickable. Picking can be disabled for individual entities
+//! by adding [`Pickable::IGNORE`](bevy::picking::Pickable::IGNORE).
+//!
+//! To make rapier picking entirely opt-in, set [`RapierPickingSettings::require_markers`]
+//! to `true` and add a [`RapierPickable`] component to the desired camera and target entities.
+
+use bevy::app::prelude::*;
+use bevy::camera::visibility::{InheritedVisibility, RenderLayers};
+use bevy::ecs::prelude::*;
+use bevy::picking::backend::ray::RayMap;
+use bevy::picking::backend::HitData;
+use bevy::picking::backend::PointerHits;
+use bevy::picking::{PickingPlugin, PickingSystems};
+use bevy::prelude::*;
+
+/// How a ray cast should handle [`Visibility`].
+#[derive(Clone, Copy, Reflect)]
+pub enum RapierCastVisibility {
+    /// Completely ignore visibility checks. Hidden items can still be ray casted against.
+    Any,
+    /// Only cast rays against entities that are visible in the hierarchy. See [`Visibility`].
+    Visible,
+}
+/// Runtime settings for the [`RapierPickingPlugin`].
+#[derive(Resource, Reflect)]
+#[reflect(Resource, Default)]
+pub struct RapierPickingSettings {
+    /// When set to `true` ray casting will only happen between cameras and entities marked with
+    /// [`RapierPickable`]. `false` by default.
+    ///
+    /// This setting is provided to give you fine-grained control over which cameras and entities
+    /// should be used by the rapier picking backend at runtime.
+    pub require_markers: bool,
+
+    /// Determines how rapier picking should consider [`Visibility`]. When set to [`RapierCastVisibility::Any`],
+    /// ray casts can be performed against both visible and hidden entities.
+    ///
+    /// Defaults to [`RapierCastVisibility::Visible`], only performing picking against entities with [`InheritedVisibility`] set to `true`.
+    pub ray_cast_visibility: RapierCastVisibility,
+}
+
+impl Default for RapierPickingSettings {
+    fn default() -> Self {
+        Self {
+            require_markers: false,
+            ray_cast_visibility: RapierCastVisibility::Visible,
+        }
+    }
+}
+
+/// An optional component that marks cameras and target entities that should be used in the [`RapierPickingPlugin`].
+///
+/// Only needed if [`RapierPickingSettings::require_markers`] is set to `true`, and ignored otherwise.
+#[derive(Debug, Clone, Default, Component, Reflect)]
+#[reflect(Component, Default)]
+pub struct RapierPickable;
+
+/// Adds the rapier picking backend to your app.
+#[derive(Clone, Default)]
+pub struct RapierPickingPlugin;
+
+impl Plugin for RapierPickingPlugin {
+    fn build(&self, app: &mut App) {
+        app.register_type::<(RapierPickable, RapierPickingSettings)>()
+            .init_resource::<RapierPickingSettings>()
+            .add_systems(PreUpdate, update_hits.in_set(PickingSystems::Backend));
+        if !app.is_plugin_added::<PickingPlugin>() {
+            app.add_plugins(PickingPlugin);
+        }
+    }
+}
+
+/// System which casts rays into the scene using [`RapierPickingSettings`] and sends [`PointerHits`] events.
+#[allow(clippy::too_many_arguments)]
+pub fn update_hits(
+    backend_settings: Res<RapierPickingSettings>,
+    ray_map: Res<RayMap>,
+    picking_cameras: Query<(&Camera, Option<&RapierPickable>, Option<&RenderLayers>)>,
+    marked_targets: Query<&RapierPickable>,
+    culling_query: Query<(Option<&InheritedVisibility>, Option<&ViewVisibility>)>,
+    layers: Query<&RenderLayers>,
+    rapier_context: Query<(
+        &crate::prelude::RapierContextColliders,
+        &crate::prelude::RapierRigidBodySet,
+        &crate::prelude::RapierContextSimulation,
+    )>,
+    mut output: MessageWriter<PointerHits>,
+) {
+    for (&ray_id, &ray) in ray_map.map.iter() {
+        let Ok((camera, cam_pickable, cam_layers)) = picking_cameras.get(ray_id.camera) else {
+            continue;
+        };
+        if backend_settings.require_markers && cam_pickable.is_none() {
+            continue;
+        }
+        let order = camera.order as f32;
+        for (colliders, bodies, simulation) in rapier_context.iter() {
+            let predicate = |entity, _: &rapier::geometry::Collider| {
+                let marker_requirement =
+                    !backend_settings.require_markers || marked_targets.get(entity).is_ok();
+                if !marker_requirement {
+                    return false;
+                }
+
+                let visibility_requirement = match backend_settings.ray_cast_visibility {
+                    RapierCastVisibility::Any => true,
+                    RapierCastVisibility::Visible => {
+                        let is_visible = culling_query
+                            .get(entity)
+                            .map(|(inherited_visibility, _)| {
+                                inherited_visibility.map(|v| v.get()).unwrap_or(false)
+                            })
+                            .unwrap_or(false);
+                        is_visible
+                    }
+                };
+                if !visibility_requirement {
+                    return false;
+                }
+                // Other entities missing render layers are on the default layer 0
+                let entity_layers = layers.get(entity).to_owned().unwrap_or_default();
+                let cam_layers = cam_layers.to_owned().unwrap_or_default();
+                let render_layers_match = cam_layers.intersects(entity_layers);
+                if !render_layers_match {
+                    return false;
+                }
+
+                true
+            };
+            let filter = crate::prelude::QueryFilter::default().predicate(&predicate);
+            let mut picks = Vec::new();
+            crate::prelude::RapierQueryPipeline::new_scoped(
+                &simulation.broad_phase,
+                colliders,
+                bodies,
+                &filter,
+                simulation.query_dispatcher(),
+                |query_pipeline| {
+                    #[cfg(feature = "dim2")]
+                    for (entity, _) in query_pipeline
+                        .intersect_point(bevy::math::Vec2::new(ray.origin.x, ray.origin.y))
+                    {
+                        let hit_data = HitData {
+                            camera: ray_id.camera,
+                            position: Some(bevy::math::Vec3::new(ray.origin.x, ray.origin.y, 0.0)),
+                            normal: None,
+                            depth: 0.0,
+                            extra: None,
+                        };
+                        picks.push((entity, hit_data));
+                    }
+                    #[cfg(feature = "dim3")]
+                    for (entity, _, intersection) in query_pipeline.intersect_ray(
+                        ray.origin,
+                        ray.direction.into(),
+                        f32::MAX,
+                        true,
+                    ) {
+                        let hit_data = HitData {
+                            camera: ray_id.camera,
+                            position: Some(intersection.point),
+                            normal: Some(intersection.normal),
+                            depth: intersection.time_of_impact,
+                            extra: None,
+                        };
+                        picks.push((entity, hit_data));
+                    }
+                },
+            );
+
+            if !picks.is_empty() {
+                output.write(PointerHits::new(ray_id.pointer, picks, order));
+            }
+        }
+    }
+}
diff --git a/bindings/bevy_rapier/src/pipeline/events.rs b/bindings/bevy_rapier/src/pipeline/events.rs
new file mode 100644
index 000000000..0fc6569d2
--- /dev/null
+++ b/bindings/bevy_rapier/src/pipeline/events.rs
@@ -0,0 +1,696 @@
+use crate::math::{Real, Vect};
+use bevy::ecs::message::Message;
+use bevy::prelude::Entity;
+use rapier::dynamics::{RigidBodySet, SoftBodySet, SoftBodyTearEvent as RapierSoftBodyTearEvent};
+use rapier::geometry::{
+    ColliderHandle, ColliderSet, CollisionEvent as RapierCollisionEvent, CollisionEventFlags,
+    ContactForceEvent as RapierContactForceEvent, ContactPair,
+};
+use rapier::pipeline::EventHandler;
+use std::collections::HashMap;
+use std::sync::RwLock;
+
+#[cfg(doc)]
+use crate::prelude::{
+    ActiveEvents, ContactForceEventThreshold, RapierContext, RapierContextMut,
+    RapierContextSimulation, SoftBodyAttachments, SoftBodyExternalForce, SoftBodyExternalImpulse,
+    SoftBodyKinematicTargets, SoftBodyPinnedParticles,
+};
+
+/// Events occurring when two colliders start or stop colliding
+///
+/// This will only get triggered if the entity has the
+/// [`ActiveEvents::COLLISION_EVENTS`] flag enabled.
+///
+/// This event only identifies the colliders involved. The detailed contact geometry
+/// (manifolds, contact points, normals, impulses) of a non-sensor pair can be read from the
+/// narrow-phase with [`RapierContext::contact_pair`] (or
+/// [`RapierContextSimulation::contact_pair`]) while the pair still exists, i.e., for
+/// [`CollisionEvent::Started`], and for [`CollisionEvent::Stopped`] unless one of the colliders
+/// was removed. For sensors, use [`RapierContext::intersection_pair`] instead. To access the raw
+/// Rapier contact pair at the exact time the event is emitted, install a custom
+/// [`EventHandler`] with [`RapierContextSimulation::set_event_handler`].
+#[derive(Message, Copy, Clone, Debug, PartialEq, Eq)]
+pub enum CollisionEvent {
+    /// Event occurring when two colliders start colliding
+    Started(Entity, Entity, CollisionEventFlags),
+    /// Event occurring when two colliders stop colliding
+    Stopped(Entity, Entity, CollisionEventFlags),
+}
+
+/// Event emitted after a simulation step during which Rapier detected non-finite (NaN or
+/// infinite) state and neutralized it.
+///
+/// Each reported rigid-body was rolled back to its last valid pose (when known), had its
+/// velocities and forces zeroed, and was disabled inside of Rapier; each reported collider was
+/// disabled inside of Rapier; each reported soft body was disabled and had its velocities zeroed
+/// (its non-finite particle positions are left as is). The plugin mirrors this by inserting
+/// [`RigidBodyDisabled`], [`ColliderDisabled`] or [`SoftBodyDisabled`] on the quarantined
+/// entities. Once the offending state is fixed (e.g. by writing a finite [`Velocity`],
+/// [`Transform`] or [`Collider`], or by moving the particles with
+/// [`RapierSoftBody::set_particle_position`]), remove that component to re-enable the entity. A
+/// warning is also logged for each event.
+///
+/// [`RigidBodyDisabled`]: crate::dynamics::RigidBodyDisabled
+/// [`ColliderDisabled`]: crate::geometry::ColliderDisabled
+/// [`SoftBodyDisabled`]: crate::dynamics::SoftBodyDisabled
+/// [`Velocity`]: crate::dynamics::Velocity
+/// [`Collider`]: crate::geometry::Collider
+/// [`Transform`]: bevy::prelude::Transform
+/// [`RapierSoftBody::set_particle_position`]: crate::dynamics::RapierSoftBody::set_particle_position
+#[derive(Message, Clone, Debug, PartialEq, Eq)]
+pub struct PhysicsQuarantineEvent {
+    /// The entity of the Rapier context in which the non-finite state was detected.
+    pub context: Entity,
+    /// The rigid-body entities quarantined during the step.
+    pub bodies: Vec<Entity>,
+    /// The collider entities quarantined during the step (because their own geometry or
+    /// position became non-finite).
+    pub colliders: Vec<Entity>,
+    /// The soft-body entities quarantined during the step (because a particle's position or
+    /// velocity became non-finite).
+    pub soft_bodies: Vec<Entity>,
+}
+
+/// Event occurring when the sum of the magnitudes of the contact forces
+/// between two colliders exceed a threshold ([`ContactForceEventThreshold`]).
+///
+/// This will only get triggered if the entity has the
+/// [`ActiveEvents::CONTACT_FORCE_EVENTS`] flag enabled.
+#[derive(Message, Copy, Clone, Debug, PartialEq)]
+pub struct ContactForceEvent {
+    /// The first collider involved in the contact.
+    pub collider1: Entity,
+    /// The second collider involved in the contact.
+    pub collider2: Entity,
+    /// The sum of all the forces between the two colliders.
+    pub total_force: Vect,
+    /// The sum of the magnitudes of each force between the two colliders.
+    ///
+    /// Note that this is **not** the same as the magnitude of `self.total_force`.
+    /// Here we are summing the magnitude of all the forces, instead of taking
+    /// the magnitude of their sum.
+    pub total_force_magnitude: Real,
+    /// The world-space (unit) direction of the force with strongest magnitude.
+    pub max_force_direction: Vect,
+    /// The magnitude of the largest force at a contact point of this contact pair.
+    pub max_force_magnitude: Real,
+    /// Is this the first step the total force of this pair exceeded its threshold?
+    ///
+    /// This is `true` on the step the force crosses the [`ContactForceEventThreshold`]
+    /// from below (or from not touching), and `false` while it stays above it on subsequent
+    /// steps. It becomes `true` again after the force drops below the threshold or the
+    /// colliders separate.
+    pub started: bool,
+}
+
+/// Message sent after a soft body tore (an element loaded past its tear threshold, or a tear or
+/// cut requested through [`RapierContextMut::tear_soft_body`] or
+/// [`RapierContextMut::cut_soft_body`]).
+///
+/// When a tear splits the soft body into disconnected pieces, the largest piece keeps the torn
+/// soft body and its entity; each other piece becomes a new soft body for which the plugin spawns
+/// a new entity (or uses the one already returned by the manual tear, see
+/// [`SoftBodyTearResult`]). That entity is a clone of the torn soft body's entity (its material,
+/// mesh synchronization, render components, user components...), except for the components tied
+/// to the torn body's particle indices ([`SoftBodyPinnedParticles`], [`SoftBodyKinematicTargets`],
+/// [`SoftBodyAttachments`], [`SoftBodyExternalForce`], [`SoftBodyExternalImpulse`]), which are
+/// remapped to the particles of each piece, and its mesh (a new one is generated if
+/// [`SoftBodyMeshSync`] is present).
+///
+/// [`SoftBodyMeshSync`]: crate::dynamics::SoftBodyMeshSync
+#[derive(Message, Clone, Debug)]
+pub struct SoftBodyTearEvent {
+    /// The entity of the Rapier context the soft body belongs to.
+    pub context: Entity,
+    /// The entity of the soft body that tore.
+    pub soft_body: Entity,
+    /// The soft bodies the torn body came apart into (empty if nothing was split off).
+    ///
+    /// The first piece is the torn soft body itself (it keeps [`Self::soft_body`] as entity), the
+    /// others are the entities spawned for the new soft bodies. The particle indices follow those
+    /// of [`Self::raw`].
+    pub pieces: Vec<SoftBodyTearPiece>,
+    /// The pieces of every soft-body cluster the tear split (see [`SoftBodyClusterSplit`]).
+    pub cluster_splits: Vec<SoftBodyClusterSplit>,
+    /// The impulse joints moved from a cluster proxy to another by a cluster split.
+    pub moved_joints: Vec<SoftBodyJointMove>,
+    /// The raw event from Rapier, with every detail of the topology change in terms of Rapier
+    /// handles and particle indices.
+    pub raw: RapierSoftBodyTearEvent,
+}
+
+/// The result of a tear or cut requested through [`RapierContextMut::tear_soft_body`] or
+/// [`RapierContextMut::cut_soft_body`].
+///
+/// The entities of the pieces are known right away: the soft bodies of the pieces are mapped to
+/// them immediately (so the helpers of [`RapierRigidBodySet`] find them), and the entities are
+/// spawned by the given `Commands`. They receive their components (cloned from the torn entity,
+/// see [`SoftBodyTearEvent`]) during the next [`PhysicsSet::Writeback`], when the
+/// [`SoftBodyTearEvent`] message of this tear is sent. The entities of the clusters split by the
+/// tear are only spawned then (see [`SoftBodyTearEvent::cluster_splits`]).
+///
+/// [`RapierRigidBodySet`]: crate::plugin::context::RapierRigidBodySet
+/// [`PhysicsSet::Writeback`]: crate::plugin::PhysicsSet::Writeback
+#[derive(Clone, Debug)]
+pub struct SoftBodyTearResult {
+    /// The entities of the soft bodies the torn body came apart into, in the order of the pieces
+    /// of [`Self::raw`] (empty if nothing was split off). The first one is the torn soft body's
+    /// entity.
+    pub pieces: Vec<Entity>,
+    /// The raw event from Rapier.
+    pub raw: RapierSoftBodyTearEvent,
+}
+
+/// A soft body resulting from a tear (see [`SoftBodyTearEvent::pieces`]).
+#[derive(Clone, Debug, PartialEq, Eq)]
+pub struct SoftBodyTearPiece {
+    /// The entity of the soft body holding the piece.
+    pub soft_body: Entity,
+    /// The particles of the piece: `particles[i]` is the index, in the torn body after the tear,
+    /// of the piece's `i`-th particle.
+    pub particles: Vec<u32>,
+}
+
+/// A piece of a soft-body cluster split by a tear (see [`SoftBodyTearEvent::cluster_splits`]).
+#[derive(Copy, Clone, Debug, PartialEq, Eq)]
+pub struct SoftBodyClusterSplit {
+    /// The index of the split cluster in the torn body, before the tear.
+    pub source_cluster: u32,
+    /// The entity of the soft body holding the piece.
+    pub soft_body: Entity,
+    /// The piece's cluster index in that soft body.
+    pub cluster: u32,
+    /// The entity the piece's proxy rigid-body maps to: the [`SoftBodyCluster`] entity of the
+    /// cluster (a new one is spawned for a piece given a fresh proxy), or the soft body entity for
+    /// a cluster without entity.
+    ///
+    /// [`SoftBodyCluster`]: crate::dynamics::SoftBodyCluster
+    pub proxy: Option<Entity>,
+    /// Whether this piece kept the proxy of the source cluster.
+    pub keeps_proxy: bool,
+}
+
+/// An impulse joint moved to another cluster proxy by a tear (see
+/// [`SoftBodyTearEvent::moved_joints`]).
+///
+/// The [`ImpulseJoint`](crate::dynamics::ImpulseJoint) component of the joint entity is not
+/// modified: its `parent` may no longer match the Rapier joint.
+#[derive(Copy, Clone, Debug, PartialEq, Eq)]
+pub struct SoftBodyJointMove {
+    /// The entity of the joint.
+    pub joint: Option<Entity>,
+    /// The entity of the proxy the joint was attached to.
+    pub from: Option<Entity>,
+    /// The entity of the proxy the joint is attached to now.
+    pub to: Option<Entity>,
+}
+
+/// Forwards every event emitted by Rapier to Bevy's event queue and to the user-provided
+/// event handler (see [`RapierContextSimulation::set_event_handler`]), if any.
+pub(crate) struct EventHandlerFanOut<'a> {
+    pub queue: Option<&'a EventQueue<'a>>,
+    pub user: Option<&'a (dyn EventHandler + Send + Sync)>,
+    /// Collects the soft-body tear events, processed after the step to spawn the piece entities.
+    pub soft_body_tears: &'a RwLock<Vec<RapierSoftBodyTearEvent>>,
+}
+
+impl EventHandlerFanOut<'_> {
+    fn handlers(&self) -> impl Iterator<Item = &dyn EventHandler> {
+        self.queue
+            .map(|q| q as &dyn EventHandler)
+            .into_iter()
+            .chain(self.user.map(|h| h as &dyn EventHandler))
+    }
+}
+
+impl EventHandler for EventHandlerFanOut<'_> {
+    fn handle_collision_event(
+        &self,
+        bodies: &RigidBodySet,
+        colliders: &ColliderSet,
+        event: RapierCollisionEvent,
+        contact_pair: Option<&ContactPair>,
+    ) {
+        for handler in self.handlers() {
+            handler.handle_collision_event(bodies, colliders, event, contact_pair);
+        }
+    }
+
+    fn handle_contact_force_event(
+        &self,
+        dt: Real,
+        bodies: &RigidBodySet,
+        colliders: &ColliderSet,
+        contact_pair: &ContactPair,
+        total_force_magnitude: Real,
+    ) {
+        for handler in self.handlers() {
+            handler.handle_contact_force_event(
+                dt,
+                bodies,
+                colliders,
+                contact_pair,
+                total_force_magnitude,
+            );
+        }
+    }
+
+    fn handle_soft_body_tear_event(
+        &self,
+        soft_bodies: &SoftBodySet,
+        event: &RapierSoftBodyTearEvent,
+    ) {
+        if let Ok(mut tears) = self.soft_body_tears.write() {
+            tears.push(event.clone());
+        }
+        for handler in self.handlers() {
+            handler.handle_soft_body_tear_event(soft_bodies, event);
+        }
+    }
+}
+
+// TODO: it may be more efficient to use crossbeam channel.
+// However crossbeam channels cause a Segfault (I have not
+// investigated how to reproduce this exactly to open an
+// issue).
+/// A set of queues collecting events emitted by the physics engine.
+pub(crate) struct EventQueue<'a> {
+    // Used to retrieve the entity of colliders that have been removed from the simulation
+    // since the last physics step.
+    pub deleted_colliders: &'a HashMap<ColliderHandle, Entity>,
+    pub collision_events: RwLock<Vec<CollisionEvent>>,
+    pub contact_force_events: RwLock<Vec<ContactForceEvent>>,
+}
+
+impl EventQueue<'_> {
+    fn collider2entity(&self, colliders: &ColliderSet, handle: ColliderHandle) -> Option<Entity> {
+        let entity = colliders
+            .get(handle)
+            .and_then(|co| Entity::try_from_bits(co.user_data as u64))
+            .or_else(|| self.deleted_colliders.get(&handle).copied());
+        if entity.is_none() {
+            // This happens for colliders Rapier removed by itself (e.g. the colliders of a torn
+            // soft body rebuilt by the tear) before the event was emitted.
+            log::debug!("No entity found for collider {handle:?}; its event is dropped.");
+        }
+        entity
+    }
+}
+
+impl EventHandler for EventQueue<'_> {
+    fn handle_collision_event(
+        &self,
+        _bodies: &RigidBodySet,
+        colliders: &ColliderSet,
+        event: RapierCollisionEvent,
+        _: Option<&ContactPair>,
+    ) {
+        let event = match event {
+            RapierCollisionEvent::Started(h1, h2, flags) => {
+                let (Some(e1), Some(e2)) = (
+                    self.collider2entity(colliders, h1),
+                    self.collider2entity(colliders, h2),
+                ) else {
+                    return;
+                };
+                CollisionEvent::Started(e1, e2, flags)
+            }
+            RapierCollisionEvent::Stopped(h1, h2, flags) => {
+                let (Some(e1), Some(e2)) = (
+                    self.collider2entity(colliders, h1),
+                    self.collider2entity(colliders, h2),
+                ) else {
+                    return;
+                };
+                CollisionEvent::Stopped(e1, e2, flags)
+            }
+        };
+
+        if let Ok(mut events) = self.collision_events.write() {
+            events.push(event);
+        }
+    }
+
+    fn handle_contact_force_event(
+        &self,
+        dt: Real,
+        _bodies: &RigidBodySet,
+        colliders: &ColliderSet,
+        contact_pair: &ContactPair,
+        total_force_magnitude: Real,
+    ) {
+        let rapier_event =
+            RapierContactForceEvent::from_contact_pair(dt, contact_pair, total_force_magnitude);
+        let (Some(collider1), Some(collider2)) = (
+            self.collider2entity(colliders, rapier_event.collider1),
+            self.collider2entity(colliders, rapier_event.collider2),
+        ) else {
+            return;
+        };
+        let event = ContactForceEvent {
+            collider1,
+            collider2,
+            total_force: rapier_event.total_force,
+            total_force_magnitude: rapier_event.total_force_magnitude,
+            max_force_direction: rapier_event.max_force_direction,
+            max_force_magnitude: rapier_event.max_force_magnitude,
+            started: rapier_event.started,
+        };
+
+        if let Ok(mut events) = self.contact_force_events.write() {
+            events.push(event);
+        }
+    }
+    // Tear events are collected by `EventHandlerFanOut` and turned into Bevy messages after the
+    // step, once the entities of the new pieces are spawned.
+    fn handle_soft_body_tear_event(
+        &self,
+        _soft_bodies: &SoftBodySet,
+        _event: &RapierSoftBodyTearEvent,
+    ) {
+    }
+}
+
+#[cfg(test)]
+mod test {
+    use bevy::{
+        app::{App, Startup, Update},
+        prelude::{Commands, Component, Entity, Query, With},
+        time::{TimePlugin, TimeUpdateStrategy},
+        transform::{components::Transform, TransformPlugin},
+        MinimalPlugins,
+    };
+
+    use crate::{plugin::*, prelude::*};
+
+    #[cfg(feature = "dim3")]
+    fn cuboid(hx: Real, hy: Real, hz: Real) -> Collider {
+        Collider::cuboid(hx, hy, hz)
+    }
+    #[cfg(feature = "dim2")]
+    fn cuboid(hx: Real, hy: Real, _hz: Real) -> Collider {
+        Collider::cuboid(hx, hy)
+    }
+
+    #[test]
+    pub fn events_received() {
+        return main();
+
+        use bevy::prelude::*;
+
+        #[derive(Resource, Reflect)]
+        pub struct EventsSaver<E: Message> {
+            pub events: Vec<E>,
+        }
+        impl<E: Message> Default for EventsSaver<E> {
+            fn default() -> Self {
+                Self {
+                    events: Default::default(),
+                }
+            }
+        }
+        pub fn save_events<E: Message + Clone>(
+            mut events: MessageReader<E>,
+            mut saver: ResMut<EventsSaver<E>>,
+        ) {
+            for event in events.read() {
+                saver.events.push(event.clone());
+            }
+        }
+        fn run_test(app: &mut App) {
+            app.add_systems(PostUpdate, save_events::<CollisionEvent>)
+                .add_systems(PostUpdate, save_events::<ContactForceEvent>)
+                .init_resource::<EventsSaver<CollisionEvent>>()
+                .init_resource::<EventsSaver<ContactForceEvent>>();
+
+            // Simulates 60 updates per seconds
+            app.insert_resource(TimeUpdateStrategy::ManualDuration(
+                std::time::Duration::from_secs_f32(1f32 / 60f32),
+            ));
+            app.finish();
+            // 2 seconds should be plenty of time for the cube to fall on the
+            // lowest collider.
+            for _ in 0..120 {
+                app.update();
+            }
+            let saved_collisions = app
+                .world()
+                .get_resource::<EventsSaver<CollisionEvent>>()
+                .unwrap();
+            assert!(!saved_collisions.events.is_empty());
+            let saved_contact_forces = app
+                .world()
+                .get_resource::<EventsSaver<CollisionEvent>>()
+                .unwrap();
+            assert!(!saved_contact_forces.events.is_empty());
+        }
+
+        /// Adapted from events example
+        fn main() {
+            let mut app = App::new();
+            app.add_plugins((
+                TransformPlugin,
+                TimePlugin,
+                RapierPhysicsPlugin::<NoUserData>::default(),
+            ))
+            .add_systems(Startup, setup_physics);
+            run_test(&mut app);
+        }
+
+        pub fn setup_physics(mut commands: Commands) {
+            /*
+             * Ground
+             */
+            commands.spawn((Transform::from_xyz(0.0, -1.2, 0.0), cuboid(4.0, 1.0, 1.0)));
+
+            commands.spawn((
+                Transform::from_xyz(0.0, 5.0, 0.0),
+                cuboid(4.0, 1.5, 1.0),
+                Sensor,
+            ));
+
+            commands.spawn((
+                Transform::from_xyz(0.0, 13.0, 0.0),
+                RigidBody::Dynamic,
+                cuboid(0.5, 0.5, 0.5),
+                ActiveEvents::COLLISION_EVENTS,
+                ContactForceEventThreshold(30.0),
+            ));
+        }
+    }
+
+    fn falling_box_app() -> App {
+        let mut app = App::new();
+        app.add_plugins((
+            TransformPlugin,
+            TimePlugin,
+            RapierPhysicsPlugin::<NoUserData>::default(),
+        ))
+        .insert_resource(TimeUpdateStrategy::ManualDuration(
+            std::time::Duration::from_secs_f32(1f32 / 60f32),
+        ))
+        .add_systems(Startup, |mut commands: Commands| {
+            commands.spawn((Transform::from_xyz(0.0, -1.0, 0.0), cuboid(4.0, 1.0, 4.0)));
+            commands.spawn((
+                Transform::from_xyz(0.0, 0.6, 0.0),
+                RigidBody::Dynamic,
+                cuboid(0.5, 0.5, 0.5),
+                ActiveEvents::COLLISION_EVENTS | ActiveEvents::CONTACT_FORCE_EVENTS,
+                ContactForceEventThreshold(0.0),
+            ));
+        });
+        app
+    }
+
+    #[test]
+    pub fn contact_force_event_started_flag() {
+        use bevy::prelude::*;
+
+        #[derive(Resource, Default)]
+        struct Saved(Vec<ContactForceEvent>);
+
+        let mut app = falling_box_app();
+        app.init_resource::<Saved>().add_systems(
+            PostUpdate,
+            |mut events: MessageReader<ContactForceEvent>, mut saved: ResMut<Saved>| {
+                saved.0.extend(events.read().copied());
+            },
+        );
+        app.finish();
+        for _ in 0..120 {
+            app.update();
+        }
+
+        let events = &app.world().resource::<Saved>().0;
+        assert!(events.len() > 2);
+        // The first event is emitted when the force first crosses the threshold.
+        assert!(events[0].started);
+        // The box then rests on the ground, keeping the force above the threshold.
+        assert!(!events.last().unwrap().started);
+        assert!(events.iter().filter(|e| e.started).count() < events.len());
+    }
+
+    #[test]
+    pub fn custom_event_handler_receives_events() {
+        use bevy::prelude::*;
+        use rapier::dynamics::{RigidBodySet, SoftBodySet, SoftBodyTearEvent};
+        use rapier::geometry::{ColliderSet, CollisionEvent as RapierCollisionEvent, ContactPair};
+        use rapier::pipeline::EventHandler;
+        use std::sync::{
+            atomic::{AtomicUsize, Ordering},
+            Arc,
+        };
+
+        #[derive(Default, Clone)]
+        struct Counters {
+            collisions: Arc<AtomicUsize>,
+            collisions_with_pair: Arc<AtomicUsize>,
+            forces: Arc<AtomicUsize>,
+        }
+
+        impl EventHandler for Counters {
+            fn handle_collision_event(
+                &self,
+                _bodies: &RigidBodySet,
+                _colliders: &ColliderSet,
+                _event: RapierCollisionEvent,
+                contact_pair: Option<&ContactPair>,
+            ) {
+                self.collisions.fetch_add(1, Ordering::SeqCst);
+                if contact_pair.is_some() {
+                    self.collisions_with_pair.fetch_add(1, Ordering::SeqCst);
+                }
+            }
+
+            fn handle_contact_force_event(
+                &self,
+                _dt: crate::math::Real,
+                _bodies: &RigidBodySet,
+                _colliders: &ColliderSet,
+                _contact_pair: &ContactPair,
+                _total_force_magnitude: crate::math::Real,
+            ) {
+                self.forces.fetch_add(1, Ordering::SeqCst);
+            }
+
+            fn handle_soft_body_tear_event(
+                &self,
+                _soft_bodies: &SoftBodySet,
+                _event: &SoftBodyTearEvent,
+            ) {
+            }
+        }
+
+        #[derive(Resource, Default)]
+        struct BevyCounts {
+            collisions: usize,
+            forces: usize,
+        }
+
+        let counters = Counters::default();
+        let handler = counters.clone();
+        let mut app = falling_box_app();
+        app.init_resource::<BevyCounts>()
+            .add_systems(
+                Startup,
+                move |mut contexts: Query<&mut RapierContextSimulation>| {
+                    for mut context in contexts.iter_mut() {
+                        context.set_event_handler(handler.clone());
+                    }
+                },
+            )
+            .add_systems(
+                PostUpdate,
+                |mut collisions: MessageReader<CollisionEvent>,
+                 mut forces: MessageReader<ContactForceEvent>,
+                 mut counts: ResMut<BevyCounts>| {
+                    counts.collisions += collisions.read().count();
+                    counts.forces += forces.read().count();
+                },
+            );
+        app.finish();
+        for _ in 0..60 {
+            app.update();
+        }
+
+        let bevy_counts = app.world().resource::<BevyCounts>();
+        let collisions = counters.collisions.load(Ordering::SeqCst);
+        let forces = counters.forces.load(Ordering::SeqCst);
+        assert!(collisions > 0);
+        assert!(counters.collisions_with_pair.load(Ordering::SeqCst) > 0);
+        assert!(forces > 0);
+        // Bevy messages are still sent alongside the custom handler.
+        assert_eq!(bevy_counts.collisions, collisions);
+        assert_eq!(bevy_counts.forces, forces);
+    }
+
+    #[test]
+    pub fn spam_remove_rapier_entity_interpolated() {
+        let mut app = App::new();
+        app.add_plugins((
+            MinimalPlugins,
+            TransformPlugin,
+            RapierPhysicsPlugin::<NoUserData>::default(),
+        ))
+        .insert_resource(TimestepMode::Interpolated {
+            dt: 1.0 / 30.0,
+            time_scale: 1.0,
+            substeps: 2,
+        })
+        .add_systems(Startup, setup_physics)
+        .add_systems(Update, remove_collider);
+        // Simulates 60 updates per seconds
+        app.insert_resource(TimeUpdateStrategy::ManualDuration(
+            std::time::Duration::from_secs_f32(1f32 / 60f32),
+        ));
+
+        app.finish();
+
+        for _ in 0..100 {
+            app.update();
+        }
+        return;
+
+        #[derive(Component)]
+        pub struct ToRemove;
+
+        #[cfg(feature = "dim3")]
+        fn cuboid(hx: Real, hy: Real, hz: Real) -> Collider {
+            Collider::cuboid(hx, hy, hz)
+        }
+        #[cfg(feature = "dim2")]
+        fn cuboid(hx: Real, hy: Real, _hz: Real) -> Collider {
+            Collider::cuboid(hx, hy)
+        }
+        pub fn setup_physics(mut commands: Commands) {
+            for _i in 0..100 {
+                commands.spawn((
+                    Transform::from_xyz(0.0, 0.0, 0.0),
+                    RigidBody::Dynamic,
+                    cuboid(0.5, 0.5, 0.5),
+                    ActiveEvents::all(),
+                    ToRemove,
+                ));
+            }
+            /*
+             * Ground
+             */
+            let ground_size = 5.1;
+            let ground_height = 0.1;
+            let starting_y = -0.5 - ground_height;
+
+            commands.spawn((
+                Transform::from_xyz(0.0, starting_y, 0.0),
+                cuboid(ground_size, ground_height, ground_size),
+            ));
+        }
+
+        fn remove_collider(mut commands: Commands, query: Query<Entity, With<ToRemove>>) {
+            let Some(entity) = query.iter().next() else {
+                return;
+            };
+            commands.entity(entity).despawn();
+        }
+    }
+}
diff --git a/bindings/bevy_rapier/src/pipeline/mod.rs b/bindings/bevy_rapier/src/pipeline/mod.rs
new file mode 100644
index 000000000..db0815096
--- /dev/null
+++ b/bindings/bevy_rapier/src/pipeline/mod.rs
@@ -0,0 +1,14 @@
+pub use self::events::{
+    CollisionEvent, ContactForceEvent, PhysicsQuarantineEvent, SoftBodyClusterSplit,
+    SoftBodyJointMove, SoftBodyTearEvent, SoftBodyTearPiece, SoftBodyTearResult,
+};
+pub(crate) use self::events::{EventHandlerFanOut, EventQueue};
+pub(crate) use self::physics_hooks::BevyPhysicsHooksAdapter;
+pub use self::physics_hooks::{
+    BevyPhysicsHooks, ContactModificationContextView, PairFilterContextView,
+};
+pub use query_filter::{QueryFilter, QueryFilterFlags};
+
+mod events;
+mod physics_hooks;
+mod query_filter;
diff --git a/bindings/bevy_rapier/src/pipeline/physics_hooks.rs b/bindings/bevy_rapier/src/pipeline/physics_hooks.rs
new file mode 100644
index 000000000..a98481355
--- /dev/null
+++ b/bindings/bevy_rapier/src/pipeline/physics_hooks.rs
@@ -0,0 +1,463 @@
+use bevy::{ecs::system::SystemParam, prelude::*};
+use rapier::{
+    geometry::{ContactManifold, SoftPairContacts, SolverContact, SolverContacts},
+    pipeline::{ContactModificationContext, ModifiableContacts, PairFilterContext},
+    prelude::{PhysicsHooks, SolverFlags},
+};
+
+use crate::math::{Real, Vect};
+
+/// Read-only access to the properties of a collision pair filter context.
+pub struct PairFilterContextView<'a> {
+    /// The raw context from Rapier.
+    pub raw: &'a PairFilterContext<'a>,
+}
+
+impl PairFilterContextView<'_> {
+    /// The entity of the first collider involved in the potential collision.
+    pub fn collider1(&self) -> Entity {
+        let co1 = &self.raw.colliders[self.raw.collider1];
+        Entity::from_bits(co1.user_data as u64)
+    }
+
+    /// The entity of the second collider involved in the potential collision.
+    pub fn collider2(&self) -> Entity {
+        let co2 = &self.raw.colliders[self.raw.collider2];
+        Entity::from_bits(co2.user_data as u64)
+    }
+
+    /// The entity of the first rigid-body (if `self.collider1()` is attached to a rigid-body)
+    /// involved in the potential collision.
+    pub fn rigid_body1(&self) -> Option<Entity> {
+        self.raw.rigid_body1.map(|h| {
+            let co1 = &self.raw.bodies[h];
+            Entity::from_bits(co1.user_data as u64)
+        })
+    }
+
+    /// The entity of the second rigid-body (if `self.collider1()` is attached to a rigid-body)
+    /// involved in the potential collision.
+    pub fn rigid_body2(&self) -> Option<Entity> {
+        self.raw.rigid_body2.map(|h| {
+            let co2 = &self.raw.bodies[h];
+            Entity::from_bits(co2.user_data as u64)
+        })
+    }
+}
+
+/// Read-write access to the properties of a contact modification context.
+pub struct ContactModificationContextView<'a, 'b> {
+    /// The raw context from Rapier.
+    pub raw: &'a mut ContactModificationContext<'b>,
+}
+
+impl ContactModificationContextView<'_, '_> {
+    /// The entity of the first collider involved in the potential collision.
+    pub fn collider1(&self) -> Entity {
+        let co1 = &self.raw.colliders[self.raw.collider1];
+        Entity::from_bits(co1.user_data as u64)
+    }
+
+    /// The entity of the second collider involved in the potential collision.
+    pub fn collider2(&self) -> Entity {
+        let co2 = &self.raw.colliders[self.raw.collider2];
+        Entity::from_bits(co2.user_data as u64)
+    }
+
+    /// The entity of the first rigid-body (if `self.collider1()` is attached to a rigid-body)
+    /// involved in the potential collision.
+    pub fn rigid_body1(&self) -> Option<Entity> {
+        self.raw.rigid_body1.map(|h| {
+            let co1 = &self.raw.bodies[h];
+            Entity::from_bits(co1.user_data as u64)
+        })
+    }
+
+    /// The entity of the second rigid-body (if `self.collider1()` is attached to a rigid-body)
+    /// involved in the potential collision.
+    pub fn rigid_body2(&self) -> Option<Entity> {
+        self.raw.rigid_body2.map(|h| {
+            let co2 = &self.raw.bodies[h];
+            Entity::from_bits(co2.user_data as u64)
+        })
+    }
+}
+
+impl ContactModificationContextView<'_, '_> {
+    /// Is this a pair with contact manifolds (every pair except two soft surfaces)?
+    ///
+    /// All the manifold accessors of this view (e.g. [`Self::normal`], [`Self::friction`],
+    /// [`Self::solver_contacts`]) are only meaningful for such pairs.
+    pub fn is_rigid(&self) -> bool {
+        matches!(self.raw.contacts, ModifiableContacts::Rigid(_))
+    }
+
+    /// Is this a pair of two soft surfaces?
+    ///
+    /// The contacts of such pairs are contact candidates rather than a manifold. They can be
+    /// accessed through [`Self::soft`] and [`Self::soft_mut`]; the manifold accessors of this
+    /// view return `None` (or do nothing) for them.
+    pub fn is_soft(&self) -> bool {
+        matches!(self.raw.contacts, ModifiableContacts::Soft(_))
+    }
+
+    /// The contact candidates of a pair of two soft surfaces (`None` for other pairs).
+    pub fn soft(&self) -> Option<&SoftPairContacts> {
+        self.raw.soft()
+    }
+
+    /// Mutable access to the contact candidates of a pair of two soft surfaces (`None` for other
+    /// pairs).
+    ///
+    /// A candidate's `dir` and `dist` can be modified, or its `enabled` flag cleared to drop it;
+    /// [`SoftPairContacts::disable_all`] ignores the whole pair in the constraints solver.
+    pub fn soft_mut(&mut self) -> Option<&mut SoftPairContacts> {
+        self.raw.soft_mut()
+    }
+
+    /// The contact manifold being modified (`None` for a pair of two soft surfaces).
+    pub fn manifold(&self) -> Option<&ContactManifold> {
+        self.raw.rigid().map(|m| m.manifold)
+    }
+
+    /// The world-space contact normal of the manifold (`None` for a pair of two soft surfaces).
+    pub fn normal(&self) -> Option<Vect> {
+        self.raw.rigid().map(|m| *m.normal)
+    }
+
+    /// Sets the world-space contact normal of the manifold (ignored for a pair of two soft surfaces).
+    pub fn set_normal(&mut self, normal: Vect) {
+        if let Some(m) = self.raw.rigid_mut() {
+            *m.normal = normal;
+        }
+    }
+
+    /// The friction coefficient applied to every solver contact of the manifold (`None` for a
+    /// pair of two soft surfaces).
+    pub fn friction(&self) -> Option<Real> {
+        self.raw.rigid().map(|m| *m.friction)
+    }
+
+    /// Sets the friction coefficient applied to every solver contact of the manifold (ignored for a
+    /// pair of two soft surfaces).
+    pub fn set_friction(&mut self, friction: Real) {
+        if let Some(m) = self.raw.rigid_mut() {
+            *m.friction = friction;
+        }
+    }
+
+    /// The restitution coefficient applied to every solver contact of the manifold (`None` for a
+    /// pair of two soft surfaces).
+    pub fn restitution(&self) -> Option<Real> {
+        self.raw.rigid().map(|m| *m.restitution)
+    }
+
+    /// Sets the restitution coefficient applied to every solver contact of the manifold (ignored
+    /// for a pair of two soft surfaces).
+    pub fn set_restitution(&mut self, restitution: Real) {
+        if let Some(m) = self.raw.rigid_mut() {
+            *m.restitution = restitution;
+        }
+    }
+
+    /// The user-defined data of the manifold, persistent across timesteps while the manifold
+    /// exists (`None` for a pair of two soft surfaces).
+    pub fn user_data(&self) -> Option<u32> {
+        self.raw.rigid().map(|m| *m.user_data)
+    }
+
+    /// Sets the user-defined data of the manifold (ignored for a pair of two soft surfaces).
+    pub fn set_user_data(&mut self, user_data: u32) {
+        if let Some(m) = self.raw.rigid_mut() {
+            *m.user_data = user_data;
+        }
+    }
+
+    /// The solver contacts of the manifold (`None` for a pair of two soft surfaces).
+    ///
+    /// While inside the hook, each solver contact's `anchor1`/`anchor2` hold the world-space
+    /// contact points on each body and `dist` their separation.
+    pub fn solver_contacts(&self) -> Option<&[SolverContact]> {
+        self.raw.rigid().map(|m| &m.solver_contacts[..])
+    }
+
+    /// Mutable access to the solver contacts of the manifold (`None` for a pair of two soft
+    /// surfaces).
+    ///
+    /// Contacts can be modified (e.g. their `tangent_velocity` to simulate conveyor belts),
+    /// removed, or all cleared to ignore this manifold in the constraints solver.
+    pub fn solver_contacts_mut(&mut self) -> Option<&mut SolverContacts> {
+        self.raw.rigid_mut().map(|m| &mut *m.solver_contacts)
+    }
+
+    /// Updates the contacts to emulate a one-way platform.
+    ///
+    /// Contacts are only allowed if the contact normal, expressed in the local space of the first
+    /// collider, is within `allowed_angle` (in radians) of `allowed_local_n1`. This must be called
+    /// at each timestep for each manifold involving the platform, and the manifold's user data
+    /// must not be modified elsewhere since it is used to track the contact state. Pairs of two
+    /// soft surfaces are left untouched.
+    pub fn update_as_oneway_platform(&mut self, allowed_local_n1: Vect, allowed_angle: Real) {
+        self.raw
+            .update_as_oneway_platform(allowed_local_n1, allowed_angle);
+    }
+}
+
+/// User-defined functions called by the physics engines during one timestep in order to customize its behavior.
+///
+/// Note that the default implementations of the filtering methods match Rapier's
+/// [`PhysicsHooks`] defaults: [`Self::filter_contact_pair`] returns
+/// `Some(SolverFlags::COMPUTE_RIGID_IMPULSES)` and [`Self::filter_intersection_pair`] returns
+/// `true`, so enabling a hook on a collider without overriding the corresponding method does not
+/// change which pairs interact.
+pub trait BevyPhysicsHooks: SystemParam + Send + Sync {
+    /// Applies the contact pair filter.
+    ///
+    /// Note that this method will only be called if at least one of the colliders
+    /// involved in the contact contains the `ActiveHooks::FILTER_CONTACT_PAIRS` flags
+    /// in its physics hooks flags.
+    ///
+    /// User-defined filter for potential contact pairs detected by the broad-phase.
+    /// This can be used to apply custom logic in order to decide whether two colliders
+    /// should have their contact computed by the narrow-phase, and if these contact
+    /// should be solved by the constraints solver
+    ///
+    /// This filter doesn't replace the built-in filtering: it is only called for the pairs that
+    /// passed it. Rapier first discards the pairs of colliders attached to the same rigid-body or
+    /// to multibody links (or impulse joints) with contacts disabled between them, then the pairs
+    /// rejected by the [`ActiveCollisionTypes`] of both colliders (e.g. two non-dynamic bodies by
+    /// default), then the pairs rejected by their [`CollisionGroups`]. The [`SolverGroups`] are
+    /// applied to the returned solver flags afterwards.
+    ///
+    /// [`ActiveCollisionTypes`]: crate::geometry::ActiveCollisionTypes
+    /// [`CollisionGroups`]: crate::geometry::CollisionGroups
+    /// [`SolverGroups`]: crate::geometry::SolverGroups
+    ///
+    /// If this returns `None`, then the narrow-phase will ignore this contact pair and
+    /// not compute any contact manifolds for it.
+    /// If this returns `Some`, then the narrow-phase will compute contact manifolds for
+    /// this pair of colliders, and configure them with the returned solver flags. For
+    /// example, if this returns `Some(SolverFlags::COMPUTE_RIGID_IMPULSES)` then the contacts
+    /// will be taken into account by the constraints solver. If this returns
+    /// `Some(SolverFlags::empty())` then the constraints solver will ignore these
+    /// contacts.
+    ///
+    /// The default implementation returns `Some(SolverFlags::COMPUTE_RIGID_IMPULSES)`.
+    fn filter_contact_pair(&self, _context: PairFilterContextView) -> Option<SolverFlags> {
+        Some(SolverFlags::COMPUTE_RIGID_IMPULSES)
+    }
+
+    /// Applies the intersection pair filter.
+    ///
+    /// Note that this method will only be called if at least one of the colliders
+    /// involved in the contact contains the `ActiveHooks::FILTER_INTERSECTION_PAIR` flags
+    /// in its physics hooks flags.
+    ///
+    /// User-defined filter for potential intersection pairs detected by the broad-phase.
+    ///
+    /// This can be used to apply custom logic in order to decide whether two colliders
+    /// should have their intersection computed by the narrow-phase.
+    ///
+    /// This filter doesn't replace the built-in filtering: it is only called for the pairs that
+    /// passed it. Rapier first discards the pairs rejected by the [`ActiveCollisionTypes`] of both
+    /// colliders (e.g. two non-dynamic bodies by default), then the pairs rejected by their
+    /// [`CollisionGroups`].
+    ///
+    /// [`ActiveCollisionTypes`]: crate::geometry::ActiveCollisionTypes
+    /// [`CollisionGroups`]: crate::geometry::CollisionGroups
+    ///
+    /// If this returns `false`, then the narrow-phase will ignore this pair and
+    /// not compute any intersection information for it.
+    /// If this return `true` then the narrow-phase will compute intersection
+    /// information for this pair.
+    ///
+    /// The default implementation returns `true`.
+    fn filter_intersection_pair(&self, _context: PairFilterContextView) -> bool {
+        true
+    }
+
+    /// Modifies the set of contacts seen by the constraints solver.
+    ///
+    /// Note that this method will only be called if at least one of the colliders
+    /// involved in the contact contains the `ActiveHooks::MODIFY_SOLVER_CONTACTS` flags
+    /// in its physics hooks flags.
+    ///
+    /// It is called on each contact manifold (with at least one solver contact) of such pairs,
+    /// after the solver contacts were computed from the manifold's contact points. This can be
+    /// used to modify the set of solver contacts seen by the constraints solver: contacts can be
+    /// removed and modified.
+    ///
+    /// Note that if all the contacts have to be ignored by the constraint solver, you may simply
+    /// clear them with `context.solver_contacts_mut()`.
+    ///
+    /// Modifying the solver contacts allow you to achieve various effects, including:
+    /// - Simulating conveyor belts by setting the `tangent_velocity` of a solver contact.
+    /// - Simulating shapes with multiply materials by modifying the friction and restitution
+    ///   coefficient depending of the features in contacts.
+    /// - Simulating one-way platforms depending on the contact normal.
+    ///
+    /// Each contact manifold is given a `u32` user-defined data that is persistent between
+    /// timesteps (as long as the contact manifold exists). This user-defined data is initialized
+    /// as 0 and can be modified with [`ContactModificationContextView::set_user_data`].
+    ///
+    /// The world-space contact normal, friction and restitution can be modified with
+    /// [`ContactModificationContextView::set_normal`],
+    /// [`ContactModificationContextView::set_friction`] and
+    /// [`ContactModificationContextView::set_restitution`].
+    fn modify_solver_contacts(&self, _context: ContactModificationContextView) {}
+}
+
+impl<T> BevyPhysicsHooks for T
+where
+    T: 'static + PhysicsHooks + SystemParam + Send + Sync,
+    for<'w, 's> T: SystemParam<Item<'w, 's> = T>,
+{
+    fn filter_contact_pair(&self, context: PairFilterContextView) -> Option<SolverFlags> {
+        PhysicsHooks::filter_contact_pair(self, context.raw)
+    }
+
+    fn filter_intersection_pair(&self, context: PairFilterContextView) -> bool {
+        PhysicsHooks::filter_intersection_pair(self, context.raw)
+    }
+
+    fn modify_solver_contacts(&self, context: ContactModificationContextView) {
+        PhysicsHooks::modify_solver_contacts(self, context.raw)
+    }
+}
+
+/// Adapts a type implementing `BevyPhysicsHooks` so that it implements `PhysicsHooks`.
+pub(crate) struct BevyPhysicsHooksAdapter<Hooks>
+where
+    Hooks: BevyPhysicsHooks,
+{
+    hooks: Hooks,
+}
+
+impl<Hooks> BevyPhysicsHooksAdapter<Hooks>
+where
+    Hooks: BevyPhysicsHooks,
+{
+    pub(crate) fn new(hooks: Hooks) -> Self {
+        Self { hooks }
+    }
+}
+
+impl<Hooks> PhysicsHooks for BevyPhysicsHooksAdapter<Hooks>
+where
+    Hooks: BevyPhysicsHooks,
+{
+    fn filter_contact_pair(&self, context: &PairFilterContext) -> Option<SolverFlags> {
+        let context_view = PairFilterContextView { raw: context };
+        self.hooks.filter_contact_pair(context_view)
+    }
+
+    fn filter_intersection_pair(&self, context: &PairFilterContext) -> bool {
+        let context_view = PairFilterContextView { raw: context };
+        self.hooks.filter_intersection_pair(context_view)
+    }
+
+    fn modify_solver_contacts(&self, context: &mut ContactModificationContext) {
+        let context_view = ContactModificationContextView { raw: context };
+        self.hooks.modify_solver_contacts(context_view)
+    }
+}
+
+#[cfg(test)]
+mod test {
+    use crate::math::{Real, Vect};
+    use crate::prelude::*;
+    use bevy::{
+        ecs::system::SystemParam,
+        prelude::*,
+        time::{TimePlugin, TimeUpdateStrategy},
+    };
+    use std::sync::{
+        atomic::{AtomicUsize, Ordering},
+        Arc,
+    };
+
+    const FRICTION: Real = 0.123;
+    const RESTITUTION: Real = 0.0;
+
+    #[derive(Resource, Default)]
+    struct HookCalls(Arc<AtomicUsize>);
+
+    #[derive(SystemParam)]
+    struct ModifyingHooks<'w> {
+        calls: Res<'w, HookCalls>,
+    }
+
+    impl BevyPhysicsHooks for ModifyingHooks<'_> {
+        fn modify_solver_contacts(&self, mut context: ContactModificationContextView) {
+            assert!(context.is_rigid());
+            assert!(!context.is_soft());
+            assert!(context.manifold().is_some());
+            assert!(context.solver_contacts().is_some());
+            let n = context.normal().unwrap();
+            context.set_normal(if n.y > 0.0 { Vect::Y } else { -Vect::Y });
+            context.set_friction(FRICTION);
+            context.set_restitution(RESTITUTION);
+            context.set_user_data(42);
+            self.calls.0.fetch_add(1, Ordering::SeqCst);
+        }
+    }
+
+    #[cfg(feature = "dim3")]
+    fn cuboid(hx: Real, hy: Real, hz: Real) -> Collider {
+        Collider::cuboid(hx, hy, hz)
+    }
+    #[cfg(feature = "dim2")]
+    fn cuboid(hx: Real, hy: Real, _hz: Real) -> Collider {
+        Collider::cuboid(hx, hy)
+    }
+
+    #[test]
+    fn hook_modifies_friction_and_normal() {
+        let mut app = App::new();
+        app.add_plugins((
+            TransformPlugin,
+            TimePlugin,
+            RapierPhysicsPlugin::<ModifyingHooks>::default(),
+        ))
+        .init_resource::<HookCalls>()
+        .insert_resource(TimeUpdateStrategy::ManualDuration(
+            std::time::Duration::from_secs_f32(1f32 / 60f32),
+        ));
+        let ground = app
+            .world_mut()
+            .spawn((Transform::from_xyz(0.0, -1.0, 0.0), cuboid(4.0, 1.0, 4.0)))
+            .id();
+        let body = app
+            .world_mut()
+            .spawn((
+                Transform::from_xyz(0.0, 0.6, 0.0),
+                RigidBody::Dynamic,
+                cuboid(0.5, 0.5, 0.5),
+                ActiveHooks::MODIFY_SOLVER_CONTACTS,
+            ))
+            .id();
+        app.finish();
+        for _ in 0..60 {
+            app.update();
+        }
+
+        assert!(app.world().resource::<HookCalls>().0.load(Ordering::SeqCst) > 0);
+
+        let mut query = app.world_mut().query::<(
+            &RapierContextSimulation,
+            &RapierContextColliders,
+            &RapierRigidBodySet,
+        )>();
+        let (simulation, colliders, bodies) = query.single(app.world()).unwrap();
+        let pair = simulation
+            .contact_pair(colliders, bodies, ground, body)
+            .unwrap();
+        assert!(pair.has_any_active_contact());
+        for manifold in pair.manifolds() {
+            assert_eq!(manifold.friction(), FRICTION);
+            assert_eq!(manifold.restitution(), RESTITUTION);
+            assert_eq!(manifold.user_data(), 42);
+            assert_eq!(manifold.normal().abs(), Vect::Y);
+        }
+    }
+}
diff --git a/bindings/bevy_rapier/src/pipeline/query_filter.rs b/bindings/bevy_rapier/src/pipeline/query_filter.rs
new file mode 100644
index 000000000..183316cf6
--- /dev/null
+++ b/bindings/bevy_rapier/src/pipeline/query_filter.rs
@@ -0,0 +1,126 @@
+use bevy::prelude::Entity;
+
+pub use rapier::pipeline::QueryFilterFlags;
+
+use crate::geometry::CollisionGroups;
+use rapier::geometry::Collider as RapierCollider;
+
+/// A filter that describes what collider should be included or excluded from a scene query.
+#[derive(Copy, Clone, Default)]
+pub struct QueryFilter<'a> {
+    /// Flags indicating what particular type of colliders should be excluded.
+    pub flags: QueryFilterFlags,
+    /// If set, only colliders with collision groups compatible with this one will
+    /// be included in the scene query.
+    ///
+    /// The [`CollisionGroups::test_mode`] of both groups is taken into account.
+    pub groups: Option<CollisionGroups>,
+    /// If set, the collider attached to that entity will be excluded from the query.
+    pub exclude_collider: Option<Entity>,
+    /// If set, any collider attached to the rigid-body attached to that entity
+    /// will be excluded from the query.
+    pub exclude_rigid_body: Option<Entity>,
+    /// If set, any collider for which this closure returns false will be excluded from the query.
+    ///
+    /// The closure is given the collider’s entity and its Rapier collider, which gives access to
+    /// its shape, position, parent, etc.
+    #[allow(clippy::type_complexity)]
+    pub predicate: Option<&'a dyn Fn(Entity, &RapierCollider) -> bool>,
+}
+
+impl From<QueryFilterFlags> for QueryFilter<'_> {
+    fn from(flags: QueryFilterFlags) -> Self {
+        Self {
+            flags,
+            ..QueryFilter::default()
+        }
+    }
+}
+
+impl From<CollisionGroups> for QueryFilter<'_> {
+    fn from(groups: CollisionGroups) -> Self {
+        Self {
+            groups: Some(groups),
+            ..QueryFilter::default()
+        }
+    }
+}
+
+impl<'a> QueryFilter<'a> {
+    /// A query filter that doesn’t exclude any collider.
+    pub fn new() -> Self {
+        Self::default()
+    }
+
+    /// Exclude from the query any collider attached to a fixed rigid-body and colliders with no rigid-body attached.
+    pub fn exclude_fixed() -> Self {
+        QueryFilterFlags::EXCLUDE_FIXED.into()
+    }
+
+    /// Exclude from the query any collider attached to a kinematic rigid-body.
+    pub fn exclude_kinematic() -> Self {
+        QueryFilterFlags::EXCLUDE_KINEMATIC.into()
+    }
+
+    /// Exclude from the query any collider attached to a dynamic rigid-body.
+    pub fn exclude_dynamic() -> Self {
+        QueryFilterFlags::EXCLUDE_DYNAMIC.into()
+    }
+
+    /// Excludes all colliders not attached to a dynamic rigid-body.
+    pub fn only_dynamic() -> Self {
+        QueryFilterFlags::ONLY_DYNAMIC.into()
+    }
+
+    /// Excludes all colliders not attached to a kinematic rigid-body.
+    pub fn only_kinematic() -> Self {
+        QueryFilterFlags::ONLY_KINEMATIC.into()
+    }
+
+    /// Exclude all colliders attached to a non-fixed rigid-body
+    /// (this will not exclude colliders not attached to any rigid-body).
+    pub fn only_fixed() -> Self {
+        QueryFilterFlags::ONLY_FIXED.into()
+    }
+
+    /// Exclude from the query any collider that is a sensor.
+    pub fn exclude_sensors(mut self) -> Self {
+        self.flags |= QueryFilterFlags::EXCLUDE_SENSORS;
+        self
+    }
+
+    /// Exclude from the query any collider that is not a sensor.
+    pub fn exclude_solids(mut self) -> Self {
+        self.flags |= QueryFilterFlags::EXCLUDE_SOLIDS;
+        self
+    }
+
+    /// Only colliders with collision groups compatible with this one will
+    /// be included in the scene query.
+    ///
+    /// The [`CollisionGroups::test_mode`] of both groups is taken into account.
+    pub fn groups(mut self, groups: CollisionGroups) -> Self {
+        self.groups = Some(groups);
+        self
+    }
+
+    /// Set the collider that will be excluded from the scene query.
+    pub fn exclude_collider(mut self, collider: Entity) -> Self {
+        self.exclude_collider = Some(collider);
+        self
+    }
+
+    /// Set the rigid-body that will be excluded from the scene query.
+    pub fn exclude_rigid_body(mut self, rigid_body: Entity) -> Self {
+        self.exclude_rigid_body = Some(rigid_body);
+        self
+    }
+
+    /// Set the predicate to apply a custom collider filtering during the scene query.
+    ///
+    /// The predicate is given the collider’s entity and its Rapier collider.
+    pub fn predicate(mut self, predicate: &'a impl Fn(Entity, &RapierCollider) -> bool) -> Self {
+        self.predicate = Some(predicate);
+        self
+    }
+}
diff --git a/bindings/bevy_rapier/src/plugin/configuration.rs b/bindings/bevy_rapier/src/plugin/configuration.rs
new file mode 100644
index 000000000..04a33643e
--- /dev/null
+++ b/bindings/bevy_rapier/src/plugin/configuration.rs
@@ -0,0 +1,167 @@
+//! Components used to configure a simulation run by rapier, these are not modified by bevy_rapier.
+
+use bevy::{
+    prelude::{Component, Resource},
+    reflect::Reflect,
+};
+
+use crate::math::{Real, Vect};
+
+#[cfg(doc)]
+use crate::prelude::TransformInterpolation;
+
+/// The friction model selected by [`IntegrationParameters::friction_model`].
+#[cfg(feature = "dim3")]
+pub use rapier::dynamics::FrictionModel;
+/// The low-level parameters of a context's simulation (see
+/// [`RapierContextSimulation::integration_parameters`](crate::plugin::context::RapierContextSimulation::integration_parameters)
+/// and [`RapierContextInitialization`](crate::plugin::RapierContextInitialization)).
+pub use rapier::dynamics::IntegrationParameters;
+
+/// The different ways of adjusting the timestep length each frame.
+#[derive(Copy, Clone, Debug, PartialEq, Resource)]
+#[cfg_attr(feature = "serde-serialize", derive(Serialize, Deserialize))]
+pub enum TimestepMode {
+    /// Use a fixed timestep: the physics simulation will be advanced by the fixed value
+    /// `dt` seconds at each Bevy tick by performing `substeps` of length `dt / substeps`.
+    Fixed {
+        /// The physics simulation will be advanced by this total amount at each Bevy tick.
+        dt: f32,
+        /// This number of substeps of length `dt / substeps` will be performed at each Bevy tick.
+        substeps: usize,
+    },
+    /// Use a variable timestep: the physics simulation will be advanced by the variable value
+    /// `min(max_dt, Time::delta_seconds() * time_scale)` seconds at each Bevy tick. If
+    /// `time_scale > 1.0` then the simulation will appear to run faster than real-time whereas
+    /// `time_scale < 1.0` makes the simulation run in slow-motion. No step is performed on ticks
+    /// where this is zero (e.g. the first tick, or `time_scale == 0.0`).
+    Variable {
+        /// Maximum amount of time the physics simulation may be advanced at each Bevy tick.
+        max_dt: f32,
+        /// Multiplier controlling if the physics simulation should advance faster (> 1.0),
+        /// at the same speed (= 1.0) or slower (< 1.0) than the real time.
+        time_scale: f32,
+        /// The number of substeps that will be performed at each tick.
+        substeps: usize,
+    },
+    /// Use a fixed timestep equal to `IntegrationParameters::dt`, but don't step if the
+    /// physics simulation advanced by a time greater than the real-world elapsed time multiplied by `time_scale`.
+    /// Rigid-bodies with a component [`TransformInterpolation`] attached will use interpolation to
+    /// estimate the rigid-bodies position in-between steps.
+    Interpolated {
+        /// The physics simulation will be advanced by this total amount at each Bevy tick, unless
+        /// the physics simulation time is ahead of a the real time.
+        dt: f32,
+        /// Multiplier controlling if the physics simulation should advance faster (> 1.0),
+        /// at the same speed (= 1.0) or slower (< 1.0) than the real time.
+        time_scale: f32,
+        /// The number of substeps that will be performed whenever the physics simulation is advanced.
+        substeps: usize,
+    },
+}
+
+impl Default for TimestepMode {
+    fn default() -> Self {
+        TimestepMode::Variable {
+            max_dt: 1.0 / 60.0,
+            time_scale: 1.0,
+            substeps: 1,
+        }
+    }
+}
+
+/// Selects what a simulation step of a Rapier context does.
+#[derive(Copy, Clone, Debug, Default, PartialEq, Eq, Hash, Reflect)]
+#[cfg_attr(feature = "serde-serialize", derive(Serialize, Deserialize))]
+pub enum SimulationMode {
+    /// Run the full physics pipeline: collision detection, constraints resolution and
+    /// integration of the rigid-bodies' motion.
+    #[default]
+    Full,
+    /// Only run collision detection with Rapier's `CollisionPipeline`.
+    ///
+    /// Collision events, contact pairs, intersections, physics hooks and scene queries keep
+    /// working, but the dynamics are not simulated: no forces, joints or contact responses are
+    /// applied and rigid-bodies only move when their `Transform` is modified (kinematic
+    /// position-based bodies are teleported to their next kinematic position). Contact force
+    /// events are never emitted in this mode.
+    CollisionOnly,
+}
+
+/// Strategy used to keep the broad-phase BVH efficient as colliders move.
+///
+/// Mirrors Rapier’s [`BvhOptimizationStrategy`](rapier::geometry::BvhOptimizationStrategy).
+#[derive(Copy, Clone, Debug, Default, PartialEq, Eq, Hash, Reflect)]
+#[cfg_attr(feature = "serde-serialize", derive(Serialize, Deserialize))]
+pub enum BroadPhaseOptimizationStrategy {
+    /// Different sub-trees of the BVH are optimized at each step.
+    #[default]
+    SubtreeOptimizer,
+    /// Disables incremental BVH optimization (discouraged, meant for debugging).
+    None,
+}
+
+impl From<BroadPhaseOptimizationStrategy> for rapier::geometry::BvhOptimizationStrategy {
+    fn from(value: BroadPhaseOptimizationStrategy) -> Self {
+        match value {
+            BroadPhaseOptimizationStrategy::SubtreeOptimizer => Self::SubtreeOptimizer,
+            BroadPhaseOptimizationStrategy::None => Self::None,
+        }
+    }
+}
+
+impl From<rapier::geometry::BvhOptimizationStrategy> for BroadPhaseOptimizationStrategy {
+    fn from(value: rapier::geometry::BvhOptimizationStrategy) -> Self {
+        match value {
+            rapier::geometry::BvhOptimizationStrategy::SubtreeOptimizer => Self::SubtreeOptimizer,
+            rapier::geometry::BvhOptimizationStrategy::None => Self::None,
+        }
+    }
+}
+
+#[derive(Component, Copy, Clone, Debug, Reflect)]
+#[cfg_attr(feature = "serde-serialize", derive(Serialize, Deserialize))]
+/// A component for specifying configuration information for the physics simulation
+pub struct RapierConfiguration {
+    /// Specifying the gravity of the physics simulation.
+    pub gravity: Vect,
+    /// Specifies if the physics simulation is active and update the physics world.
+    pub physics_pipeline_active: bool,
+    /// Specifies the number of subdivisions along each axes a shape should be subdivided
+    /// if its scaled representation cannot be represented with the same shape type.
+    ///
+    /// For example, a ball subject to a non-uniform scaling cannot be represented as a ball
+    /// (it’s an ellipsoid). Thus, in order to be compatible with Rapier, the shape is automatically
+    /// discretized into a convex polyhedron, using `scaled_shape_subdivision` as the number of subdivisions
+    /// along each spherical coordinates angle.
+    pub scaled_shape_subdivision: u32,
+    /// Specifies if backend sync should always accept transform changes, which may be from the writeback stage.
+    pub force_update_from_transform_changes: bool,
+    /// Whether this context simulates the full dynamics, or only detects collisions.
+    pub simulation_mode: SimulationMode,
+    /// The number of worker threads of a thread pool dedicated to this context’s simulation.
+    ///
+    /// If `None` (the default), the simulation runs on the thread pool of the calling thread,
+    /// usually Rayon’s global pool. Changes are applied before the next simulation step. This
+    /// is ignored unless the `parallel` feature is enabled (and `unsync-callbacks` is not).
+    pub num_threads: Option<usize>,
+}
+
+impl RapierConfiguration {
+    /// Configures rapier with the specified length unit.
+    ///
+    /// See the documentation of [`IntegrationParameters::length_unit`] for additional details
+    /// on that argument.
+    ///
+    /// The default gravity is automatically scaled by that length unit.
+    pub fn new(length_unit: Real) -> Self {
+        Self {
+            gravity: Vect::Y * -9.81 * length_unit,
+            physics_pipeline_active: true,
+            scaled_shape_subdivision: 10,
+            force_update_from_transform_changes: false,
+            simulation_mode: SimulationMode::Full,
+            num_threads: None,
+        }
+    }
+}
diff --git a/bindings/bevy_rapier/src/plugin/context/mod.rs b/bindings/bevy_rapier/src/plugin/context/mod.rs
new file mode 100644
index 000000000..af938a875
--- /dev/null
+++ b/bindings/bevy_rapier/src/plugin/context/mod.rs
@@ -0,0 +1,2677 @@
+//! These are components used and modified during a simulation frame.
+
+pub mod systemparams;
+
+use bevy::prelude::*;
+use rapier::geometry::{ContactData, ContactManifoldData};
+use rapier::parry::query::{PersistentQueryDispatcher, QueryDispatcher};
+use std::collections::HashMap;
+use std::sync::RwLock;
+
+use rapier::prelude::{
+    Aabb, CCDSolver, ColliderHandle, ColliderSet, CollisionPipeline, EventHandler, FeatureId,
+    ImpulseJointHandle, ImpulseJointSet, IntegrationParameters, IslandManager,
+    MultibodyJointHandle, MultibodyJointSet, NarrowPhase, PhysicsHooks, PhysicsPipeline,
+    QueryFilter as RapierQueryFilter, QueryPipeline, QueryPipelineMut, Ray, Real, RigidBodyHandle,
+    RigidBodySet, RigidBodyType, SoftBodyHandle, SoftBodySet,
+};
+
+use crate::geometry::{
+    AsShape, NonlinearMotion, PointProjection, RayIntersection, ShapeCastHit, ShapeClosestPoints,
+    ShapeContact,
+};
+use crate::math::{Rot, Vect};
+use crate::pipeline::{CollisionEvent, ContactForceEvent, EventHandlerFanOut, EventQueue};
+use bevy::prelude::{Entity, GlobalTransform, Query};
+use rapier::geometry::Collider as RapierCollider;
+use rapier::parry::partitioning::Bvh;
+use rapier::parry::query::ClosestPoints;
+use rapier::parry::shape::CompositeShapeRef;
+
+use crate::control::{CharacterCollision, MoveShapeOptions, MoveShapeOutput};
+use crate::dynamics::{
+    ImpulseJointImpulses, InverseKinematicsOption, MultibodyJointState, RapierSoftBody,
+    RapierSoftBodyTearEvent, TransformInterpolation,
+};
+use crate::parry::query::details::ShapeCastOptions;
+use crate::pipeline::{PhysicsQuarantineEvent, SoftBodyTearResult};
+use crate::plugin::configuration::{BroadPhaseOptimizationStrategy, SimulationMode, TimestepMode};
+use crate::prelude::{CollisionGroups, QueryFilter, RapierRigidBodyHandle};
+use rapier::control::CharacterAutostep;
+use rapier::dynamics::ImpulseJoint as RapierImpulseJoint;
+use rapier::dynamics::{Multibody, MultibodyJoint as RapierMultibodyJoint};
+use rapier::geometry::DefaultBroadPhase;
+use rapier::math::{DVector, Jacobian};
+use std::ops::Range;
+
+#[cfg(doc)]
+use crate::prelude::{
+    systemparams::{RapierContext, ReadRapierContext},
+    ImpulseJoint, KinematicMultibodyJoint, MultibodyJoint, RevoluteJoint, TypedJoint,
+};
+
+/// Difference between simulation and rendering time
+#[derive(Component, Default, Reflect, Clone)]
+pub struct SimulationToRenderTime {
+    /// Difference between simulation and rendering time
+    pub diff: f32,
+}
+
+/// Marker component for to access the default [`ReadRapierContext`].
+///
+/// This is used as the default marker filter for [`systemparams::ReadRapierContext`] and [`systemparams::WriteRapierContext`]
+/// to help with getting a reference to the correct RapierContext.
+///
+/// If you're making a library, you might be interested in [`RapierContextEntityLink`]
+/// and leverage a [`Query`] to have precise access to relevant components (for example [`RapierContextSimulation`]).
+///
+/// See the list of full components in [`RapierContext`]
+#[derive(Component, Reflect, Debug, Clone, Copy)]
+pub struct DefaultRapierContext;
+
+/// This is a component applied to any entity containing a rapier handle component.
+/// The inner Entity referred to has the component [`RapierContextSimulation`]
+/// and others from [`crate::plugin::context`], responsible for handling
+/// its rapier data.
+#[derive(Component, Reflect, Debug, Clone, Copy, PartialEq, Eq, Hash)]
+pub struct RapierContextEntityLink(pub Entity);
+
+/// The set of colliders part of the simulation.
+///
+/// This should be attached on an entity with a [`RapierContextSimulation`]
+///
+/// With the `serde-serialize` feature, the entity-to-handle map isn't serialized: it is rebuilt
+/// from the colliders’ user-data on deserialization (see [`Self::rebuild_entity_maps`]).
+#[cfg_attr(feature = "serde-serialize", derive(Serialize, Deserialize))]
+#[cfg_attr(
+    feature = "serde-serialize",
+    serde(from = "serde_shadows::RapierContextCollidersData")
+)]
+#[derive(Component, Default, Debug, Clone)]
+pub struct RapierContextColliders {
+    /// The set of colliders part of the simulation.
+    pub colliders: ColliderSet,
+    #[cfg_attr(feature = "serde-serialize", serde(skip))]
+    pub(crate) entity2collider: HashMap<Entity, ColliderHandle>,
+}
+
+impl RapierContextColliders {
+    /// Rebuilds the map from entities to collider handles from the user-data of the colliders,
+    /// which contain the bits of their entity.
+    ///
+    /// This is called automatically when deserializing this component. Call it manually after
+    /// replacing [`Self::colliders`] with a set restored in another way.
+    pub fn rebuild_entity_maps(&mut self) {
+        self.entity2collider = self
+            .colliders
+            .iter()
+            .filter_map(|(handle, co)| Some((Entity::try_from_bits(co.user_data as u64)?, handle)))
+            .collect();
+    }
+
+    /// If the collider attached to `entity` is attached to a rigid-body, this
+    /// returns the `Entity` containing that rigid-body.
+    pub fn collider_parent(
+        &self,
+        rigidbody_set: &RapierRigidBodySet,
+        entity: Entity,
+    ) -> Option<Entity> {
+        self.entity2collider
+            .get(&entity)
+            .and_then(|h| self.colliders.get(*h))
+            .and_then(|co| co.parent())
+            .and_then(|h| rigidbody_set.rigid_body_entity(h))
+    }
+
+    /// If entity is a rigid-body, this returns the collider `Entity`s attached
+    /// to that rigid-body.
+    pub fn rigid_body_colliders<'a, 'b: 'a>(
+        &'a self,
+        entity: Entity,
+        rigidbody_set: &'b RapierRigidBodySet,
+    ) -> impl Iterator<Item = Entity> + 'a {
+        rigidbody_set
+            .entity2body()
+            .get(&entity)
+            .and_then(|handle| rigidbody_set.bodies.get(*handle))
+            .map(|body| {
+                body.colliders()
+                    .iter()
+                    .filter_map(|handle| self.collider_entity(*handle))
+            })
+            .into_iter()
+            .flatten()
+    }
+
+    /// Retrieve the Bevy entity the given Rapier collider (identified by its handle) is attached to.
+    pub fn collider_entity(&self, handle: ColliderHandle) -> Option<Entity> {
+        RapierContextColliders::collider_entity_with_set(&self.colliders, handle)
+    }
+
+    // Mostly used to avoid borrowing self completely.
+    pub(crate) fn collider_entity_with_set(
+        colliders: &ColliderSet,
+        handle: ColliderHandle,
+    ) -> Option<Entity> {
+        colliders.get(handle).map(Self::entity_from_collider)
+    }
+
+    /// Retrieve the Bevy entity the given Rapier collider is attached to.
+    pub fn entity_from_collider(collider: &rapier::prelude::Collider) -> Entity {
+        Entity::from_bits(collider.user_data as u64)
+    }
+
+    /// The map from entities to collider handles.
+    pub fn entity2collider(&self) -> &HashMap<Entity, ColliderHandle> {
+        &self.entity2collider
+    }
+
+    /// The Rapier collider attached to the given `entity`, if any.
+    fn collider(&self, entity: Entity) -> Option<&rapier::geometry::Collider> {
+        self.colliders.get(*self.entity2collider.get(&entity)?)
+    }
+
+    /// Computes the world-space axis-aligned bounding box of the collider of `entity`.
+    ///
+    /// This doesn't include the contact skin. Returns `None` if `entity` has no collider.
+    #[cfg(feature = "dim2")]
+    pub fn compute_aabb(&self, entity: Entity) -> Option<bevy::shape::Aabb2d> {
+        Some(aabb_to_bevy(self.collider(entity)?.compute_aabb()))
+    }
+
+    /// Computes the world-space axis-aligned bounding box of the collider of `entity`.
+    ///
+    /// This doesn't include the contact skin. Returns `None` if `entity` has no collider.
+    #[cfg(feature = "dim3")]
+    pub fn compute_aabb(&self, entity: Entity) -> Option<bevy::shape::Aabb3d> {
+        Some(aabb_to_bevy(self.collider(entity)?.compute_aabb()))
+    }
+
+    /// Computes the world-space axis-aligned bounding box swept by the collider of `entity` when
+    /// moving from its current position to `next_position`.
+    ///
+    /// The scale of `next_position` is ignored. Returns `None` if `entity` has no collider.
+    #[cfg(feature = "dim2")]
+    pub fn compute_swept_aabb(
+        &self,
+        entity: Entity,
+        next_position: Transform,
+    ) -> Option<bevy::shape::Aabb2d> {
+        let next_position = crate::utils::transform_to_iso(&next_position);
+        Some(aabb_to_bevy(
+            self.collider(entity)?.compute_swept_aabb(&next_position),
+        ))
+    }
+
+    /// Computes the world-space axis-aligned bounding box swept by the collider of `entity` when
+    /// moving from its current position to `next_position`.
+    ///
+    /// The scale of `next_position` is ignored. Returns `None` if `entity` has no collider.
+    #[cfg(feature = "dim3")]
+    pub fn compute_swept_aabb(
+        &self,
+        entity: Entity,
+        next_position: Transform,
+    ) -> Option<bevy::shape::Aabb3d> {
+        let next_position = crate::utils::transform_to_iso(&next_position);
+        Some(aabb_to_bevy(
+            self.collider(entity)?.compute_swept_aabb(&next_position),
+        ))
+    }
+
+    /// The volume (in 3D) or area (in 2D) of the collider of `entity`.
+    ///
+    /// Returns `None` if `entity` has no collider.
+    pub fn volume(&self, entity: Entity) -> Option<Real> {
+        Some(self.collider(entity)?.volume())
+    }
+
+    /// The mass of the collider of `entity`.
+    ///
+    /// Returns `None` if `entity` has no collider.
+    pub fn mass(&self, entity: Entity) -> Option<Real> {
+        Some(self.collider(entity)?.mass())
+    }
+
+    /// The density of the collider of `entity`.
+    ///
+    /// If the collider's mass was set explicitly, this is the mass divided by the volume. Returns
+    /// `None` if `entity` has no collider.
+    pub fn density(&self, entity: Entity) -> Option<Real> {
+        Some(self.collider(entity)?.density())
+    }
+}
+
+/// Converts a Rapier AABB to a Bevy AABB.
+#[cfg(feature = "dim2")]
+fn aabb_to_bevy(aabb: Aabb) -> bevy::shape::Aabb2d {
+    bevy::shape::Aabb2d {
+        min: aabb.mins,
+        max: aabb.maxs,
+    }
+}
+
+/// Converts a Rapier AABB to a Bevy AABB.
+#[cfg(feature = "dim3")]
+fn aabb_to_bevy(aabb: Aabb) -> bevy::shape::Aabb3d {
+    bevy::shape::Aabb3d {
+        min: aabb.mins.into(),
+        max: aabb.maxs.into(),
+    }
+}
+
+/// The sets of joints part of the simulation.
+///
+/// This should be attached on an entity with a [`RapierContextSimulation`]
+///
+/// With the `serde-serialize` feature, the entity-to-handle maps aren't serialized: they are
+/// rebuilt from the joints’ user-data on deserialization (see [`Self::rebuild_entity_maps`]).
+#[cfg_attr(feature = "serde-serialize", derive(Serialize, Deserialize))]
+#[cfg_attr(
+    feature = "serde-serialize",
+    serde(from = "serde_shadows::RapierContextJointsData")
+)]
+#[derive(Component, Default, Debug, Clone)]
+pub struct RapierContextJoints {
+    /// The set of impulse joints part of the simulation.
+    pub impulse_joints: ImpulseJointSet,
+    /// The set of multibody joints part of the simulation.
+    pub multibody_joints: MultibodyJointSet,
+
+    #[cfg_attr(feature = "serde-serialize", serde(skip))]
+    pub(crate) entity2impulse_joint: HashMap<Entity, ImpulseJointHandle>,
+    #[cfg_attr(feature = "serde-serialize", serde(skip))]
+    pub(crate) entity2multibody_joint: HashMap<Entity, MultibodyJointHandle>,
+}
+
+impl RapierContextJoints {
+    /// Rebuilds the maps from entities to impulse and multibody joint handles from the
+    /// user-data of the joints, which contain the bits of their entity.
+    ///
+    /// This is called automatically when deserializing this component. Call it manually after
+    /// replacing the joint sets with sets restored in another way.
+    pub fn rebuild_entity_maps(&mut self) {
+        self.entity2impulse_joint = self
+            .impulse_joints
+            .iter()
+            .filter_map(|(handle, joint)| {
+                Some((Entity::try_from_bits(joint.data.user_data as u64)?, handle))
+            })
+            .collect();
+        self.entity2multibody_joint = self
+            .multibody_joints
+            .iter()
+            .filter_map(|(handle, _, _, link)| {
+                Some((
+                    Entity::try_from_bits(link.joint().data.user_data as u64)?,
+                    handle,
+                ))
+            })
+            .collect();
+    }
+
+    /// The map from entities to impulse joint handles.
+    pub fn entity2impulse_joint(&self) -> &HashMap<Entity, ImpulseJointHandle> {
+        &self.entity2impulse_joint
+    }
+
+    /// The map from entities to multibody joint handles.
+    pub fn entity2multibody_joint(&self) -> &HashMap<Entity, MultibodyJointHandle> {
+        &self.entity2multibody_joint
+    }
+
+    /// Retrieve the entity containing the [`ImpulseJoint`] component the given Rapier impulse
+    /// joint was created from.
+    pub fn entity_from_impulse_joint(joint: &RapierImpulseJoint) -> Entity {
+        Entity::from_bits(joint.data.user_data as u64)
+    }
+
+    /// Retrieve the entity containing the [`ImpulseJoint`] component of the Rapier impulse joint
+    /// identified by the given handle.
+    pub fn impulse_joint_entity(&self, handle: ImpulseJointHandle) -> Option<Entity> {
+        self.impulse_joints
+            .get(handle)
+            .map(Self::entity_from_impulse_joint)
+    }
+
+    /// The impulses applied during the last simulation step by the [`ImpulseJoint`] of `entity`.
+    ///
+    /// This is the value written back into the [`ImpulseJointImpulses`] component after each
+    /// step. Returns `None` if `entity` has no impulse joint.
+    pub fn impulse_joint_impulses(&self, entity: Entity) -> Option<ImpulseJointImpulses> {
+        let joint = self
+            .impulse_joints
+            .get(*self.entity2impulse_joint.get(&entity)?)?;
+        Some(ImpulseJointImpulses::from_rapier(joint))
+    }
+
+    /// Iterates through the entities of all the impulse joints attaching the rigid-bodies of
+    /// `body1` and `body2` (in any order).
+    pub fn impulse_joints_between<'a>(
+        &'a self,
+        rigidbody_set: &RapierRigidBodySet,
+        body1: Entity,
+        body2: Entity,
+    ) -> impl Iterator<Item = Entity> + 'a {
+        let handles = rigidbody_set
+            .entity2body
+            .get(&body1)
+            .copied()
+            .zip(rigidbody_set.entity2body.get(&body2).copied());
+        handles.into_iter().flat_map(move |(handle1, handle2)| {
+            self.impulse_joints
+                .joints_between(handle1, handle2)
+                .map(|(_, joint)| Self::entity_from_impulse_joint(joint))
+        })
+    }
+
+    /// Iterates through the entities of all the impulse joints attached to the rigid-body of
+    /// `body`, including disabled joints.
+    pub fn attached_impulse_joints<'a>(
+        &'a self,
+        rigidbody_set: &RapierRigidBodySet,
+        body: Entity,
+    ) -> impl Iterator<Item = Entity> + 'a {
+        let handle = rigidbody_set.entity2body.get(&body).copied();
+        handle.into_iter().flat_map(move |handle| {
+            self.impulse_joints
+                .attached_joints(handle)
+                .map(|(_, _, _, joint)| Self::entity_from_impulse_joint(joint))
+        })
+    }
+
+    /// Iterates through the entities of the enabled impulse joints attached to the rigid-body
+    /// of `body`.
+    pub fn attached_enabled_impulse_joints<'a>(
+        &'a self,
+        rigidbody_set: &RapierRigidBodySet,
+        body: Entity,
+    ) -> impl Iterator<Item = Entity> + 'a {
+        let handle = rigidbody_set.entity2body.get(&body).copied();
+        handle.into_iter().flat_map(move |handle| {
+            self.impulse_joints
+                .attached_enabled_joints(handle)
+                .map(|(_, _, _, joint)| Self::entity_from_impulse_joint(joint))
+        })
+    }
+
+    /// Retrieve the entity containing the [`MultibodyJoint`] component the given Rapier
+    /// multibody joint was created from.
+    ///
+    /// This is also the entity of the rigid-body of the link containing this joint.
+    pub fn entity_from_multibody_joint(joint: &RapierMultibodyJoint) -> Entity {
+        Entity::from_bits(joint.data.user_data as u64)
+    }
+
+    /// The multibody containing the rigid-body of `entity`, and the index of the link of that
+    /// rigid-body in the multibody.
+    ///
+    /// The root rigid-body of a multibody is its link `0`. Returns `None` if the rigid-body is not
+    /// attached to any [`MultibodyJoint`].
+    pub fn multibody(
+        &self,
+        rigidbody_set: &RapierRigidBodySet,
+        entity: Entity,
+    ) -> Option<(&Multibody, usize)> {
+        let body = rigidbody_set.entity2body.get(&entity)?;
+        let link = self.multibody_joints.rigid_body_link(*body)?;
+        Some((
+            self.multibody_joints.get_multibody(link.multibody)?,
+            link.id,
+        ))
+    }
+
+    /// The multibody containing the rigid-body of `entity`, and the index of the link of that
+    /// rigid-body in the multibody, for modification.
+    ///
+    /// Note that Rapier doesn’t wake up the multibody automatically after a modification.
+    pub fn multibody_mut(
+        &mut self,
+        rigidbody_set: &RapierRigidBodySet,
+        entity: Entity,
+    ) -> Option<(&mut Multibody, usize)> {
+        let body = rigidbody_set.entity2body.get(&entity)?;
+        let link = *self.multibody_joints.rigid_body_link(*body)?;
+        Some((
+            self.multibody_joints.get_multibody_mut(link.multibody)?,
+            link.id,
+        ))
+    }
+
+    /// The entity of the root rigid-body of the multibody containing the rigid-body of `entity`.
+    pub fn multibody_root(
+        &self,
+        rigidbody_set: &RapierRigidBodySet,
+        entity: Entity,
+    ) -> Option<Entity> {
+        let (mb, _) = self.multibody(rigidbody_set, entity)?;
+        rigidbody_set.rigid_body_entity(mb.root().rigid_body_handle())
+    }
+
+    /// Iterates through the entities of the rigid-bodies of all the links of the multibody
+    /// containing the rigid-body of `entity`.
+    ///
+    /// The root comes first, and each link is yielded before its descendants. All the entities
+    /// except the root contain the [`MultibodyJoint`] attaching them to their parent link: to
+    /// remove all the joints of a multibody (like Rapier’s
+    /// `MultibodyJointSet::remove_multibody_articulations`), remove the [`MultibodyJoint`]
+    /// component from these entities (for example with `.skip(1)`).
+    pub fn multibody_links<'a>(
+        &'a self,
+        rigidbody_set: &'a RapierRigidBodySet,
+        entity: Entity,
+    ) -> impl Iterator<Item = Entity> + 'a {
+        self.multibody(rigidbody_set, entity)
+            .into_iter()
+            .flat_map(move |(mb, _)| {
+                mb.links()
+                    .filter_map(|link| rigidbody_set.rigid_body_entity(link.rigid_body_handle()))
+            })
+    }
+
+    /// The entity of the rigid-body of the parent link of the rigid-body of `entity` in its
+    /// multibody.
+    ///
+    /// Returns `None` if `entity` is the root of its multibody, or isn’t part of any multibody.
+    pub fn multibody_parent_link(
+        &self,
+        rigidbody_set: &RapierRigidBodySet,
+        entity: Entity,
+    ) -> Option<Entity> {
+        let (mb, link_id) = self.multibody(rigidbody_set, entity)?;
+        let parent = mb.link(mb.link(link_id)?.parent_id()?)?;
+        rigidbody_set.rigid_body_entity(parent.rigid_body_handle())
+    }
+
+    /// The entity of the [`MultibodyJoint`] attaching the rigid-bodies of `body1` and `body2`
+    /// (in any order), if any.
+    pub fn multibody_joint_between(
+        &self,
+        rigidbody_set: &RapierRigidBodySet,
+        body1: Entity,
+        body2: Entity,
+    ) -> Option<Entity> {
+        let handle1 = rigidbody_set.entity2body.get(&body1)?;
+        let handle2 = rigidbody_set.entity2body.get(&body2)?;
+        let (_, _, link) = self.multibody_joints.joint_between(*handle1, *handle2)?;
+        rigidbody_set.rigid_body_entity(link.rigid_body_handle())
+    }
+
+    /// Iterates through the entities of all the multibody joints attached to the rigid-body of
+    /// `body`: the joint attaching it to its parent link (if any), and the joints of its child
+    /// links.
+    pub fn attached_multibody_joints<'a>(
+        &'a self,
+        rigidbody_set: &'a RapierRigidBodySet,
+        body: Entity,
+    ) -> impl Iterator<Item = Entity> + 'a {
+        let handle = rigidbody_set.entity2body.get(&body).copied();
+        handle.into_iter().flat_map(move |handle| {
+            self.multibody_joints
+                .attached_joints(handle)
+                .filter_map(|(_, body2, _)| rigidbody_set.rigid_body_entity(body2))
+        })
+    }
+
+    /// The range of the degrees of freedom of the link of `entity` in the generalized
+    /// coordinates, velocities and displacements of its multibody.
+    ///
+    /// The degrees of freedom of a joint are its free axes, in [`JointAxis`] order.
+    ///
+    /// [`JointAxis`]: crate::dynamics::JointAxis
+    pub fn multibody_link_dofs(
+        &self,
+        rigidbody_set: &RapierRigidBodySet,
+        entity: Entity,
+    ) -> Option<Range<usize>> {
+        let (mb, link_id) = self.multibody(rigidbody_set, entity)?;
+        let link = mb.link(link_id)?;
+        let start = link.assembly_id();
+        Some(start..start + link.joint().ndofs())
+    }
+
+    /// The generalized velocities of the multibody containing the rigid-body of `entity`.
+    ///
+    /// See [`Self::multibody_link_dofs`] for the range of each link in this slice.
+    pub fn multibody_generalized_velocity(
+        &self,
+        rigidbody_set: &RapierRigidBodySet,
+        entity: Entity,
+    ) -> Option<&[Real]> {
+        let (mb, _) = self.multibody(rigidbody_set, entity)?;
+        Some(mb.generalized_velocity().data.into_slice())
+    }
+
+    /// The generalized velocities of the multibody containing the rigid-body of `entity`, for
+    /// modification.
+    ///
+    /// This wakes up the rigid-bodies of the multibody.
+    pub fn multibody_generalized_velocity_mut(
+        &mut self,
+        rigidbody_set: &mut RapierRigidBodySet,
+        entity: Entity,
+    ) -> Option<&mut [Real]> {
+        let (mb, _) = self.multibody_mut(rigidbody_set, entity)?;
+        crate::plugin::systems::wake_up_multibody(mb, &mut rigidbody_set.bodies);
+        Some(mb.generalized_velocity_mut().data.into_slice_mut())
+    }
+
+    /// The generalized velocities of the [`MultibodyJoint`] of `entity`, one per free axis in
+    /// [`JointAxis`] order, for modification.
+    ///
+    /// This is typically used to drive a [`KinematicMultibodyJoint`]. This wakes up the
+    /// rigid-bodies of the multibody.
+    ///
+    /// [`JointAxis`]: crate::dynamics::JointAxis
+    pub fn multibody_joint_velocity_mut(
+        &mut self,
+        rigidbody_set: &mut RapierRigidBodySet,
+        entity: Entity,
+    ) -> Option<&mut [Real]> {
+        let handle = *self.entity2multibody_joint.get(&entity)?;
+        let (mb, link_id) = self.multibody_joints.get_mut(handle)?;
+        crate::plugin::systems::wake_up_multibody(mb, &mut rigidbody_set.bodies);
+        let link = mb.link(link_id)?;
+        let range = link.assembly_id()..link.assembly_id() + link.joint().ndofs();
+        Some(&mut mb.generalized_velocity_mut().data.into_slice_mut()[range])
+    }
+
+    /// The state of the [`MultibodyJoint`] of `entity`.
+    ///
+    /// This is the value written back into the [`MultibodyJointState`] component after each
+    /// step.
+    pub fn multibody_joint_state(&self, entity: Entity) -> Option<MultibodyJointState> {
+        self.multibody_joint_state_from_handle(*self.entity2multibody_joint.get(&entity)?)
+    }
+
+    /// The state of the multibody joint with the given handle.
+    pub(crate) fn multibody_joint_state_from_handle(
+        &self,
+        handle: MultibodyJointHandle,
+    ) -> Option<MultibodyJointState> {
+        let (mb, link_id) = self.multibody_joints.get(handle)?;
+        let link = mb.link(link_id)?;
+        Some(MultibodyJointState::from_rapier(
+            link.joint(),
+            mb.joint_velocity(link).as_slice(),
+        ))
+    }
+
+    /// The jacobian of the link of `entity`, mapping the generalized velocities of its multibody
+    /// to the link’s world-space linear and angular velocities.
+    ///
+    /// This is computed by the last forward kinematics (see
+    /// [`Self::multibody_forward_kinematics`]), which runs at each simulation step.
+    pub fn multibody_body_jacobian(
+        &self,
+        rigidbody_set: &RapierRigidBodySet,
+        entity: Entity,
+    ) -> Option<&Jacobian<Real>> {
+        let (mb, link_id) = self.multibody(rigidbody_set, entity)?;
+        Some(mb.body_jacobian(link_id))
+    }
+
+    /// Applies displacements, in generalized coordinates, to the multibody containing the
+    /// rigid-body of `entity`.
+    ///
+    /// `displacements` must contain one value per degree of freedom of the multibody. This only
+    /// modifies the joint coordinates: call [`Self::multibody_forward_kinematics`] to update the
+    /// rigid-bodies. Returns `false` if `entity` isn’t part of a multibody or the number of
+    /// displacements doesn’t match.
+    pub fn multibody_apply_displacements(
+        &mut self,
+        rigidbody_set: &RapierRigidBodySet,
+        entity: Entity,
+        displacements: &[Real],
+    ) -> bool {
+        let Some((mb, _)) = self.multibody_mut(rigidbody_set, entity) else {
+            return false;
+        };
+        if displacements.len() != mb.ndofs() {
+            return false;
+        }
+        mb.apply_displacements(displacements);
+        true
+    }
+
+    /// Runs forward kinematics on the multibody containing the rigid-body of `entity`, and moves
+    /// its rigid-bodies to the resulting poses.
+    ///
+    /// Set `read_root_pose_from_rigid_body` if the root rigid-body was moved and the multibody
+    /// should follow. The `Transform` of the rigid-bodies are updated during the next writeback
+    /// (after the next simulation step). Returns `false` if `entity` isn’t part of a multibody.
+    pub fn multibody_forward_kinematics(
+        &mut self,
+        rigidbody_set: &mut RapierRigidBodySet,
+        entity: Entity,
+        read_root_pose_from_rigid_body: bool,
+    ) -> bool {
+        let Some((mb, _)) = self.multibody_mut(rigidbody_set, entity) else {
+            return false;
+        };
+        mb.forward_kinematics(&rigidbody_set.bodies, read_root_pose_from_rigid_body);
+        mb.update_rigid_bodies(&mut rigidbody_set.bodies, true);
+        true
+    }
+
+    /// Computes the displacements, in generalized coordinates, moving the link of `link` as close
+    /// as possible to the world-space `target` pose, with a jacobian-based inverse kinematics
+    /// solver.
+    ///
+    /// `displacements` is an output buffer: it is cleared and resized to the number of degrees of
+    /// freedom of the multibody (see [`Self::multibody_link_dofs`]), so the solver always starts
+    /// from the current configuration, then filled with the result, which can then be applied with
+    /// [`Self::multibody_apply_displacements`]. The same buffer can be reused across calls without
+    /// resetting it. Only the joints for which `joint_can_move`
+    /// returns `true` are moved; it is called with the entity of each link between the root
+    /// (included) and `link`. Returns `false` if `link` isn’t part of a multibody.
+    pub fn multibody_inverse_kinematics(
+        &self,
+        rigidbody_set: &RapierRigidBodySet,
+        link: Entity,
+        target: Transform,
+        options: &InverseKinematicsOption,
+        joint_can_move: impl Fn(Entity) -> bool,
+        displacements: &mut Vec<Real>,
+    ) -> bool {
+        let Some((mb, link_id)) = self.multibody(rigidbody_set, link) else {
+            return false;
+        };
+        displacements.clear();
+        displacements.resize(mb.ndofs(), 0.0);
+        let mut result = DVector::from_vec(std::mem::take(displacements));
+        mb.inverse_kinematics(
+            &rigidbody_set.bodies,
+            link_id,
+            options,
+            &crate::utils::transform_to_iso(&target),
+            |link| {
+                rigidbody_set
+                    .rigid_body_entity(link.rigid_body_handle())
+                    .is_some_and(&joint_can_move)
+            },
+            &mut result,
+        );
+        *displacements = result.data.into();
+        true
+    }
+}
+
+/// Wrapper around [QueryPipeline] to provide bevy friendly methods.
+///
+/// This wrapper is designed to be short lived, made whenever necessary.
+///
+/// See [RapierQueryPipeline::new_scoped] to create one.
+#[derive(Copy, Clone)]
+pub struct RapierQueryPipeline<'a> {
+    /// The query pipeline, which performs scene queries (ray-casting, point projection, etc.)
+    pub query_pipeline: QueryPipeline<'a>,
+}
+
+/// Wrapper around [QueryPipelineMut] to provide bevy friendly methods.
+///
+/// This wrapper is designed to be short lived, made whenever necessary.
+///
+/// See [RapierQueryPipelineMut::new_scoped] to create one.
+pub struct RapierQueryPipelineMut<'a> {
+    /// The query pipeline, which performs scene queries (ray-casting, point projection, etc.)
+    pub query_pipeline: QueryPipelineMut<'a>,
+}
+impl<'a> RapierQueryPipelineMut<'a> {
+    /// Creates a temporary [RapierQueryPipelineMut] and passes it as a parameter to `scoped_fn`.
+    pub fn new_scoped<T>(
+        broad_phase: &DefaultBroadPhase,
+        colliders: &mut RapierContextColliders,
+        rigid_bodies: &mut RapierRigidBodySet,
+        filter: &QueryFilter<'_>,
+        dispatcher: &dyn QueryDispatcher,
+        scoped_fn: impl FnOnce(RapierQueryPipelineMut<'_>) -> T,
+    ) -> T {
+        let predicate = to_rapier_query_filter_combined_predicate(filter);
+        let rapier_filter =
+            to_rapier_query_filter(filter, colliders, rigid_bodies, predicate.as_ref());
+        let query_pipeline = broad_phase.as_query_pipeline_mut(
+            dispatcher,
+            &mut rigid_bodies.bodies,
+            &mut colliders.colliders,
+            rapier_filter,
+        );
+        scoped_fn(RapierQueryPipelineMut { query_pipeline })
+    }
+
+    /// Downgrades the mutable reference to an immutable reference.
+    pub fn as_ref(&self) -> RapierQueryPipeline<'_> {
+        RapierQueryPipeline {
+            query_pipeline: self.query_pipeline.as_ref(),
+        }
+    }
+}
+
+/// Wraps a [bevy query filter predicate](QueryFilter::predicate) into a [rapier query filter predicate](RapierQueryFilter::predicate).
+pub fn to_rapier_query_filter_predicate(
+    predicate: &dyn Fn(Entity, &RapierCollider) -> bool,
+) -> impl Fn(ColliderHandle, &RapierCollider) -> bool + use<'_> {
+    |_: ColliderHandle, collider: &RapierCollider| -> bool {
+        let entity = RapierContextColliders::entity_from_collider(collider);
+        (predicate)(entity, collider)
+    }
+}
+
+/// Wraps the [`QueryFilter::predicate`] into a Rapier predicate, or returns `None` if it isn’t set.
+fn to_rapier_query_filter_combined_predicate<'b>(
+    filter: &QueryFilter<'b>,
+) -> Option<impl Fn(ColliderHandle, &RapierCollider) -> bool + 'b> {
+    filter.predicate.map(to_rapier_query_filter_predicate)
+}
+
+/// Converts a bevy [`QueryFilter`] into a Rapier query filter using the given Rapier predicate.
+fn to_rapier_query_filter<'b>(
+    filter: &QueryFilter<'_>,
+    colliders: &RapierContextColliders,
+    rigid_bodies: &RapierRigidBodySet,
+    predicate: Option<&'b (impl Fn(ColliderHandle, &RapierCollider) -> bool + 'b)>,
+) -> RapierQueryFilter<'b> {
+    RapierQueryFilter {
+        flags: filter.flags,
+        groups: filter.groups.map(CollisionGroups::into),
+        exclude_collider: filter
+            .exclude_collider
+            .and_then(|c| colliders.entity2collider.get(&c).copied()),
+        exclude_rigid_body: filter
+            .exclude_rigid_body
+            .and_then(|b| rigid_bodies.entity2body.get(&b).copied()),
+        predicate: predicate.map(|p| p as &dyn Fn(ColliderHandle, &RapierCollider) -> bool),
+    }
+}
+
+impl<'a> RapierQueryPipeline<'a> {
+    /// Creates a temporary [RapierQueryPipeline] and passes it as a parameter to `scoped_fn`.
+    pub fn new_scoped<T>(
+        broad_phase: &DefaultBroadPhase,
+        colliders: &RapierContextColliders,
+        rigid_bodies: &RapierRigidBodySet,
+        filter: &QueryFilter<'_>,
+        dispatcher: &dyn QueryDispatcher,
+        scoped_fn: impl FnOnce(RapierQueryPipeline<'_>) -> T,
+    ) -> T {
+        let predicate = to_rapier_query_filter_combined_predicate(filter);
+        let rapier_filter =
+            to_rapier_query_filter(filter, colliders, rigid_bodies, predicate.as_ref());
+        let query_pipeline = broad_phase.as_query_pipeline(
+            dispatcher,
+            &rigid_bodies.bodies,
+            &colliders.colliders,
+            rapier_filter,
+        );
+        scoped_fn(RapierQueryPipeline { query_pipeline })
+    }
+
+    /// Retrieves the Entity for a given collider handle.
+    pub fn collider_entity(&self, collider_handle: ColliderHandle) -> Entity {
+        RapierContextColliders::collider_entity_with_set(
+            self.query_pipeline.colliders,
+            collider_handle,
+        )
+        .unwrap()
+    }
+
+    /// Find the closest intersection between a ray and a set of collider.
+    ///
+    /// # Parameters
+    /// * `ray_origin`: the starting point of the ray to cast.
+    /// * `ray_dir`: the direction of the ray to cast.
+    /// * `max_toi`: the maximum time-of-impact that can be reported by this cast. This effectively
+    ///   limits the length of the ray to `ray.dir.norm() * max_toi`. Use `Real::MAX` for an unbounded ray.
+    /// * `solid`: if this is `true` an impact at time 0.0 (i.e. at the ray origin) is returned if
+    ///   it starts inside of a shape. If this `false` then the ray will hit the shape's boundary
+    ///   even if its starts inside of it.
+    pub fn cast_ray(
+        &self,
+        ray_origin: Vect,
+        ray_dir: Vect,
+        max_toi: Real,
+        solid: bool,
+    ) -> Option<(Entity, Real)> {
+        let ray = Ray::new(ray_origin, ray_dir);
+
+        let (h, toi) = self.query_pipeline.cast_ray(&ray, max_toi, solid)?;
+
+        Some((self.collider_entity(h), toi))
+    }
+
+    /// Find the closest intersection between a ray and a set of collider.
+    ///
+    /// # Parameters
+    /// * `ray_origin`: the starting point of the ray to cast.
+    /// * `ray_dir`: the direction of the ray to cast.
+    /// * `max_toi`: the maximum time-of-impact that can be reported by this cast. This effectively
+    ///   limits the length of the ray to `ray.dir.norm() * max_toi`. Use `Real::MAX` for an unbounded ray.
+    /// * `solid`: if this is `true` an impact at time 0.0 (i.e. at the ray origin) is returned if
+    ///   it starts inside of a shape. If this `false` then the ray will hit the shape's boundary
+    ///   even if its starts inside of it.
+    pub fn cast_ray_and_get_normal(
+        &self,
+        ray_origin: Vect,
+        ray_dir: Vect,
+        max_toi: Real,
+        solid: bool,
+    ) -> Option<(Entity, RayIntersection)> {
+        let ray = Ray::new(ray_origin, ray_dir);
+
+        let (h, result) = self
+            .query_pipeline
+            .cast_ray_and_get_normal(&ray, max_toi, solid)?;
+
+        Some((
+            self.collider_entity(h),
+            RayIntersection::from_rapier(result, ray_origin, ray_dir),
+        ))
+    }
+
+    /// Iterates through all the colliders intersecting a given ray, alongside their Rapier collider.
+    ///
+    /// # Parameters
+    /// * `ray_origin`: the starting point of the ray to cast.
+    /// * `ray_dir`: the direction of the ray to cast.
+    /// * `max_toi`: the maximum time-of-impact that can be reported by this cast. This effectively
+    ///   limits the length of the ray to `ray.dir.norm() * max_toi`. Use `Real::MAX` for an unbounded ray.
+    /// * `solid`: if this is `true` an impact at time 0.0 (i.e. at the ray origin) is returned if
+    ///   it starts inside of a shape. If this `false` then the ray will hit the shape's boundary
+    ///   even if its starts inside of it.
+    pub fn intersect_ray(
+        &'a self,
+        ray_origin: Vect,
+        ray_dir: Vect,
+        max_toi: Real,
+        solid: bool,
+    ) -> impl Iterator<Item = (Entity, &'a RapierCollider, RayIntersection)> + 'a {
+        let ray = Ray::new(ray_origin, ray_dir);
+
+        self.query_pipeline.intersect_ray(ray, max_toi, solid).map(
+            move |(_, collider, intersection)| {
+                (
+                    RapierContextColliders::entity_from_collider(collider),
+                    collider,
+                    RayIntersection::from_rapier(intersection, ray_origin, ray_dir),
+                )
+            },
+        )
+    }
+
+    /// Retrieve all the colliders intersecting the given shape, alongside their Rapier collider.
+    ///
+    /// # Parameters
+    /// * `shape_pos` - The position of the shape used for the intersection test.
+    /// * `shape_rot` - The orientation of the shape used for the intersection test.
+    /// * `shape` - The shape used for the intersection test.
+    pub fn intersect_shape(
+        &'a self,
+        shape_pos: Vect,
+        shape_rot: Rot,
+        shape: &'a (impl AsShape + ?Sized + 'a),
+    ) -> impl Iterator<Item = (Entity, &'a RapierCollider)> + 'a {
+        let shape = shape.as_shape();
+        let scaled_transform = crate::utils::pose_from(shape_pos, shape_rot);
+
+        self.query_pipeline
+            .intersect_shape(scaled_transform, shape)
+            .map(|(_, collider)| {
+                (
+                    RapierContextColliders::entity_from_collider(collider),
+                    collider,
+                )
+            })
+    }
+
+    /// Find the projection of a point on the closest collider.
+    ///
+    /// # Parameters
+    /// * `point` - The point to project.
+    /// * `max_dist` - The maximum distance between the point and its projection. Colliders
+    ///   further than this distance are ignored.
+    /// * `solid` - If this is set to `true` then the collider shapes are considered to
+    ///   be plain (if the point is located inside of a plain shape, its projection is the point
+    ///   itself). If it is set to `false` the collider shapes are considered to be hollow
+    ///   (if the point is located inside of an hollow shape, it is projected on the shape's
+    ///   boundary).
+    pub fn project_point(
+        &self,
+        point: Vect,
+        max_dist: Real,
+        solid: bool,
+    ) -> Option<(Entity, PointProjection)> {
+        let (h, result) = self.query_pipeline.project_point(point, max_dist, solid)?;
+
+        Some((
+            self.collider_entity(h),
+            PointProjection::from_rapier(result),
+        ))
+    }
+
+    /// Find all the colliders containing the given point, alongside their Rapier collider.
+    ///
+    /// # Parameters
+    /// * `point` - The point used for the containment test.
+    pub fn intersect_point(
+        &'a self,
+        point: Vect,
+    ) -> impl Iterator<Item = (Entity, &'a RapierCollider)> + 'a {
+        self.query_pipeline
+            .intersect_point(point)
+            .map(|(_, collider)| {
+                (
+                    RapierContextColliders::entity_from_collider(collider),
+                    collider,
+                )
+            })
+    }
+
+    /// Find the projection of a point on the boundary of the closest collider.
+    ///
+    /// The results include the ID of the feature hit by the point.
+    ///
+    /// # Parameters
+    /// * `point` - The point to project.
+    /// * `max_dist` - The maximum distance between the point and its projection. Colliders
+    ///   further than this distance are ignored. Use `Real::MAX` for an unbounded search.
+    pub fn project_point_and_get_feature(
+        &self,
+        point: Vect,
+        max_dist: Real,
+    ) -> Option<(Entity, PointProjection, FeatureId)> {
+        let (h, proj, fid) = self
+            .query_pipeline
+            .project_point_and_get_feature(point, max_dist)?;
+
+        Some((
+            self.collider_entity(h),
+            PointProjection::from_rapier(proj),
+            fid,
+        ))
+    }
+
+    /// Finds all the colliders with an [`Aabb`] intersecting the given [`Aabb`], alongside their
+    /// Rapier collider.
+    ///
+    /// Note that the collider AABB taken into account is the one currently stored in the query
+    /// pipeline’s BVH. It doesn’t recompute the latest collider AABB.
+    pub fn intersect_aabb_conservative(
+        &'a self,
+        #[cfg(feature = "dim2")] aabb: bevy::shape::Aabb2d,
+        #[cfg(feature = "dim3")] aabb: bevy::shape::Aabb3d,
+    ) -> impl Iterator<Item = (Entity, &'a RapierCollider)> + 'a {
+        #[cfg(feature = "dim2")]
+        let scaled_aabb = Aabb {
+            mins: aabb.min,
+            maxs: aabb.max,
+        };
+        #[cfg(feature = "dim3")]
+        let scaled_aabb = Aabb {
+            mins: aabb.min.into(),
+            maxs: aabb.max.into(),
+        };
+        self.query_pipeline
+            .intersect_aabb_conservative(scaled_aabb)
+            .map(|(_, collider)| {
+                (
+                    RapierContextColliders::entity_from_collider(collider),
+                    collider,
+                )
+            })
+    }
+
+    /// Casts a shape at a constant linear velocity and retrieve the first collider it hits.
+    ///
+    /// This is similar to ray-casting except that we are casting a whole shape instead of just a
+    /// point (the ray origin). In the resulting `ShapeCastHit`, witness and normal 1 refer to the
+    /// collider hit and are in world-space, while witness and normal 2 refer to the cast shape and
+    /// are in its local-space (see [`ShapeCastHitDetails`](crate::geometry::ShapeCastHitDetails)).
+    ///
+    /// # Parameters
+    /// * `shape_pos` - The initial translation of the shape to cast.
+    /// * `shape_rot` - The rotation of the shape to cast.
+    /// * `shape_vel` - The constant velocity of the shape to cast (i.e. the cast direction).
+    /// * `shape` - The shape to cast.
+    /// * `max_toi` - The maximum time-of-impact that can be reported by this cast. This effectively
+    ///   limits the distance traveled by the shape to `shape_vel.norm() * maxToi`.
+    /// * `stop_at_penetration` - If the casted shape starts in a penetration state with any
+    ///   collider, two results are possible. If `stop_at_penetration` is `true` then, the
+    ///   result will have a `toi` equal to `start_time`. If `stop_at_penetration` is `false`
+    ///   then the nonlinear shape-casting will see if further motion wrt. the penetration normal
+    ///   would result in tunnelling. If it does not (i.e. we have a separating velocity along
+    ///   that normal) then the nonlinear shape-casting will attempt to find another impact,
+    ///   at a time `> start_time` that could result in tunnelling.
+    #[allow(clippy::too_many_arguments)]
+    pub fn cast_shape(
+        &'a self,
+        shape_pos: Vect,
+        shape_rot: Rot,
+        shape_vel: Vect,
+        shape: &(impl AsShape + ?Sized),
+        options: ShapeCastOptions,
+    ) -> Option<(Entity, ShapeCastHit)> {
+        let shape = shape.as_shape();
+        let scaled_transform = crate::utils::pose_from(shape_pos, shape_rot);
+
+        let (h, result) =
+            self.query_pipeline
+                .cast_shape(&scaled_transform, shape_vel, shape, options)?;
+
+        Some((
+            self.collider_entity(h),
+            ShapeCastHit::from_rapier(result, options.compute_impact_geometry_on_penetration),
+        ))
+    }
+
+    /// Casts a shape with an arbitrary continuous motion and retrieve the first collider it hits.
+    ///
+    /// In the resulting `ShapeCastHit`, witness and normal 1 refer to the collider hit and are in
+    /// world-space, while witness and normal 2 refer to the cast shape and are in its local-space.
+    ///
+    /// # Parameters
+    /// * `shape_motion` - The motion of the shape.
+    /// * `shape` - The shape to cast.
+    /// * `start_time` - The starting time of the interval where the motion takes place.
+    /// * `end_time` - The end time of the interval where the motion takes place.
+    /// * `stop_at_penetration` - If the casted shape starts in a penetration state with any
+    ///   collider, two results are possible. If `stop_at_penetration` is `true` then, the
+    ///   result will have a `toi` equal to `start_time`. If `stop_at_penetration` is `false`
+    ///   then the nonlinear shape-casting will see if further motion wrt. the penetration normal
+    ///   would result in tunnelling. If it does not (i.e. we have a separating velocity along
+    ///   that normal) then the nonlinear shape-casting will attempt to find another impact,
+    ///   at a time `> start_time` that could result in tunnelling.
+    pub fn cast_shape_nonlinear(
+        &self,
+        shape_motion: &NonlinearMotion,
+        shape: &(impl AsShape + ?Sized),
+        start_time: Real,
+        end_time: Real,
+        stop_at_penetration: bool,
+    ) -> Option<(Entity, ShapeCastHit)> {
+        let shape = shape.as_shape();
+        let (h, result) = self.query_pipeline.cast_shape_nonlinear(
+            &shape_motion.into_rapier(),
+            shape,
+            start_time,
+            end_time,
+            stop_at_penetration,
+        )?;
+
+        Some((
+            self.collider_entity(h),
+            ShapeCastHit::from_rapier(result, false),
+        ))
+    }
+
+    /// Computes the smallest distance between the given shape and the closest collider.
+    ///
+    /// Returns the entity of the closest collider alongside that distance, which is `0.0` if they
+    /// are intersecting. Returns `None` if no collider passes the query filter.
+    ///
+    /// # Parameters
+    /// * `shape_pos` - The translation of the shape.
+    /// * `shape_rot` - The rotation of the shape.
+    /// * `shape` - The shape to compute the distance from.
+    pub fn distance_to_shape(
+        &self,
+        shape_pos: Vect,
+        shape_rot: Rot,
+        shape: &(impl AsShape + ?Sized),
+    ) -> Option<(Entity, Real)> {
+        let shape = shape.as_shape();
+        let pose = crate::utils::pose_from(shape_pos, shape_rot);
+        let (id, dist) = CompositeShapeRef(&self.query_pipeline).distance_to_shape(
+            self.query_pipeline.dispatcher,
+            &pose,
+            shape,
+        )?;
+        Some((self.collider_entity_from_id(id)?, dist.distance))
+    }
+
+    /// Computes the closest points between the given shape and the closest collider.
+    ///
+    /// Returns the entity of the closest collider alongside the closest points. In
+    /// [`ShapeClosestPoints::WithinMargin`], the first point is on the collider and the second
+    /// point is on `shape`, both in world-space. Returns `None` if no collider lies within
+    /// `max_dist` of `shape`.
+    ///
+    /// # Parameters
+    /// * `shape_pos` - The translation of the shape.
+    /// * `shape_rot` - The rotation of the shape.
+    /// * `shape` - The shape to compute the closest points from.
+    /// * `max_dist` - Colliders further than this distance from `shape` are ignored.
+    pub fn closest_points_to_shape(
+        &self,
+        shape_pos: Vect,
+        shape_rot: Rot,
+        shape: &(impl AsShape + ?Sized),
+        max_dist: Real,
+    ) -> Option<(Entity, ShapeClosestPoints)> {
+        let shape = shape.as_shape();
+        let pose = crate::utils::pose_from(shape_pos, shape_rot);
+        let (id, mut pts) = CompositeShapeRef(&self.query_pipeline).closest_points_to_shape(
+            self.query_pipeline.dispatcher,
+            &pose,
+            shape,
+            max_dist,
+        )?;
+        match &mut pts {
+            ClosestPoints::Disjoint => return None,
+            ClosestPoints::Intersecting => {}
+            // The first point is already in world-space, the second one is local to `shape`.
+            ClosestPoints::WithinMargin(_, p2) => *p2 = pose * *p2,
+        }
+        Some((
+            self.collider_entity_from_id(id)?,
+            ShapeClosestPoints::from_rapier(pts),
+        ))
+    }
+
+    /// Computes the contact between the given shape and the closest (or deepest penetrating)
+    /// collider.
+    ///
+    /// Returns the entity of that collider alongside the contact, where the first shape is the
+    /// collider and the second shape is `shape`; contact points and normals are in world-space.
+    /// Returns `None` if no collider lies within `prediction` of `shape`.
+    ///
+    /// # Parameters
+    /// * `shape_pos` - The translation of the shape.
+    /// * `shape_rot` - The rotation of the shape.
+    /// * `shape` - The shape to compute the contact with.
+    /// * `prediction` - Colliders further than this distance from `shape` are ignored.
+    pub fn contact_with_shape(
+        &self,
+        shape_pos: Vect,
+        shape_rot: Rot,
+        shape: &(impl AsShape + ?Sized),
+        prediction: Real,
+    ) -> Option<(Entity, ShapeContact)> {
+        let shape = shape.as_shape();
+        let pose = crate::utils::pose_from(shape_pos, shape_rot);
+        let (id, mut contact) = CompositeShapeRef(&self.query_pipeline).contact_with_shape(
+            self.query_pipeline.dispatcher,
+            &pose,
+            shape,
+            prediction,
+        )?;
+        // The first point and normal are already in world-space, the second ones are local to `shape`.
+        contact.point2 = pose * contact.point2;
+        contact.normal2 = pose.rotation * contact.normal2;
+        Some((
+            self.collider_entity_from_id(id)?,
+            ShapeContact::from_rapier(contact),
+        ))
+    }
+
+    /// The bounding volume hierarchy containing the world-space AABB of every collider.
+    ///
+    /// This can be used for custom scene traversals. Each leaf index identifies a collider and
+    /// can be resolved with [`Self::bvh_leaf_collider`]. Note that the BVH itself ignores the
+    /// query filter.
+    pub fn bvh(&self) -> &'a Bvh {
+        self.query_pipeline.bvh
+    }
+
+    /// Retrieves the entity and Rapier collider identified by a leaf index of [`Self::bvh`].
+    ///
+    /// Returns `None` if the collider doesn't exist or is rejected by the query filter.
+    pub fn bvh_leaf_collider(&self, leaf: u32) -> Option<(Entity, &'a RapierCollider)> {
+        let (collider, handle) = self.query_pipeline.colliders.get_unknown_gen(leaf)?;
+        self.query_pipeline
+            .filter
+            .test(self.query_pipeline.bodies, handle, collider)
+            .then(|| {
+                (
+                    RapierContextColliders::entity_from_collider(collider),
+                    collider,
+                )
+            })
+    }
+
+    /// Retrieves the Entity of the collider identified by a sub-shape id of the query pipeline.
+    fn collider_entity_from_id(&self, id: u32) -> Option<Entity> {
+        self.query_pipeline
+            .colliders
+            .get_unknown_gen(id)
+            .map(|(collider, _)| RapierContextColliders::entity_from_collider(collider))
+    }
+}
+
+/// The set of rigid-bodies part of the simulation.
+///
+/// This should be attached on an entity with a [`RapierContextSimulation`]
+///
+/// With the `serde-serialize` feature, the entity-to-handle map isn't serialized: it is rebuilt
+/// from the rigid-bodies’ user-data on deserialization (see [`Self::rebuild_entity_maps`]).
+#[cfg_attr(feature = "serde-serialize", derive(Serialize, Deserialize))]
+#[cfg_attr(
+    feature = "serde-serialize",
+    serde(from = "serde_shadows::RapierRigidBodySetData")
+)]
+#[derive(Component, Default, Clone)]
+pub struct RapierRigidBodySet {
+    /// The set of rigid-bodies part of the simulation.
+    pub bodies: RigidBodySet,
+    /// The set of soft-bodies part of the simulation.
+    pub soft_bodies: SoftBodySet,
+    /// NOTE: this map is needed to handle despawning.
+    #[cfg_attr(feature = "serde-serialize", serde(skip))]
+    pub(crate) entity2body: HashMap<Entity, RigidBodyHandle>,
+    /// NOTE: this map is needed to handle despawning.
+    #[cfg_attr(feature = "serde-serialize", serde(skip))]
+    pub(crate) entity2soft_body: HashMap<Entity, SoftBodyHandle>,
+
+    /// For transform change detection.
+    #[cfg_attr(feature = "serde-serialize", serde(skip))]
+    pub(crate) last_body_transform_set: HashMap<RigidBodyHandle, GlobalTransform>,
+}
+
+impl RapierRigidBodySet {
+    /// Rebuilds the map from entities to rigid-body handles from the user-data of the
+    /// rigid-bodies, which contain the bits of their entity.
+    ///
+    /// This is called automatically when deserializing this component. Call it manually after
+    /// replacing [`Self::bodies`] with a set restored in another way. The transform change
+    /// detection state is reset, so the next [`GlobalTransform`] change of a rigid-body entity
+    /// is applied to its rigid-body.
+    ///
+    /// The soft-body map is rebuilt from the soft bodies' user-data too. The hidden proxy
+    /// rigid-bodies of the soft bodies are not mapped, except the proxies of the clusters that
+    /// have their own entity (see [`SoftBodyCluster`](crate::dynamics::SoftBodyCluster)) and the
+    /// whole-body proxy of each soft body (see [`Self::soft_body_whole_proxy`]).
+    pub fn rebuild_entity_maps(&mut self) {
+        let soft_bodies = &self.soft_bodies;
+        self.entity2body = self
+            .bodies
+            .iter()
+            .filter(|(_, rb)| {
+                // A proxy with the user-data of its soft body stands for the soft body entity.
+                rb.soft_body()
+                    .and_then(|h| soft_bodies.get(h))
+                    .is_none_or(|sb| sb.user_data != rb.user_data)
+            })
+            .filter_map(|(handle, rb)| Some((Entity::try_from_bits(rb.user_data as u64)?, handle)))
+            .collect();
+        self.entity2soft_body = self
+            .soft_bodies
+            .iter()
+            .filter_map(|(handle, sb)| Some((Entity::try_from_bits(sb.user_data as u64)?, handle)))
+            .collect();
+        let soft_bodies: Vec<_> = self
+            .entity2soft_body
+            .iter()
+            .map(|(entity, handle)| (*entity, *handle))
+            .collect();
+        for (entity, handle) in soft_bodies {
+            self.map_soft_body_whole_proxy(entity, handle);
+        }
+        self.last_body_transform_set.clear();
+    }
+
+    /// Maps `entity` to the whole-body proxy of its soft body `handle` (or unmaps it if the soft
+    /// body has none).
+    pub(crate) fn map_soft_body_whole_proxy(&mut self, entity: Entity, handle: SoftBodyHandle) {
+        match self.whole_proxy(entity, handle) {
+            Some(proxy) => {
+                self.entity2body.insert(entity, proxy);
+            }
+            None => {
+                self.entity2body.remove(&entity);
+            }
+        }
+    }
+
+    /// The whole-body proxy of the soft body `handle` standing for `entity`: its root body, or
+    /// else the proxy of a cluster covering all its particles.
+    fn whole_proxy(&self, entity: Entity, handle: SoftBodyHandle) -> Option<RigidBodyHandle> {
+        let sb = self.soft_bodies.get(handle)?;
+        let bits = entity.to_bits() as u128;
+        let stands_for_entity = |proxy: RigidBodyHandle| {
+            self.bodies
+                .get(proxy)
+                .is_some_and(|rb| rb.user_data == bits)
+        };
+        let root = sb.root_body();
+        if stands_for_entity(root) {
+            return Some(root);
+        }
+        sb.live_clusters()
+            .map(|(_, cluster)| cluster)
+            .find(|cluster| {
+                cluster.particles().len() == sb.num_particles()
+                    && stands_for_entity(cluster.proxy())
+            })
+            .map(|cluster| cluster.proxy())
+    }
+
+    /// Moves the Rapier objects of the new soft body `handle` (split off another one by a tear) to
+    /// `entity`: the user-data of the soft body and of its proxies and colliders standing for the
+    /// soft body it was split from.
+    pub(crate) fn map_soft_body_piece(
+        &mut self,
+        colliders: &mut RapierContextColliders,
+        handle: SoftBodyHandle,
+        entity: Entity,
+    ) {
+        let new_bits = entity.to_bits() as u128;
+        let Some(sb) = self.soft_bodies.get_mut(handle) else {
+            return;
+        };
+        let old_bits = sb.user_data;
+        sb.user_data = new_bits;
+        for (_, cluster) in sb.live_clusters() {
+            let Some(rb) = self.bodies.get_mut(cluster.proxy()) else {
+                continue;
+            };
+            if rb.user_data == old_bits {
+                rb.user_data = new_bits;
+            }
+            for co_handle in rb.colliders() {
+                if let Some(co) = colliders.colliders.get_mut(*co_handle) {
+                    if co.user_data == old_bits {
+                        co.user_data = new_bits;
+                    }
+                }
+            }
+        }
+        self.entity2soft_body.insert(entity, handle);
+    }
+
+    /// Maps the soft body entity to the collider of the soft body's collision mesh.
+    pub(crate) fn map_soft_body_collision_mesh(
+        &self,
+        colliders: &mut RapierContextColliders,
+        handle: SoftBodyHandle,
+        entity: Entity,
+    ) {
+        match self
+            .soft_bodies
+            .get(handle)
+            .and_then(|sb| sb.collision_mesh())
+        {
+            Some(mesh) => {
+                colliders.entity2collider.insert(entity, mesh.collider());
+            }
+            None => {
+                colliders.entity2collider.remove(&entity);
+            }
+        }
+    }
+
+    /// The colliders standing for the soft body of `entity`: the colliders of its collision
+    /// meshes (or of its particles), attached to its proxies and reporting `entity` as their
+    /// entity. The colliders attached by the user to its proxies (e.g. [`DeformableCollider`]s or
+    /// children colliders) are not included.
+    ///
+    /// Returns `None` if `entity` has no soft body.
+    ///
+    /// [`DeformableCollider`]: crate::dynamics::DeformableCollider
+    pub fn soft_body_colliders(
+        &self,
+        colliders: &ColliderSet,
+        entity: Entity,
+    ) -> Option<Vec<ColliderHandle>> {
+        let sb = self.soft_body(entity)?;
+        let bits = entity.to_bits() as u128;
+        let mut result = vec![];
+        for (_, cluster) in sb.live_clusters() {
+            let Some(rb) = self.bodies.get(cluster.proxy()) else {
+                continue;
+            };
+            result.extend(
+                rb.colliders()
+                    .iter()
+                    .copied()
+                    .filter(|h| colliders.get(*h).is_some_and(|co| co.user_data == bits)),
+            );
+        }
+        Some(result)
+    }
+
+    /// The map from entities to soft-body handles.
+    pub fn entity2soft_body(&self) -> &HashMap<Entity, SoftBodyHandle> {
+        &self.entity2soft_body
+    }
+
+    /// Retrieve the Bevy entity of the given Rapier soft body (identified by its handle).
+    pub fn soft_body_entity(&self, handle: SoftBodyHandle) -> Option<Entity> {
+        let entity = Entity::try_from_bits(self.soft_bodies.get(handle)?.user_data as u64)?;
+        (self.entity2soft_body.get(&entity) == Some(&handle)).then_some(entity)
+    }
+
+    /// The Rapier soft body attached to the given `entity`, if any.
+    pub fn soft_body(&self, entity: Entity) -> Option<&RapierSoftBody> {
+        self.soft_bodies.get(*self.entity2soft_body.get(&entity)?)
+    }
+
+    /// The Rapier soft body attached to the given `entity`, if any.
+    ///
+    /// This gives access to every setter of the soft body (particle positions, velocities and
+    /// kinematic targets, pinning, forces, impulses, clusters...). Prefer the soft-body components
+    /// (e.g. [`SoftBodyMaterial`](crate::dynamics::SoftBodyMaterial)) for the properties they
+    /// cover, since they are applied again whenever they change.
+    pub fn soft_body_mut(&mut self, entity: Entity) -> Option<&mut RapierSoftBody> {
+        self.soft_bodies
+            .get_mut(*self.entity2soft_body.get(&entity)?)
+    }
+
+    /// The world-space positions of the particles of the soft body of `entity`.
+    ///
+    /// Returns `None` if `entity` has no soft body.
+    pub fn soft_body_particle_positions(
+        &self,
+        entity: Entity,
+    ) -> Option<impl ExactSizeIterator<Item = Vect> + '_> {
+        Some(self.soft_body(entity)?.particle_positions())
+    }
+
+    /// The world-space velocities of the particles of the soft body of `entity`.
+    ///
+    /// Returns `None` if `entity` has no soft body.
+    pub fn soft_body_particle_velocities(
+        &self,
+        entity: Entity,
+    ) -> Option<impl ExactSizeIterator<Item = Vect> + '_> {
+        Some(self.soft_body(entity)?.particle_velocities())
+    }
+
+    /// The area (2D) or volume (3D) currently enclosed by the soft body of `entity` (`0.0` for a
+    /// soft body without closed boundary).
+    ///
+    /// Returns `None` if `entity` has no soft body.
+    pub fn soft_body_volume(&self, entity: Entity) -> Option<Real> {
+        Some(self.soft_body(entity)?.volume())
+    }
+
+    /// The total mass of the particles of the soft body of `entity`.
+    ///
+    /// Returns `None` if `entity` has no soft body.
+    pub fn soft_body_mass(&self, entity: Entity) -> Option<Real> {
+        Some(self.soft_body(entity)?.mass())
+    }
+
+    /// The world-space, mass-weighted, center of the particles of the soft body of `entity`.
+    ///
+    /// Returns `None` if `entity` has no soft body.
+    pub fn soft_body_center_of_mass(&self, entity: Entity) -> Option<Vect> {
+        Some(self.soft_body(entity)?.center_of_mass())
+    }
+
+    /// Whether the soft body of `entity` is sleeping.
+    ///
+    /// Returns `None` if `entity` has no soft body.
+    pub fn is_soft_body_sleeping(&self, entity: Entity) -> Option<bool> {
+        Some(self.soft_body(entity)?.is_sleeping())
+    }
+
+    /// Wakes up the soft body of `entity` (effective at the start of the next step, together
+    /// with the island of the bodies it touches).
+    ///
+    /// Returns `false` if `entity` has no soft body.
+    pub fn wake_up_soft_body(&mut self, entity: Entity, strong: bool) -> bool {
+        let Some(handle) = self.entity2soft_body.get(&entity).copied() else {
+            return false;
+        };
+        self.soft_bodies.wake_up(handle, &mut self.bodies, strong);
+        true
+    }
+
+    /// The proxy rigid-body of the cluster `cluster` of the soft body of `entity`.
+    ///
+    /// The cluster `0` is the whole-body cluster created with the soft body. Returns `None` if
+    /// `entity` has no soft body or if that cluster doesn't exist.
+    pub fn soft_body_cluster_proxy(&self, entity: Entity, cluster: u32) -> Option<RigidBodyHandle> {
+        self.soft_body(entity)?.cluster_proxy(cluster)
+    }
+
+    /// The whole-body proxy rigid-body of the soft body of `entity`: the proxy of its cluster
+    /// covering all its particles, which `entity` is mapped to in [`Self::entity2body`].
+    ///
+    /// This lets the soft body entity be used like a rigid-body entity by impulse joints (as
+    /// their `parent`, or on the soft body entity itself). Returns `None` if `entity` has no soft
+    /// body.
+    pub fn soft_body_whole_proxy(&self, entity: Entity) -> Option<RigidBodyHandle> {
+        self.whole_proxy(entity, *self.entity2soft_body.get(&entity)?)
+    }
+
+    /// The soft body and the index of the cluster standing for `entity`: a
+    /// [`SoftBodyCluster`](crate::dynamics::SoftBodyCluster) entity, or a soft body entity (for
+    /// its whole-body cluster).
+    ///
+    /// The index can be given to the cluster methods of [`RapierSoftBody`] (e.g.
+    /// [`RapierSoftBody::set_cluster_pinned`]). It may change when the soft body tears, so it
+    /// should not be stored. Returns `None` if `entity` doesn't stand for a live cluster.
+    pub fn soft_body_cluster_index(&self, entity: Entity) -> Option<(SoftBodyHandle, u32)> {
+        let proxy = *self.entity2body.get(&entity)?;
+        let handle = self.bodies.get(proxy)?.soft_body()?;
+        let sb = self.soft_bodies.get(handle)?;
+        let index = self
+            .bodies
+            .get(proxy)?
+            .soft_cluster()
+            .filter(|i| sb.cluster_proxy(*i) == Some(proxy))
+            .or_else(|| {
+                sb.live_clusters()
+                    .find(|(_, cluster)| cluster.proxy() == proxy)
+                    .map(|(i, _)| i)
+            })?;
+        Some((handle, index))
+    }
+
+    /// The map from entities to rigid-body handles.
+    pub fn entity2body(&self) -> &HashMap<Entity, RigidBodyHandle> {
+        &self.entity2body
+    }
+
+    /// Retrieve the Bevy entity the given Rapier rigid-body (identified by its handle) is attached.
+    pub fn rigid_body_entity(&self, handle: RigidBodyHandle) -> Option<Entity> {
+        self.bodies
+            .get(handle)
+            .map(|c| Entity::from_bits(c.user_data as u64))
+    }
+
+    /// This method makes sure that the rigid-body positions have been propagated to
+    /// their attached colliders, without having to perform a simulation step.
+    pub fn propagate_modified_body_positions_to_colliders(
+        &self,
+        colliders: &mut RapierContextColliders,
+    ) {
+        self.bodies
+            .propagate_modified_body_positions_to_colliders(&mut colliders.colliders);
+    }
+
+    /// Computes the angle between the two bodies attached by the [`RevoluteJoint`] component (if any) referenced by the given `entity`.
+    ///
+    /// The angle is computed along the revolute joint’s principal axis.
+    ///
+    /// Parameter `entity` should have a [`ImpulseJoint`] component with a [`TypedJoint::RevoluteJoint`] variant as `data`.
+    pub fn impulse_revolute_joint_angle(
+        &self,
+        joints: &RapierContextJoints,
+        entity: Entity,
+    ) -> Option<f32> {
+        let joint_handle = joints.entity2impulse_joint().get(&entity)?;
+        let impulse_joint = joints.impulse_joints.get(*joint_handle)?;
+        let revolute_joint = impulse_joint.data.as_revolute()?;
+
+        let rb1 = &self.bodies[impulse_joint.body1()];
+        let rb2 = &self.bodies[impulse_joint.body2()];
+        Some(revolute_joint.angle(rb1.rotation(), rb2.rotation()))
+    }
+
+    /// The Rapier rigid-body attached to the given `entity`, if any.
+    fn body(&self, entity: Entity) -> Option<&rapier::dynamics::RigidBody> {
+        self.bodies.get(*self.entity2body.get(&entity)?)
+    }
+
+    /// The linear velocity of the given world-space `point`, assuming it is rigidly attached to the
+    /// rigid-body of `entity`.
+    ///
+    /// Unlike [`crate::dynamics::Velocity::linear_velocity_at_point`], this uses the center of mass
+    /// computed by Rapier. Returns `None` if `entity` has no rigid-body.
+    pub fn velocity_at_point(&self, entity: Entity, point: Vect) -> Option<Vect> {
+        Some(self.body(entity)?.velocity_at_point(point))
+    }
+
+    /// Returns `true` if the rigid-body of `entity` has a non-zero linear or angular velocity.
+    ///
+    /// Returns `None` if `entity` has no rigid-body.
+    pub fn is_moving(&self, entity: Entity) -> Option<bool> {
+        Some(self.body(entity)?.is_moving())
+    }
+
+    /// Returns `true` if CCD is active for the rigid-body of `entity`, i.e., if it moved fast
+    /// enough during the last step to justify a CCD run.
+    ///
+    /// Returns `None` if `entity` has no rigid-body.
+    pub fn is_ccd_active(&self, entity: Entity) -> Option<bool> {
+        Some(self.body(entity)?.is_ccd_active())
+    }
+
+    /// The next position of the rigid-body of `entity`.
+    ///
+    /// For kinematic rigid-bodies, this is the position set by the user for the next step. For
+    /// other rigid-bodies, this value is currently unspecified. The returned transform has a unit
+    /// scale. Returns `None` if `entity` has no rigid-body.
+    pub fn next_position(&self, entity: Entity) -> Option<Transform> {
+        Some(crate::utils::iso_to_transform(
+            self.body(entity)?.next_position(),
+        ))
+    }
+
+    /// Predicts the position of the rigid-body of `entity` after `dt` seconds, by integrating its
+    /// current velocity and forces (including gravity).
+    ///
+    /// The returned transform has a unit scale. Returns `None` if `entity` has no rigid-body.
+    pub fn predict_position_using_velocity_and_forces(
+        &self,
+        entity: Entity,
+        dt: Real,
+    ) -> Option<Transform> {
+        Some(crate::utils::iso_to_transform(
+            &self
+                .body(entity)?
+                .predict_position_using_velocity_and_forces(dt),
+        ))
+    }
+
+    /// Predicts the position of the rigid-body of `entity` after `dt` seconds, by integrating its
+    /// current velocity only (forces are ignored).
+    ///
+    /// The returned transform has a unit scale. Returns `None` if `entity` has no rigid-body.
+    pub fn predict_position_using_velocity(&self, entity: Entity, dt: Real) -> Option<Transform> {
+        Some(crate::utils::iso_to_transform(
+            &self.body(entity)?.predict_position_using_velocity(dt),
+        ))
+    }
+
+    /// The kinetic energy of the rigid-body of `entity`.
+    ///
+    /// Returns `None` if `entity` has no rigid-body.
+    pub fn kinetic_energy(&self, entity: Entity) -> Option<Real> {
+        Some(self.body(entity)?.kinetic_energy())
+    }
+
+    /// The gravitational potential energy of the rigid-body of `entity`.
+    ///
+    /// The position is projected back by half a timestep `dt` so the result is synchronized with
+    /// [`Self::kinetic_energy`]. Returns `None` if `entity` has no rigid-body.
+    pub fn gravitational_potential_energy(
+        &self,
+        entity: Entity,
+        dt: Real,
+        gravity: Vect,
+    ) -> Option<Real> {
+        Some(
+            self.body(entity)?
+                .gravitational_potential_energy(dt, gravity),
+        )
+    }
+
+    /// The total user force applied to the rigid-body of `entity` (e.g. from its
+    /// [`crate::dynamics::ExternalForce`] component).
+    ///
+    /// This is zero for non-dynamic rigid-bodies. Returns `None` if `entity` has no rigid-body.
+    pub fn user_force(&self, entity: Entity) -> Option<Vect> {
+        Some(self.body(entity)?.user_force())
+    }
+
+    /// The total user torque applied to the rigid-body of `entity` (e.g. from its
+    /// [`crate::dynamics::ExternalForce`] component).
+    ///
+    /// This is zero for non-dynamic rigid-bodies. Returns `None` if `entity` has no rigid-body.
+    #[cfg(feature = "dim2")]
+    pub fn user_torque(&self, entity: Entity) -> Option<Real> {
+        Some(self.body(entity)?.user_torque())
+    }
+
+    /// The total user torque applied to the rigid-body of `entity` (e.g. from its
+    /// [`crate::dynamics::ExternalForce`] component).
+    ///
+    /// This is zero for non-dynamic rigid-bodies. Returns `None` if `entity` has no rigid-body.
+    #[cfg(feature = "dim3")]
+    pub fn user_torque(&self, entity: Entity) -> Option<Vect> {
+        Some(self.body(entity)?.user_torque())
+    }
+
+    /// The dominance group actually used by the solver for the rigid-body of `entity`.
+    ///
+    /// This is `i8::MAX + 1` for non-dynamic rigid-bodies. Returns `None` if `entity` has no
+    /// rigid-body.
+    pub fn effective_dominance_group(&self, entity: Entity) -> Option<i16> {
+        Some(self.body(entity)?.effective_dominance_group())
+    }
+
+    /// The world-space center of mass of the rigid-body of `entity`.
+    ///
+    /// Returns `None` if `entity` has no rigid-body.
+    pub fn center_of_mass(&self, entity: Entity) -> Option<Vect> {
+        Some(self.body(entity)?.center_of_mass())
+    }
+
+    /// The mass of the rigid-body of `entity` (including the contributions of its colliders).
+    ///
+    /// This is zero for rigid-bodies without mass. Returns `None` if `entity` has no rigid-body.
+    pub fn mass(&self, entity: Entity) -> Option<Real> {
+        Some(self.body(entity)?.mass())
+    }
+}
+
+/// Teleports the kinematic position-based rigid-bodies to their next kinematic position.
+///
+/// This emulates, in collision-only mode, the motion the physics pipeline would apply.
+fn apply_kinematic_targets(bodies: &mut RigidBodySet) {
+    let targets: Vec<_> = bodies
+        .iter()
+        .filter(|(_, rb)| {
+            rb.body_type() == RigidBodyType::KinematicPositionBased
+                && rb.position() != rb.next_position()
+        })
+        .map(|(handle, rb)| (handle, *rb.next_position()))
+        .collect();
+    for (handle, pose) in targets {
+        if let Some(rb) = bodies.get_mut(handle) {
+            rb.set_position(pose, false);
+        }
+    }
+}
+
+/// A soft-body tear waiting for the `handle_soft_body_tears` system.
+pub(crate) struct PendingSoftBodyTear {
+    /// The Rapier tear event.
+    pub raw: RapierSoftBodyTearEvent,
+    /// The entities already spawned for the pieces split off the torn body (the pieces of `raw`
+    /// but the first), or empty if they must be spawned by the system.
+    pub piece_entities: Vec<Entity>,
+}
+
+/// Statistics about the simulation steps executed by the last call to
+/// [`RapierContextSimulation::step_simulation`], i.e., during the last physics update.
+///
+/// The step count and time are measured by `bevy_rapier` and always available. The other
+/// statistics are read from the [`PhysicsPipeline::counters`] after each step, and are only
+/// measured while these counters are enabled (e.g. by the
+/// [`RapierDiagnosticsPlugin`](crate::plugin::diagnostics::RapierDiagnosticsPlugin)). The other
+/// timings also require the `profiler` feature. In [`SimulationMode::CollisionOnly`], only the
+/// contact pairs are counted besides the steps.
+#[derive(Copy, Clone, Debug, Default, PartialEq)]
+pub struct SimulationStepStats {
+    /// The number of simulation steps (including substeps) executed.
+    pub num_steps: usize,
+    /// The total wall-clock time spent running the simulation steps, in milliseconds.
+    pub step_time_ms: f64,
+    /// Time spent on collision detection (broad-phase and narrow-phase), in milliseconds.
+    pub collision_detection_time_ms: f64,
+    /// Time spent in the broad-phase, in milliseconds.
+    pub broad_phase_time_ms: f64,
+    /// Time spent in the narrow-phase, in milliseconds.
+    pub narrow_phase_time_ms: f64,
+    /// Time spent building the simulation islands, in milliseconds.
+    pub island_construction_time_ms: f64,
+    /// Time spent in the constraints solver, in milliseconds.
+    pub solver_time_ms: f64,
+    /// Time spent on Continuous Collision Detection, in milliseconds.
+    pub ccd_time_ms: f64,
+    /// Time spent updating the rigid-bodies’ positions and velocities, in milliseconds.
+    pub update_time_ms: f64,
+    /// The number of CCD substeps executed (zero on the steps where the CCD didn't need to act).
+    pub ccd_substeps: usize,
+    /// The number of contact pairs tracked by the narrow-phase (touching or not) after the last
+    /// step.
+    pub num_contact_pairs: usize,
+    /// The number of contact manifolds and impulse joints handed to the constraints solver,
+    /// summed over the steps. The contacts and joints of sleeping bodies aren't counted.
+    pub num_solver_constraints: usize,
+    /// The number of contact points handed to the constraints solver, soft-body contacts
+    /// included, summed over the steps.
+    pub num_solver_contacts: usize,
+}
+
+impl SimulationStepStats {
+    /// Adds the counters of the last step of `pipeline` to these statistics.
+    fn accumulate_counters(&mut self, pipeline: &PhysicsPipeline) {
+        let counters = &pipeline.counters;
+        self.collision_detection_time_ms += counters.collision_detection_time_ms();
+        self.broad_phase_time_ms += counters.broad_phase_time_ms();
+        self.narrow_phase_time_ms += counters.narrow_phase_time_ms();
+        self.island_construction_time_ms += counters.island_construction_time_ms();
+        self.solver_time_ms += counters.solver_time_ms();
+        self.ccd_time_ms += counters.ccd_time_ms();
+        self.update_time_ms += counters.update_time_ms();
+        self.ccd_substeps += counters.ccd.num_substeps;
+        self.num_contact_pairs = counters.cd.ncontact_pairs;
+        self.num_solver_constraints += counters.solver.nconstraints;
+        self.num_solver_contacts += counters.solver.ncontacts;
+    }
+}
+
+/// The Rapier context, containing parts of the state of the physics engine, specific to the simulation step.
+///
+/// This is the main driver for a rapier context, which will create other required components if needed.
+///
+/// Additionally to its required components, this component is also always paired with a [`RapierConfiguration`][crate::prelude::RapierConfiguration] component.
+#[cfg_attr(feature = "serde-serialize", derive(Serialize, Deserialize))]
+#[derive(Component)]
+#[require(
+    RapierContextColliders,
+    RapierRigidBodySet,
+    RapierContextJoints,
+    SimulationToRenderTime
+)]
+pub struct RapierContextSimulation {
+    /// The island manager, which detects what object is sleeping
+    /// (not moving much) to reduce computations.
+    pub islands: IslandManager,
+    /// The broad-phase, which detects potential contact pairs.
+    pub broad_phase: DefaultBroadPhase,
+    /// The narrow-phase, which computes contact points, tests intersections,
+    /// and maintain the contact and intersection graphs.
+    pub narrow_phase: NarrowPhase,
+    /// The solver, which handles Continuous Collision Detection (CCD).
+    pub ccd_solver: CCDSolver,
+    /// The physics pipeline, which advance the simulation step by step.
+    #[cfg_attr(feature = "serde-serialize", serde(skip))]
+    pub pipeline: PhysicsPipeline,
+    /// The collision pipeline, which only runs collision detection when the context is in
+    /// [`SimulationMode::CollisionOnly`].
+    #[cfg_attr(feature = "serde-serialize", serde(skip))]
+    pub collision_pipeline: CollisionPipeline,
+    /// The integration parameters, controlling various low-level coefficient of the simulation.
+    pub integration_parameters: IntegrationParameters,
+    /// The user-provided event handler, see [`Self::set_event_handler`].
+    #[cfg_attr(feature = "serde-serialize", serde(skip))]
+    pub(crate) event_handler: Option<Box<dyn EventHandler + Send + Sync>>,
+    // This maps the handles of colliders that have been deleted since the last
+    // physics update, to the entity they was attached to.
+    /// NOTE: this map is needed to handle despawning.
+    #[cfg_attr(feature = "serde-serialize", serde(skip))]
+    pub(crate) deleted_colliders: HashMap<ColliderHandle, Entity>,
+
+    #[cfg_attr(feature = "serde-serialize", serde(skip))]
+    pub(crate) collision_events_to_send: Vec<CollisionEvent>,
+    #[cfg_attr(feature = "serde-serialize", serde(skip))]
+    pub(crate) contact_force_events_to_send: Vec<ContactForceEvent>,
+    #[cfg_attr(feature = "serde-serialize", serde(skip))]
+    pub(crate) character_collisions_collector: Vec<rapier::control::CharacterCollision>,
+    #[cfg_attr(feature = "serde-serialize", serde(skip))]
+    pub(crate) step_stats: SimulationStepStats,
+    /// Rigid-body entities quarantined since the last quarantine event was sent.
+    #[cfg_attr(feature = "serde-serialize", serde(skip))]
+    pub(crate) quarantined_bodies: Vec<Entity>,
+    /// Collider entities quarantined since the last quarantine event was sent.
+    #[cfg_attr(feature = "serde-serialize", serde(skip))]
+    pub(crate) quarantined_colliders: Vec<Entity>,
+    /// Soft-body entities quarantined since the last quarantine event was sent.
+    #[cfg_attr(feature = "serde-serialize", serde(skip))]
+    pub(crate) quarantined_soft_bodies: Vec<Entity>,
+    /// The number of threads last requested through [`Self::set_num_threads`].
+    #[cfg_attr(feature = "serde-serialize", serde(skip))]
+    pub(crate) requested_num_threads: Option<usize>,
+    /// Soft-body tears not yet turned into [`SoftBodyTearEvent`] messages (their piece entities
+    /// are spawned by the `handle_soft_body_tears` system).
+    ///
+    /// [`SoftBodyTearEvent`]: crate::pipeline::SoftBodyTearEvent
+    #[cfg_attr(feature = "serde-serialize", serde(skip))]
+    pub(crate) pending_soft_body_tears: Vec<PendingSoftBodyTear>,
+}
+
+impl Default for RapierContextSimulation {
+    fn default() -> Self {
+        Self {
+            islands: IslandManager::new(),
+            broad_phase: DefaultBroadPhase::new(),
+            narrow_phase: NarrowPhase::new(),
+            ccd_solver: CCDSolver::new(),
+            pipeline: PhysicsPipeline::new(),
+            collision_pipeline: CollisionPipeline::new(),
+            integration_parameters: IntegrationParameters::default(),
+            event_handler: None,
+            deleted_colliders: HashMap::default(),
+            collision_events_to_send: Vec::new(),
+            contact_force_events_to_send: Vec::new(),
+            character_collisions_collector: Vec::new(),
+            step_stats: SimulationStepStats::default(),
+            quarantined_bodies: Vec::new(),
+            quarantined_colliders: Vec::new(),
+            quarantined_soft_bodies: Vec::new(),
+            requested_num_threads: None,
+            pending_soft_body_tears: Vec::new(),
+        }
+    }
+}
+
+impl RapierContextSimulation {
+    /// Creates a simulation context whose broad-phase uses the given BVH optimization strategy.
+    ///
+    /// This is what [`RapierContextInitialization::InitializeDefaultRapierContext`] uses for the
+    /// default context.
+    ///
+    /// [`RapierContextInitialization::InitializeDefaultRapierContext`]: crate::plugin::RapierContextInitialization::InitializeDefaultRapierContext
+    pub fn with_broad_phase_optimization_strategy(
+        strategy: BroadPhaseOptimizationStrategy,
+    ) -> Self {
+        Self {
+            broad_phase: DefaultBroadPhase::with_optimization_strategy(strategy.into()),
+            ..Self::default()
+        }
+    }
+
+    /// Statistics about the simulation steps executed during the last physics update.
+    pub fn step_stats(&self) -> &SimulationStepStats {
+        &self.step_stats
+    }
+
+    /// Sets the number of threads of the thread pool dedicated to this context’s simulation, or
+    /// removes that pool if `num_threads` is `None`.
+    ///
+    /// The pool is only rebuilt if `num_threads` differs from the value of the previous call. This
+    /// is called automatically with [`RapierConfiguration::num_threads`] before each simulation
+    /// step, and does nothing unless the `parallel` feature is enabled (and `unsync-callbacks`
+    /// is not).
+    ///
+    /// [`RapierConfiguration::num_threads`]: crate::plugin::RapierConfiguration::num_threads
+    pub fn set_num_threads(&mut self, num_threads: Option<usize>) {
+        if self.requested_num_threads == num_threads {
+            return;
+        }
+        self.requested_num_threads = num_threads;
+
+        #[cfg(all(feature = "parallel", not(feature = "unsync-callbacks")))]
+        match num_threads {
+            Some(n) => {
+                if let Err(err) = self.pipeline.configure_thread_pool(n) {
+                    log::error!("Failed to create a Rapier thread pool with {n} threads: {err}");
+                }
+            }
+            None => self.pipeline.clear_thread_pool(),
+        }
+    }
+
+    /// Creates a simulation context whose narrow-phase uses a custom query dispatcher.
+    ///
+    /// The query dispatcher computes the contact manifolds and intersections between pairs of
+    /// shapes, which makes it possible to support custom shapes or override the contact
+    /// generation of existing ones. Spawn it with
+    /// [`RapierContextInitialization::NoAutomaticRapierContext`](crate::plugin::RapierContextInitialization::NoAutomaticRapierContext),
+    /// or see [`Self::set_query_dispatcher`] for the default context.
+    pub fn with_query_dispatcher<D>(dispatcher: D) -> Self
+    where
+        D: 'static + PersistentQueryDispatcher<ContactManifoldData, ContactData>,
+    {
+        Self {
+            narrow_phase: NarrowPhase::with_query_dispatcher(dispatcher),
+            ..Self::default()
+        }
+    }
+
+    /// Replaces the narrow-phase with an empty one using the given custom query dispatcher.
+    ///
+    /// This discards every contact and intersection pair of the current narrow-phase, so it
+    /// must be called before any collider is added to this context (for example in a
+    /// `Startup` system, since colliders are inserted during [`PhysicsSet::SyncBackend`]).
+    ///
+    /// [`PhysicsSet::SyncBackend`]: crate::plugin::PhysicsSet::SyncBackend
+    pub fn set_query_dispatcher<D>(&mut self, dispatcher: D)
+    where
+        D: 'static + PersistentQueryDispatcher<ContactManifoldData, ContactData>,
+    {
+        self.narrow_phase = NarrowPhase::with_query_dispatcher(dispatcher);
+    }
+
+    /// The query dispatcher used by the narrow-phase to compute contacts and intersections.
+    pub fn query_dispatcher(
+        &self,
+    ) -> &dyn PersistentQueryDispatcher<ContactManifoldData, ContactData> {
+        self.narrow_phase.query_dispatcher()
+    }
+
+    /// Installs a Rapier [`EventHandler`] called by the physics pipeline for every collision,
+    /// contact force and soft-body tear event.
+    ///
+    /// It is called in addition to (not instead of) the forwarding of events as
+    /// [`CollisionEvent`] and [`ContactForceEvent`] Bevy messages, and replaces the previously
+    /// installed handler, if any. The handler receives raw Rapier handles: the entity of a
+    /// collider can be retrieved with [`RapierContextColliders::entity_from_collider`]. Note that
+    /// the colliders of an event flagged with `CollisionEventFlags::REMOVED` may no longer be
+    /// part of the collider set.
+    pub fn set_event_handler(&mut self, handler: impl EventHandler + Send + Sync + 'static) {
+        self.event_handler = Some(Box::new(handler));
+    }
+
+    /// Removes the event handler installed with [`Self::set_event_handler`] and returns it.
+    pub fn remove_event_handler(&mut self) -> Option<Box<dyn EventHandler + Send + Sync>> {
+        self.event_handler.take()
+    }
+
+    /// The event handler installed with [`Self::set_event_handler`], if any.
+    pub fn event_handler(&self) -> Option<&(dyn EventHandler + Send + Sync)> {
+        self.event_handler.as_deref()
+    }
+
+    /// Removes the soft body `handle` (with its colliders, cluster proxies and the joints
+    /// attached to them), and unmaps the entities standing for them.
+    pub(crate) fn remove_soft_body(
+        &mut self,
+        colliders: &mut RapierContextColliders,
+        joints: &mut RapierContextJoints,
+        rigidbody_set: &mut RapierRigidBodySet,
+        handle: SoftBodyHandle,
+    ) -> Option<RapierSoftBody> {
+        let sb = rigidbody_set.soft_bodies.get(handle)?;
+        for (_, cluster) in sb.live_clusters() {
+            let proxy = cluster.proxy();
+            let Some(rb) = rigidbody_set.bodies.get(proxy) else {
+                continue;
+            };
+            if let Some(entity) = Entity::try_from_bits(rb.user_data as u64) {
+                if rigidbody_set.entity2body.get(&entity) == Some(&proxy) {
+                    rigidbody_set.entity2body.remove(&entity);
+                    rigidbody_set.last_body_transform_set.remove(&proxy);
+                }
+            }
+            for co_handle in rb.colliders() {
+                let Some(co) = colliders.colliders.get(*co_handle) else {
+                    continue;
+                };
+                let Some(entity) = Entity::try_from_bits(co.user_data as u64) else {
+                    continue;
+                };
+                // Removed colliders may still be reported by the next step's events.
+                self.deleted_colliders.insert(*co_handle, entity);
+                if colliders.entity2collider.get(&entity) == Some(co_handle) {
+                    colliders.entity2collider.remove(&entity);
+                }
+            }
+            for (_, _, joint_handle, joint) in joints.impulse_joints.attached_joints(proxy) {
+                let entity = RapierContextJoints::entity_from_impulse_joint(joint);
+                if joints.entity2impulse_joint.get(&entity) == Some(&joint_handle) {
+                    joints.entity2impulse_joint.remove(&entity);
+                }
+            }
+        }
+        rigidbody_set.entity2soft_body.retain(|_, h| *h != handle);
+        rigidbody_set.soft_bodies.remove(
+            handle,
+            &mut self.islands,
+            &mut rigidbody_set.bodies,
+            &mut colliders.colliders,
+            &mut joints.impulse_joints,
+            &mut joints.multibody_joints,
+        )
+    }
+
+    /// Tears the soft body of `entity` right away along the given edges and through the given
+    /// cells (see [`SoftBodySet::tear`]).
+    ///
+    /// The entities of the pieces split off the soft body are spawned with `commands` and
+    /// returned right away; they get their components and a
+    /// [`SoftBodyTearEvent`](crate::pipeline::SoftBodyTearEvent) message is sent during the next
+    /// [`PhysicsSet::Writeback`](crate::plugin::PhysicsSet::Writeback) (see
+    /// [`SoftBodyTearResult`]). Returns `None` if `entity` has no soft body or if nothing changed.
+    #[allow(clippy::too_many_arguments)]
+    pub fn tear_soft_body(
+        &mut self,
+        colliders: &mut RapierContextColliders,
+        joints: &mut RapierContextJoints,
+        rigidbody_set: &mut RapierRigidBodySet,
+        commands: &mut Commands,
+        entity: Entity,
+        edges: &[u32],
+        cells: &[u32],
+    ) -> Option<SoftBodyTearResult> {
+        let handle = *rigidbody_set.entity2soft_body.get(&entity)?;
+        let event = rigidbody_set.soft_bodies.tear(
+            handle,
+            edges,
+            cells,
+            &mut self.islands,
+            &mut rigidbody_set.bodies,
+            &mut colliders.colliders,
+            &mut joints.impulse_joints,
+            &mut joints.multibody_joints,
+        )?;
+        Some(self.map_manual_tear(colliders, rigidbody_set, commands, entity, event))
+    }
+
+    /// Cuts the soft body of `entity` right away along a blade: a world-space segment in 2D, a
+    /// world-space triangle in 3D (see [`SoftBodySet::cut`]).
+    ///
+    /// The entities of the pieces split off the soft body are spawned with `commands` and
+    /// returned right away; they get their components and a
+    /// [`SoftBodyTearEvent`](crate::pipeline::SoftBodyTearEvent) message is sent during the next
+    /// [`PhysicsSet::Writeback`](crate::plugin::PhysicsSet::Writeback) (see
+    /// [`SoftBodyTearResult`]). Returns `None` if `entity` has no soft body or if nothing changed.
+    pub fn cut_soft_body(
+        &mut self,
+        colliders: &mut RapierContextColliders,
+        joints: &mut RapierContextJoints,
+        rigidbody_set: &mut RapierRigidBodySet,
+        commands: &mut Commands,
+        entity: Entity,
+        blade: &[Vect; rapier::math::DIM],
+    ) -> Option<SoftBodyTearResult> {
+        let handle = *rigidbody_set.entity2soft_body.get(&entity)?;
+        let event = rigidbody_set.soft_bodies.cut(
+            handle,
+            blade,
+            &mut self.islands,
+            &mut rigidbody_set.bodies,
+            &mut colliders.colliders,
+            &mut joints.impulse_joints,
+            &mut joints.multibody_joints,
+        )?;
+        Some(self.map_manual_tear(colliders, rigidbody_set, commands, entity, event))
+    }
+
+    /// Spawns the entities of the pieces of a tear of the soft body of `entity`, maps them to their
+    /// soft bodies, and queues the tear for the `handle_soft_body_tears` system.
+    fn map_manual_tear(
+        &mut self,
+        colliders: &mut RapierContextColliders,
+        rigidbody_set: &mut RapierRigidBodySet,
+        commands: &mut Commands,
+        entity: Entity,
+        event: RapierSoftBodyTearEvent,
+    ) -> SoftBodyTearResult {
+        let mut pieces = Vec::with_capacity(event.pieces.len());
+        for (k, piece) in event.pieces.iter().enumerate() {
+            let piece_entity = if k == 0 {
+                entity
+            } else {
+                let piece_entity = commands.spawn_empty().id();
+                rigidbody_set.map_soft_body_piece(colliders, piece.soft_body, piece_entity);
+                piece_entity
+            };
+            rigidbody_set.map_soft_body_collision_mesh(colliders, piece.soft_body, piece_entity);
+            rigidbody_set.map_soft_body_whole_proxy(piece_entity, piece.soft_body);
+            pieces.push(piece_entity);
+        }
+        if event.pieces.is_empty() {
+            rigidbody_set.map_soft_body_collision_mesh(colliders, event.soft_body, entity);
+            rigidbody_set.map_soft_body_whole_proxy(entity, event.soft_body);
+        }
+        self.pending_soft_body_tears.push(PendingSoftBodyTear {
+            raw: event.clone(),
+            piece_entities: pieces.get(1..).unwrap_or_default().to_vec(),
+        });
+        SoftBodyTearResult { pieces, raw: event }
+    }
+
+    /// Advance the simulation, based on the given timestep mode.
+    ///
+    /// With [`SimulationMode::CollisionOnly`], only collision detection runs at each step (see
+    /// [`SimulationMode`]).
+    ///
+    /// Steps with a zero (or negative) dt, like the first frame with [`TimestepMode::Variable`],
+    /// are skipped entirely.
+    #[allow(clippy::too_many_arguments)]
+    pub fn step_simulation(
+        &mut self,
+        colliders: &mut RapierContextColliders,
+        joints: &mut RapierContextJoints,
+        rigidbody_set: &mut RapierRigidBodySet,
+        gravity: Vect,
+        simulation_mode: SimulationMode,
+        timestep_mode: TimestepMode,
+        events: Option<(
+            &MessageWriter<CollisionEvent>,
+            &MessageWriter<ContactForceEvent>,
+        )>,
+        hooks: &dyn PhysicsHooks,
+        time: &Time,
+        sim_to_render_time: &mut SimulationToRenderTime,
+        mut interpolation_query: Option<
+            &mut Query<(&RapierRigidBodyHandle, &mut TransformInterpolation)>,
+        >,
+    ) {
+        self.step_stats = SimulationStepStats::default();
+
+        // Temporarily move the event handling state out of `self` so it can be borrowed while
+        // `self` is borrowed mutably by each step.
+        let user_event_handler = self.event_handler.take();
+        let deleted_colliders = std::mem::take(&mut self.deleted_colliders);
+
+        let event_queue = if events.is_some() {
+            Some(EventQueue {
+                deleted_colliders: &deleted_colliders,
+                collision_events: RwLock::new(Vec::new()),
+                contact_force_events: RwLock::new(Vec::new()),
+            })
+        } else {
+            None
+        };
+
+        let soft_body_tears = RwLock::new(Vec::new());
+        let fan_out = EventHandlerFanOut {
+            queue: event_queue.as_ref(),
+            user: user_event_handler.as_deref(),
+            soft_body_tears: &soft_body_tears,
+        };
+        let event_handler = &fan_out as &dyn EventHandler;
+
+        let mut executed_steps = 0;
+        match timestep_mode {
+            TimestepMode::Interpolated {
+                dt,
+                time_scale,
+                substeps,
+            } => {
+                self.integration_parameters.dt = dt;
+
+                sim_to_render_time.diff += time.delta_secs();
+
+                while sim_to_render_time.diff > 0.0 {
+                    // NOTE: in this comparison we do the same computations we
+                    // will do for the next `while` iteration test, to make sure we
+                    // don't get bit by potential float inaccuracy.
+                    if sim_to_render_time.diff - dt <= 0.0 {
+                        if let Some(interpolation_query) = interpolation_query.as_mut() {
+                            // This is the last simulation step to be executed in the loop
+                            // Update the previous state transforms
+                            for (handle, mut interpolation) in interpolation_query.iter_mut() {
+                                if let Some(body) = rigidbody_set.bodies.get(handle.0) {
+                                    interpolation.start = Some(*body.position());
+                                    interpolation.end = None;
+                                }
+                            }
+                        }
+                    }
+
+                    let mut substep_integration_parameters = self.integration_parameters;
+                    substep_integration_parameters.dt = dt / (substeps as Real) * time_scale;
+
+                    // A zero `time_scale` would run zero-length steps; skip them.
+                    let num_substeps = if substep_integration_parameters.dt > 0.0 {
+                        substeps
+                    } else {
+                        0
+                    };
+
+                    for _ in 0..num_substeps {
+                        self.step_once(
+                            simulation_mode,
+                            gravity,
+                            &substep_integration_parameters,
+                            colliders,
+                            joints,
+                            rigidbody_set,
+                            hooks,
+                            event_handler,
+                        );
+                        executed_steps += 1;
+                    }
+
+                    sim_to_render_time.diff -= dt;
+                }
+            }
+            TimestepMode::Variable {
+                max_dt,
+                time_scale,
+                substeps,
+            } => {
+                self.integration_parameters.dt = (time.delta_secs() * time_scale).min(max_dt);
+
+                let mut substep_integration_parameters = self.integration_parameters;
+                substep_integration_parameters.dt /= substeps as Real;
+
+                // The first frame (or a zero `time_scale`) has a zero dt: skip the step, which
+                // would only run a useless collision detection pass.
+                let num_substeps = if substep_integration_parameters.dt > 0.0 {
+                    substeps
+                } else {
+                    0
+                };
+
+                for _ in 0..num_substeps {
+                    self.step_once(
+                        simulation_mode,
+                        gravity,
+                        &substep_integration_parameters,
+                        colliders,
+                        joints,
+                        rigidbody_set,
+                        hooks,
+                        event_handler,
+                    );
+                    executed_steps += 1;
+                }
+            }
+            TimestepMode::Fixed { dt, substeps } => {
+                self.integration_parameters.dt = dt;
+
+                let mut substep_integration_parameters = self.integration_parameters;
+                substep_integration_parameters.dt = dt / (substeps as Real);
+
+                let num_substeps = if substep_integration_parameters.dt > 0.0 {
+                    substeps
+                } else {
+                    0
+                };
+
+                for _ in 0..num_substeps {
+                    self.step_once(
+                        simulation_mode,
+                        gravity,
+                        &substep_integration_parameters,
+                        colliders,
+                        joints,
+                        rigidbody_set,
+                        hooks,
+                        event_handler,
+                    );
+                    executed_steps += 1;
+                }
+            }
+        }
+        if let Some(mut event_queue) = event_queue {
+            // NOTE: event_queue and its inner locks are only accessed from
+            // within the steps executed above, so we can unwrap here safely.
+            self.collision_events_to_send =
+                std::mem::take(event_queue.collision_events.get_mut().unwrap());
+            self.contact_force_events_to_send =
+                std::mem::take(event_queue.contact_force_events.get_mut().unwrap());
+        }
+
+        // NOTE: the lock is only accessed from within the steps executed above.
+        self.pending_soft_body_tears.extend(
+            soft_body_tears
+                .into_inner()
+                .unwrap_or_default()
+                .into_iter()
+                .map(|raw| PendingSoftBodyTear {
+                    raw,
+                    piece_entities: vec![],
+                }),
+        );
+
+        self.event_handler = user_event_handler;
+        if executed_steps == 0 {
+            self.deleted_colliders = deleted_colliders;
+            // No step ran (e.g. zero dt): still move colliders attached to bodies the user moved,
+            // like when the physics pipeline is inactive.
+            rigidbody_set.propagate_modified_body_positions_to_colliders(colliders);
+        }
+    }
+
+    /// Executes a single simulation step (or collision-detection step) and updates the step
+    /// statistics and quarantine reports.
+    #[allow(clippy::too_many_arguments)]
+    fn step_once(
+        &mut self,
+        simulation_mode: SimulationMode,
+        gravity: Vect,
+        integration_parameters: &IntegrationParameters,
+        colliders: &mut RapierContextColliders,
+        joints: &mut RapierContextJoints,
+        rigidbody_set: &mut RapierRigidBodySet,
+        hooks: &dyn PhysicsHooks,
+        event_handler: &dyn EventHandler,
+    ) {
+        let start = bevy::platform::time::Instant::now();
+
+        match simulation_mode {
+            SimulationMode::Full => {
+                self.pipeline.step(
+                    gravity,
+                    integration_parameters,
+                    &mut self.islands,
+                    &mut self.broad_phase,
+                    &mut self.narrow_phase,
+                    &mut rigidbody_set.bodies,
+                    &mut colliders.colliders,
+                    &mut joints.impulse_joints,
+                    &mut joints.multibody_joints,
+                    &mut rigidbody_set.soft_bodies,
+                    &mut self.ccd_solver,
+                    hooks,
+                    event_handler,
+                );
+            }
+            SimulationMode::CollisionOnly => {
+                apply_kinematic_targets(&mut rigidbody_set.bodies);
+                self.collision_pipeline.step(
+                    integration_parameters.prediction_distance(),
+                    &mut self.islands,
+                    &mut self.broad_phase,
+                    &mut self.narrow_phase,
+                    &mut rigidbody_set.bodies,
+                    &mut colliders.colliders,
+                    hooks,
+                    event_handler,
+                );
+            }
+        }
+
+        self.step_stats.num_steps += 1;
+        self.step_stats.step_time_ms += start.elapsed().as_secs_f64() * 1000.0;
+
+        // Rapier doesn't reset its counters while they are disabled, so they would be stale.
+        if self.pipeline.counters.enabled() {
+            match simulation_mode {
+                SimulationMode::Full => self.step_stats.accumulate_counters(&self.pipeline),
+                // The collision pipeline has no counters.
+                SimulationMode::CollisionOnly => {
+                    self.step_stats.num_contact_pairs = self.narrow_phase.contact_pairs().count();
+                }
+            }
+        }
+
+        if simulation_mode == SimulationMode::Full {
+            let quarantine = self.pipeline.quarantine();
+            if !quarantine.is_empty() {
+                self.quarantined_bodies.extend(
+                    quarantine
+                        .bodies()
+                        .iter()
+                        .filter_map(|h| rigidbody_set.rigid_body_entity(*h)),
+                );
+                self.quarantined_colliders.extend(
+                    quarantine
+                        .colliders()
+                        .iter()
+                        .filter_map(|h| colliders.collider_entity(*h)),
+                );
+                self.quarantined_soft_bodies.extend(
+                    quarantine
+                        .soft_bodies()
+                        .iter()
+                        .filter_map(|h| rigidbody_set.soft_body_entity(*h)),
+                );
+            }
+        }
+    }
+
+    /// Sends a [`PhysicsQuarantineEvent`] (and logs a warning) if some rigid-bodies, colliders or
+    /// soft bodies were quarantined by the simulation steps executed since the last call.
+    ///
+    /// `context` is the entity of this context. This is called automatically by the
+    /// [`step_simulation`](crate::plugin::systems::step_simulation) system.
+    pub fn send_quarantine_events(
+        &mut self,
+        context: Entity,
+        quarantine_event_writer: &mut MessageWriter<PhysicsQuarantineEvent>,
+    ) {
+        if self.quarantined_bodies.is_empty()
+            && self.quarantined_colliders.is_empty()
+            && self.quarantined_soft_bodies.is_empty()
+        {
+            return;
+        }
+
+        let event = PhysicsQuarantineEvent {
+            context,
+            bodies: std::mem::take(&mut self.quarantined_bodies),
+            colliders: std::mem::take(&mut self.quarantined_colliders),
+            soft_bodies: std::mem::take(&mut self.quarantined_soft_bodies),
+        };
+        log::warn!(
+            "Rapier detected non-finite (NaN or infinite) state in context {context}; the \
+            following rigid-bodies were rolled back and disabled: {:?}; the following colliders \
+            were disabled: {:?}; the following soft bodies were disabled: {:?}.",
+            event.bodies,
+            event.colliders,
+            event.soft_bodies
+        );
+        quarantine_event_writer.write(event);
+    }
+
+    /// Generates bevy events for any physics interactions that have happened
+    /// that are stored in the events list
+    pub fn send_bevy_events(
+        &mut self,
+        collision_event_writer: &mut MessageWriter<CollisionEvent>,
+        contact_force_event_writer: &mut MessageWriter<ContactForceEvent>,
+    ) {
+        for collision_event in self.collision_events_to_send.drain(..) {
+            collision_event_writer.write(collision_event);
+        }
+        for contact_force_event in self.contact_force_events_to_send.drain(..) {
+            contact_force_event_writer.write(contact_force_event);
+        }
+    }
+
+    /// Attempts to move shape, optionally sliding or climbing obstacles.
+    ///
+    /// The obstacles are the colliders of this context matching `filter`, detected with this
+    /// context's [query dispatcher](Self::query_dispatcher).
+    ///
+    /// # Parameters
+    /// * `colliders`, `rigidbody_set`: the collider and rigid-body sets of this context.
+    /// * `movement`: the translational movement to apply.
+    /// * `shape`: the shape to move.
+    /// * `shape_translation`: the initial position of the shape.
+    /// * `shape_rotation`: the rotation of the shape.
+    /// * `shape_mass`: the mass of the shape to be considered by the impulse calculation if
+    ///   `MoveShapeOptions::apply_impulse_to_dynamic_bodies` is set to true.
+    /// * `options`: configures the behavior of the automatic sliding and climbing.
+    /// * `filter`: selects the colliders the shape can collide with (exclude the collider or
+    ///   rigid-body of the moved shape itself).
+    /// * `events`: callback run on each obstacle hit by the shape on its path, once the
+    ///   movement is computed.
+    #[allow(clippy::too_many_arguments)]
+    pub fn move_shape(
+        &mut self,
+        colliders: &mut RapierContextColliders,
+        rigidbody_set: &mut RapierRigidBodySet,
+        movement: Vect,
+        shape: &(impl AsShape + ?Sized),
+        shape_translation: Vect,
+        shape_rotation: Rot,
+        shape_mass: Real,
+        options: &MoveShapeOptions,
+        filter: QueryFilter,
+        mut events: impl FnMut(CharacterCollision),
+    ) -> MoveShapeOutput {
+        let shape = shape.as_shape();
+        assert!(
+            options.up.length_squared() > 0.0,
+            "The up vector must be non-zero."
+        );
+        let up = options.up.normalize();
+        let autostep = options.autostep.map(|autostep| CharacterAutostep {
+            max_height: autostep.max_height,
+            min_width: autostep.min_width,
+            include_dynamic_bodies: autostep.include_dynamic_bodies,
+        });
+        let controller = rapier::control::KinematicCharacterController {
+            up,
+            offset: options.offset,
+            slide: options.slide,
+            autostep,
+            max_slope_climb_angle: options.max_slope_climb_angle,
+            min_slope_slide_angle: options.min_slope_slide_angle,
+            snap_to_ground: options.snap_to_ground,
+            normal_nudge_factor: options.normal_nudge_factor,
+        };
+
+        let dt = self.integration_parameters.dt;
+        let collisions = &mut self.character_collisions_collector;
+        collisions.clear();
+
+        let result = RapierQueryPipelineMut::new_scoped(
+            &self.broad_phase,
+            colliders,
+            rigidbody_set,
+            &filter,
+            self.narrow_phase.query_dispatcher(),
+            |mut query_pipeline| {
+                let result = controller.move_shape(
+                    dt,
+                    &query_pipeline.query_pipeline.as_ref(),
+                    shape,
+                    &crate::utils::pose_from(shape_translation, shape_rotation),
+                    movement,
+                    |c| collisions.push(c),
+                );
+
+                if options.apply_impulse_to_dynamic_bodies {
+                    controller.solve_character_collision_impulses(
+                        dt,
+                        &mut query_pipeline.query_pipeline,
+                        shape,
+                        shape_mass,
+                        collisions.iter(),
+                    );
+                }
+
+                result
+            },
+        );
+
+        for collision in collisions.iter() {
+            if let Some(collision) =
+                CharacterCollision::from_raw_with_set(&colliders.colliders, collision, true)
+            {
+                events(collision);
+            }
+        }
+
+        MoveShapeOutput {
+            effective_translation: result.translation,
+            grounded: result.grounded,
+            is_sliding_down_slope: result.is_sliding_down_slope,
+        }
+    }
+}
+
+/// Deserialization helpers rebuilding the entity maps skipped during serialization.
+#[cfg(feature = "serde-serialize")]
+mod serde_shadows {
+    use super::*;
+    use rapier::prelude::{ImpulseJointSet, MultibodyJointSet};
+
+    #[derive(Deserialize)]
+    pub(super) struct RapierContextCollidersData {
+        colliders: ColliderSet,
+    }
+
+    impl From<RapierContextCollidersData> for RapierContextColliders {
+        fn from(data: RapierContextCollidersData) -> Self {
+            let mut result = Self {
+                colliders: data.colliders,
+                entity2collider: HashMap::default(),
+            };
+            result.rebuild_entity_maps();
+            result
+        }
+    }
+
+    #[derive(Deserialize)]
+    pub(super) struct RapierContextJointsData {
+        impulse_joints: ImpulseJointSet,
+        multibody_joints: MultibodyJointSet,
+    }
+
+    impl From<RapierContextJointsData> for RapierContextJoints {
+        fn from(data: RapierContextJointsData) -> Self {
+            let mut result = Self {
+                impulse_joints: data.impulse_joints,
+                multibody_joints: data.multibody_joints,
+                entity2impulse_joint: HashMap::default(),
+                entity2multibody_joint: HashMap::default(),
+            };
+            result.rebuild_entity_maps();
+            result
+        }
+    }
+
+    #[derive(Deserialize)]
+    pub(super) struct RapierRigidBodySetData {
+        bodies: RigidBodySet,
+        soft_bodies: SoftBodySet,
+    }
+
+    impl From<RapierRigidBodySetData> for RapierRigidBodySet {
+        fn from(data: RapierRigidBodySetData) -> Self {
+            let mut result = Self {
+                bodies: data.bodies,
+                soft_bodies: data.soft_bodies,
+                entity2body: HashMap::default(),
+                entity2soft_body: HashMap::default(),
+                last_body_transform_set: HashMap::default(),
+            };
+            result.rebuild_entity_maps();
+            result
+        }
+    }
+}
diff --git a/bindings/bevy_rapier/src/plugin/context/systemparams/mod.rs b/bindings/bevy_rapier/src/plugin/context/systemparams/mod.rs
new file mode 100644
index 000000000..e86c90a4e
--- /dev/null
+++ b/bindings/bevy_rapier/src/plugin/context/systemparams/mod.rs
@@ -0,0 +1,21 @@
+//! Helper types to ease bevy_rapier API usage, grouping often used together components
+//! through [`bevy::ecs::query::QueryData`] or [`bevy::ecs::system::SystemParam`] to
+//! avoid writing too much boilerplate: shorter parameters for your systems,
+//! and pass less parameters to bey_rapier lower level functions.
+
+mod rapier_context_systemparam;
+
+use bevy::{ecs::query::QueryData, prelude::Entity};
+pub use rapier_context_systemparam::*;
+
+use super::RapierContextEntityLink;
+
+/// Information needed to access the rapier data from an entity managed by rapier.
+#[derive(QueryData)]
+pub struct RapierEntity {
+    /// This bevy [`Entity`].
+    pub entity: Entity,
+    /// Link to another bevy [`Entity`], which owns the context of this [`RapierEntity`]:
+    /// i.e. the relevant components from [`crate::plugin::context`].
+    pub rapier_context_link: &'static RapierContextEntityLink,
+}
diff --git a/bindings/bevy_rapier/src/plugin/context/systemparams/rapier_context_systemparam.rs b/bindings/bevy_rapier/src/plugin/context/systemparams/rapier_context_systemparam.rs
new file mode 100644
index 000000000..050e80839
--- /dev/null
+++ b/bindings/bevy_rapier/src/plugin/context/systemparams/rapier_context_systemparam.rs
@@ -0,0 +1,1903 @@
+use crate::math::{Rot, Vect};
+use bevy::ecs::{query, system::SystemParam};
+use bevy::prelude::*;
+use rapier::prelude::Real;
+
+pub(crate) const RAPIER_CONTEXT_EXPECT_ERROR: &str =
+    "RapierContextEntityLink.0 refers to an entity missing components from RapierContextSimulation.";
+
+use crate::plugin::context::{
+    DefaultRapierContext, RapierContextColliders, RapierContextJoints, RapierContextSimulation,
+    RapierQueryPipeline, RapierRigidBodySet,
+};
+
+/// Utility [`SystemParam`] to easily access every required components of a [`RapierContext`] immutably.
+///
+/// This uses the [`DefaultRapierContext`] filter by default, but you can use a custom query filter with the `T` type parameter.
+#[derive(SystemParam)]
+pub struct ReadRapierContext<'w, 's, T: query::QueryFilter + 'static = With<DefaultRapierContext>> {
+    /// The query used to feed components into [`RapierContext`] struct through [`ReadRapierContext::single`].
+    pub rapier_context: Query<
+        'w,
+        's,
+        (
+            &'static RapierContextSimulation,
+            &'static RapierContextColliders,
+            &'static RapierContextJoints,
+            &'static RapierRigidBodySet,
+        ),
+        T,
+    >,
+}
+
+impl<'w, 's, T: query::QueryFilter + 'static> ReadRapierContext<'w, 's, T> {
+    /// Returns a single [`RapierContext`] corresponding to the filter (T) of [`ReadRapierContext`].
+    ///
+    /// If the number of query items is not exactly one, a [`bevy::ecs::query::QuerySingleError`] is returned instead.
+    ///
+    /// You can also use the underlying query [`ReadRapierContext::rapier_context`] for finer grained queries.
+    pub fn single(&self) -> Result<RapierContext<'_>> {
+        let (simulation, colliders, joints, rigidbody_set) = self.rapier_context.single()?;
+        Ok(RapierContext {
+            simulation,
+            colliders,
+            joints,
+            rigidbody_set,
+        })
+    }
+}
+
+/// A helper struct to avoid passing too many parameters to most rapier functions.
+/// This helps with reducing boilerplate, at the (small) price of maybe getting too much information from the ECS.
+///
+/// Note: This is not a component, refer to [`ReadRapierContext`], [`WriteRapierContext`], or [`RapierContextSimulation`]
+#[cfg_attr(feature = "serde-serialize", derive(Serialize))]
+#[derive(query::QueryData)]
+pub struct RapierContext<'a> {
+    /// The Rapier context, containing all the state of the physics engine.
+    pub simulation: &'a RapierContextSimulation,
+    /// The set of colliders part of the simulation.
+    pub colliders: &'a RapierContextColliders,
+    /// The sets of joints part of the simulation.
+    pub joints: &'a RapierContextJoints,
+    /// The set of rigid-bodies part of the simulation.
+    pub rigidbody_set: &'a RapierRigidBodySet,
+}
+
+/// Utility [`SystemParam`] to easily access every required components of a [`RapierContext`] mutably.
+///
+/// This uses the [`DefaultRapierContext`] filter by default, but you can use a custom query filter with the `T` type parameter.
+#[derive(SystemParam)]
+pub struct WriteRapierContext<'w, 's, T: query::QueryFilter + 'static = With<DefaultRapierContext>>
+{
+    /// The query used to feed components into [`RapierContext`] struct through [`ReadRapierContext::single`].
+    pub rapier_context: Query<
+        'w,
+        's,
+        (
+            &'static mut RapierContextSimulation,
+            &'static mut RapierContextColliders,
+            &'static mut RapierContextJoints,
+            &'static mut RapierRigidBodySet,
+        ),
+        T,
+    >,
+}
+
+impl<'w, 's, T: query::QueryFilter + 'static> WriteRapierContext<'w, 's, T> {
+    /// Returns a single [`RapierContext`] corresponding to the filter (T) of [`WriteRapierContext`].
+    ///
+    /// If the number of query items is not exactly one, a [`bevy::ecs::query::QuerySingleError`] is returned instead.
+    ///
+    /// You can also use the underlying query [`WriteRapierContext::rapier_context`] for finer grained queries.
+    pub fn single(&self) -> Result<RapierContext<'_>> {
+        let (simulation, colliders, joints, rigidbody_set) = self.rapier_context.single()?;
+        Ok(RapierContext {
+            simulation,
+            colliders,
+            joints,
+            rigidbody_set,
+        })
+    }
+
+    /// Returns a single mutable [`RapierContextMut`] corresponding to the filter (T) of [`WriteRapierContext`].
+    ///
+    /// If the number of query items is not exactly one, a [`bevy::ecs::query::QuerySingleError`] is returned instead.
+    ///
+    /// You can also use the underlying query [`WriteRapierContext::rapier_context`] for finer grained queries.
+    pub fn single_mut(&mut self) -> Result<RapierContextMut<'_>> {
+        let (simulation, colliders, joints, rigidbody_set) = self.rapier_context.single_mut()?;
+        Ok(RapierContextMut {
+            simulation,
+            colliders,
+            joints,
+            rigidbody_set,
+        })
+    }
+}
+
+/// A helper struct to avoid passing too many parameters to most rapier functions.
+/// This helps with reducing boilerplate, at the (small) price of maybe getting too much information from the ECS.
+///
+/// If you need more granular control over mutability of each component, use a regular [`Query`]
+pub struct RapierContextMut<'a> {
+    /// The Rapier context, containing all the state of the physics engine.
+    pub simulation: Mut<'a, RapierContextSimulation>,
+    /// The set of colliders part of the simulation.
+    pub colliders: Mut<'a, RapierContextColliders>,
+    /// The sets of joints part of the simulation.
+    pub joints: Mut<'a, RapierContextJoints>,
+    /// The set of rigid-bodies part of the simulation.
+    pub rigidbody_set: Mut<'a, RapierRigidBodySet>,
+}
+
+/// [`RapierRigidBodySet`] functions
+mod simulation {
+    use crate::control::CharacterCollision;
+    use crate::control::MoveShapeOptions;
+    use crate::control::MoveShapeOutput;
+    use crate::geometry::AsShape;
+    use crate::plugin::context::SimulationToRenderTime;
+    use crate::plugin::ContactPairView;
+    use crate::plugin::{SimulationMode, TimestepMode};
+    use crate::prelude::CollisionEvent;
+    use crate::prelude::ContactForceEvent;
+    use crate::prelude::QueryFilter;
+    use crate::prelude::RapierRigidBodyHandle;
+    use crate::prelude::TransformInterpolation;
+    use rapier::prelude::PhysicsHooks;
+
+    use super::*;
+
+    /// [`RapierContextSimulation`] functions for immutable accesses
+    impl RapierContext<'_> {
+        /// Shortcut to [`RapierContextSimulation::contact_pair`].
+        pub fn contact_pair(
+            &self,
+            collider1: Entity,
+            collider2: Entity,
+        ) -> Option<ContactPairView<'_>> {
+            self.simulation
+                .contact_pair(self.colliders, self.rigidbody_set, collider1, collider2)
+        }
+
+        /// Shortcut to [`RapierContextSimulation::contact_pairs_with`].
+        pub fn contact_pairs_with(
+            &self,
+            collider: Entity,
+        ) -> impl Iterator<Item = ContactPairView<'_>> {
+            self.simulation
+                .contact_pairs_with(self.colliders, self.rigidbody_set, collider)
+        }
+
+        /// Shortcut to [`RapierContextSimulation::intersection_pair`].
+        pub fn intersection_pair(&self, collider1: Entity, collider2: Entity) -> Option<bool> {
+            self.simulation
+                .intersection_pair(self.colliders, collider1, collider2)
+        }
+
+        /// Shortcut to [`RapierContextSimulation::intersection_pairs_with`].
+        pub fn intersection_pairs_with(
+            &self,
+            collider: Entity,
+        ) -> impl Iterator<Item = (Entity, Entity, bool)> + '_ {
+            self.simulation
+                .intersection_pairs_with(self.colliders, collider)
+        }
+    }
+
+    /// [`RapierContextSimulation`] functions for mutable accesses
+    impl RapierContextMut<'_> {
+        /// Shortcut to [`RapierContextSimulation::step_simulation`].
+        #[expect(clippy::too_many_arguments)]
+        pub fn step_simulation(
+            &mut self,
+            gravity: Vect,
+            simulation_mode: SimulationMode,
+            timestep_mode: TimestepMode,
+            events: Option<(
+                &MessageWriter<CollisionEvent>,
+                &MessageWriter<ContactForceEvent>,
+            )>,
+            hooks: &dyn PhysicsHooks,
+            time: &Time,
+            sim_to_render_time: &mut SimulationToRenderTime,
+            interpolation_query: Option<
+                &mut Query<(&RapierRigidBodyHandle, &mut TransformInterpolation)>,
+            >,
+        ) {
+            self.simulation.step_simulation(
+                &mut self.colliders,
+                &mut self.joints,
+                &mut self.rigidbody_set,
+                gravity,
+                simulation_mode,
+                timestep_mode,
+                events,
+                hooks,
+                time,
+                sim_to_render_time,
+                interpolation_query,
+            )
+        }
+
+        /// Shortcut to [`RapierContextSimulation::move_shape`].
+        ///
+        /// The scene queries are filtered with `filter`, like the other scene queries of this
+        /// context.
+        #[expect(clippy::too_many_arguments)]
+        pub fn move_shape(
+            &mut self,
+            movement: Vect,
+            shape: &(impl AsShape + ?Sized),
+            shape_translation: Vect,
+            shape_rotation: Rot,
+            shape_mass: Real,
+            options: &MoveShapeOptions,
+            filter: QueryFilter,
+            events: impl FnMut(CharacterCollision),
+        ) -> MoveShapeOutput {
+            self.simulation.move_shape(
+                &mut self.colliders,
+                &mut self.rigidbody_set,
+                movement,
+                shape,
+                shape_translation,
+                shape_rotation,
+                shape_mass,
+                options,
+                filter,
+                events,
+            )
+        }
+
+        /// Shortcut to [`RapierContextSimulation::contact_pair`].
+        pub fn contact_pair(
+            &self,
+            collider1: Entity,
+            collider2: Entity,
+        ) -> Option<ContactPairView<'_>> {
+            self.simulation
+                .contact_pair(&self.colliders, &self.rigidbody_set, collider1, collider2)
+        }
+
+        /// Shortcut to [`RapierContextSimulation::contact_pairs_with`].
+        pub fn contact_pairs_with(
+            &self,
+            collider: Entity,
+        ) -> impl Iterator<Item = ContactPairView<'_>> {
+            self.simulation
+                .contact_pairs_with(&self.colliders, &self.rigidbody_set, collider)
+        }
+
+        /// Shortcut to [`RapierContextSimulation::intersection_pair`].
+        pub fn intersection_pair(&self, collider1: Entity, collider2: Entity) -> Option<bool> {
+            self.simulation
+                .intersection_pair(&self.colliders, collider1, collider2)
+        }
+
+        /// Shortcut to [`RapierContextSimulation::intersection_pairs_with`].
+        pub fn intersection_pairs_with(
+            &self,
+            collider: Entity,
+        ) -> impl Iterator<Item = (Entity, Entity, bool)> + '_ {
+            self.simulation
+                .intersection_pairs_with(&self.colliders, collider)
+        }
+    }
+}
+
+mod query_pipeline {
+    use rapier::{
+        geometry::Collider as RapierCollider,
+        parry::{partitioning::Bvh, query::ShapeCastOptions},
+        prelude::FeatureId,
+    };
+
+    use crate::geometry::AsShape;
+
+    use crate::prelude::{
+        NonlinearMotion, PointProjection, QueryFilter, RayIntersection, ShapeCastHit,
+        ShapeClosestPoints, ShapeContact,
+    };
+
+    use super::*;
+
+    impl RapierContext<'_> {
+        /// Shortcut to [RapierQueryPipeline::new_scoped].
+        pub fn with_query_pipeline<'a, T>(
+            &'a self,
+            filter: QueryFilter<'a>,
+            scoped_fn: impl FnOnce(RapierQueryPipeline<'_>) -> T,
+        ) -> T {
+            crate::prelude::RapierQueryPipeline::new_scoped(
+                &self.simulation.broad_phase,
+                self.colliders,
+                self.rigidbody_set,
+                &filter,
+                self.simulation.query_dispatcher(),
+                scoped_fn,
+            )
+        }
+        /// Shortcut to [`RapierQueryPipeline::cast_ray`].
+        pub fn cast_ray(
+            &self,
+            ray_origin: Vect,
+            ray_dir: Vect,
+            max_toi: Real,
+            solid: bool,
+            filter: QueryFilter,
+        ) -> Option<(Entity, Real)> {
+            self.with_query_pipeline(filter, |query_pipeline| {
+                query_pipeline.cast_ray(ray_origin, ray_dir, max_toi, solid)
+            })
+        }
+
+        /// Shortcut to [`RapierQueryPipeline::cast_ray_and_get_normal`].
+        pub fn cast_ray_and_get_normal(
+            &self,
+            ray_origin: Vect,
+            ray_dir: Vect,
+            max_toi: Real,
+            solid: bool,
+            filter: QueryFilter,
+        ) -> Option<(Entity, RayIntersection)> {
+            self.with_query_pipeline(filter, |query_pipeline| {
+                query_pipeline.cast_ray_and_get_normal(ray_origin, ray_dir, max_toi, solid)
+            })
+        }
+
+        /// Shortcut to [`RapierQueryPipeline::intersect_point`].
+        ///
+        /// Stops the query if `callback` returns false.
+        pub fn intersect_point(
+            &self,
+            point: Vect,
+            filter: QueryFilter,
+            mut callback: impl FnMut(Entity, &RapierCollider) -> bool,
+        ) {
+            self.with_query_pipeline(filter, |query_pipeline| {
+                for (e, co) in query_pipeline.intersect_point(point) {
+                    if !callback(e, co) {
+                        break;
+                    }
+                }
+            });
+        }
+
+        /// Shortcut to [`RapierQueryPipeline::intersect_ray`].
+        ///
+        /// Stops the query if `callback` returns false.
+        pub fn intersect_ray(
+            &self,
+            ray_origin: Vect,
+            ray_dir: Vect,
+            max_toi: Real,
+            solid: bool,
+            filter: QueryFilter,
+            mut callback: impl FnMut(Entity, &RapierCollider, RayIntersection) -> bool,
+        ) {
+            self.with_query_pipeline(filter, |query_pipeline| {
+                for (e, co, intersection) in
+                    query_pipeline.intersect_ray(ray_origin, ray_dir, max_toi, solid)
+                {
+                    if !callback(e, co, intersection) {
+                        break;
+                    }
+                }
+            });
+        }
+
+        /// Shortcut to [`RapierQueryPipeline::intersect_shape`].
+        pub fn intersect_shape(
+            &self,
+            shape_pos: Vect,
+            shape_rot: Rot,
+            shape: &(impl AsShape + ?Sized),
+            filter: QueryFilter,
+            mut callback: impl FnMut(Entity, &RapierCollider) -> bool,
+        ) {
+            self.with_query_pipeline(filter, |query_pipeline| {
+                for (e, co) in query_pipeline.intersect_shape(shape_pos, shape_rot, shape) {
+                    if !callback(e, co) {
+                        break;
+                    }
+                }
+            });
+        }
+
+        /// Shortcut to [`RapierQueryPipeline::intersect_aabb_conservative`].
+        pub fn intersect_aabb_conservative(
+            &self,
+            #[cfg(feature = "dim2")] aabb: bevy::shape::Aabb2d,
+            #[cfg(feature = "dim3")] aabb: bevy::shape::Aabb3d,
+            filter: QueryFilter,
+            mut callback: impl FnMut(Entity, &RapierCollider) -> bool,
+        ) {
+            self.with_query_pipeline(filter, |query_pipeline| {
+                for (e, co) in query_pipeline.intersect_aabb_conservative(aabb) {
+                    if !callback(e, co) {
+                        break;
+                    }
+                }
+            });
+        }
+
+        /// Shortcut to [`RapierQueryPipeline::cast_shape`].
+        pub fn cast_shape(
+            &self,
+            shape_pos: Vect,
+            shape_rot: Rot,
+            shape_vel: Vect,
+            shape: &(impl AsShape + ?Sized),
+            options: ShapeCastOptions,
+            filter: QueryFilter,
+        ) -> Option<(Entity, ShapeCastHit)> {
+            self.with_query_pipeline(filter, |query_pipeline| {
+                query_pipeline.cast_shape(shape_pos, shape_rot, shape_vel, shape, options)
+            })
+        }
+
+        /// Shortcut to [`RapierQueryPipeline::project_point`].
+        pub fn project_point(
+            &self,
+            point: Vect,
+            max_dist: f32,
+            solid: bool,
+            filter: QueryFilter,
+        ) -> Option<(Entity, PointProjection)> {
+            self.with_query_pipeline(filter, |query_pipeline| {
+                query_pipeline.project_point(point, max_dist, solid)
+            })
+        }
+    }
+
+    impl RapierContext<'_> {
+        /// Shortcut to [`RapierQueryPipeline::project_point_and_get_feature`].
+        pub fn project_point_and_get_feature(
+            &self,
+            point: Vect,
+            max_dist: Real,
+            filter: QueryFilter,
+        ) -> Option<(Entity, PointProjection, FeatureId)> {
+            self.with_query_pipeline(filter, |query_pipeline| {
+                query_pipeline.project_point_and_get_feature(point, max_dist)
+            })
+        }
+
+        /// Shortcut to [`RapierQueryPipeline::cast_shape_nonlinear`].
+        pub fn cast_shape_nonlinear(
+            &self,
+            shape_motion: &NonlinearMotion,
+            shape: &(impl AsShape + ?Sized),
+            start_time: Real,
+            end_time: Real,
+            stop_at_penetration: bool,
+            filter: QueryFilter,
+        ) -> Option<(Entity, ShapeCastHit)> {
+            self.with_query_pipeline(filter, |query_pipeline| {
+                query_pipeline.cast_shape_nonlinear(
+                    shape_motion,
+                    shape,
+                    start_time,
+                    end_time,
+                    stop_at_penetration,
+                )
+            })
+        }
+
+        /// Shortcut to [`RapierQueryPipeline::distance_to_shape`].
+        pub fn distance_to_shape(
+            &self,
+            shape_pos: Vect,
+            shape_rot: Rot,
+            shape: &(impl AsShape + ?Sized),
+            filter: QueryFilter,
+        ) -> Option<(Entity, Real)> {
+            self.with_query_pipeline(filter, |query_pipeline| {
+                query_pipeline.distance_to_shape(shape_pos, shape_rot, shape)
+            })
+        }
+
+        /// Shortcut to [`RapierQueryPipeline::closest_points_to_shape`].
+        pub fn closest_points_to_shape(
+            &self,
+            shape_pos: Vect,
+            shape_rot: Rot,
+            shape: &(impl AsShape + ?Sized),
+            max_dist: Real,
+            filter: QueryFilter,
+        ) -> Option<(Entity, ShapeClosestPoints)> {
+            self.with_query_pipeline(filter, |query_pipeline| {
+                query_pipeline.closest_points_to_shape(shape_pos, shape_rot, shape, max_dist)
+            })
+        }
+
+        /// Shortcut to [`RapierQueryPipeline::contact_with_shape`].
+        pub fn contact_with_shape(
+            &self,
+            shape_pos: Vect,
+            shape_rot: Rot,
+            shape: &(impl AsShape + ?Sized),
+            prediction: Real,
+            filter: QueryFilter,
+        ) -> Option<(Entity, ShapeContact)> {
+            self.with_query_pipeline(filter, |query_pipeline| {
+                query_pipeline.contact_with_shape(shape_pos, shape_rot, shape, prediction)
+            })
+        }
+
+        /// Shortcut to [`RapierQueryPipeline::bvh`].
+        pub fn bvh(&self) -> &Bvh {
+            self.simulation
+                .broad_phase
+                .as_query_pipeline(
+                    self.simulation.query_dispatcher(),
+                    &self.rigidbody_set.bodies,
+                    &self.colliders.colliders,
+                    Default::default(),
+                )
+                .bvh
+        }
+    }
+
+    impl RapierContextMut<'_> {
+        /// Reborrows this context immutably.
+        fn as_read(&self) -> RapierContext<'_> {
+            RapierContext {
+                simulation: &self.simulation,
+                colliders: &self.colliders,
+                joints: &self.joints,
+                rigidbody_set: &self.rigidbody_set,
+            }
+        }
+
+        /// Shortcut to [`RapierQueryPipeline::project_point_and_get_feature`].
+        pub fn project_point_and_get_feature(
+            &self,
+            point: Vect,
+            max_dist: Real,
+            filter: QueryFilter,
+        ) -> Option<(Entity, PointProjection, FeatureId)> {
+            self.as_read()
+                .project_point_and_get_feature(point, max_dist, filter)
+        }
+
+        /// Shortcut to [`RapierQueryPipeline::cast_shape_nonlinear`].
+        pub fn cast_shape_nonlinear(
+            &self,
+            shape_motion: &NonlinearMotion,
+            shape: &(impl AsShape + ?Sized),
+            start_time: Real,
+            end_time: Real,
+            stop_at_penetration: bool,
+            filter: QueryFilter,
+        ) -> Option<(Entity, ShapeCastHit)> {
+            self.as_read().cast_shape_nonlinear(
+                shape_motion,
+                shape,
+                start_time,
+                end_time,
+                stop_at_penetration,
+                filter,
+            )
+        }
+
+        /// Shortcut to [`RapierQueryPipeline::distance_to_shape`].
+        pub fn distance_to_shape(
+            &self,
+            shape_pos: Vect,
+            shape_rot: Rot,
+            shape: &(impl AsShape + ?Sized),
+            filter: QueryFilter,
+        ) -> Option<(Entity, Real)> {
+            self.as_read()
+                .distance_to_shape(shape_pos, shape_rot, shape, filter)
+        }
+
+        /// Shortcut to [`RapierQueryPipeline::closest_points_to_shape`].
+        pub fn closest_points_to_shape(
+            &self,
+            shape_pos: Vect,
+            shape_rot: Rot,
+            shape: &(impl AsShape + ?Sized),
+            max_dist: Real,
+            filter: QueryFilter,
+        ) -> Option<(Entity, ShapeClosestPoints)> {
+            self.as_read()
+                .closest_points_to_shape(shape_pos, shape_rot, shape, max_dist, filter)
+        }
+
+        /// Shortcut to [`RapierQueryPipeline::contact_with_shape`].
+        pub fn contact_with_shape(
+            &self,
+            shape_pos: Vect,
+            shape_rot: Rot,
+            shape: &(impl AsShape + ?Sized),
+            prediction: Real,
+            filter: QueryFilter,
+        ) -> Option<(Entity, ShapeContact)> {
+            self.as_read()
+                .contact_with_shape(shape_pos, shape_rot, shape, prediction, filter)
+        }
+
+        /// Shortcut to [`RapierQueryPipeline::bvh`].
+        pub fn bvh(&self) -> &Bvh {
+            self.simulation
+                .broad_phase
+                .as_query_pipeline(
+                    self.simulation.query_dispatcher(),
+                    &self.rigidbody_set.bodies,
+                    &self.colliders.colliders,
+                    Default::default(),
+                )
+                .bvh
+        }
+    }
+
+    // Copied from `RapierContext`.
+    impl RapierContextMut<'_> {
+        /// Shortcut to [`RapierQueryPipeline::cast_ray`].
+        pub fn cast_ray(
+            &self,
+            ray_origin: Vect,
+            ray_dir: Vect,
+            max_toi: Real,
+            solid: bool,
+            filter: QueryFilter,
+        ) -> Option<(Entity, Real)> {
+            self.with_query_pipeline(filter, |query_pipeline| {
+                query_pipeline.cast_ray(ray_origin, ray_dir, max_toi, solid)
+            })
+        }
+
+        /// Shortcut to [`RapierQueryPipeline::cast_ray_and_get_normal`].
+        pub fn cast_ray_and_get_normal(
+            &self,
+            ray_origin: Vect,
+            ray_dir: Vect,
+            max_toi: Real,
+            solid: bool,
+            filter: QueryFilter,
+        ) -> Option<(Entity, RayIntersection)> {
+            self.with_query_pipeline(filter, |query_pipeline| {
+                query_pipeline.cast_ray_and_get_normal(ray_origin, ray_dir, max_toi, solid)
+            })
+        }
+
+        /// Shortcut to [`RapierQueryPipeline::intersect_point`].
+        ///
+        /// Stops the query if `callback` returns false.
+        pub fn intersect_point(
+            &self,
+            point: Vect,
+            filter: QueryFilter,
+            mut callback: impl FnMut(Entity, &RapierCollider) -> bool,
+        ) {
+            self.with_query_pipeline(filter, |query_pipeline| {
+                for (e, co) in query_pipeline.intersect_point(point) {
+                    if !callback(e, co) {
+                        break;
+                    }
+                }
+            });
+        }
+
+        /// Shortcut to [`RapierQueryPipeline::intersect_ray`].
+        ///
+        /// Stops the query if `callback` returns false.
+        pub fn intersect_ray(
+            &self,
+            ray_origin: Vect,
+            ray_dir: Vect,
+            max_toi: Real,
+            solid: bool,
+            filter: QueryFilter,
+            mut callback: impl FnMut(Entity, &RapierCollider, RayIntersection) -> bool,
+        ) {
+            self.with_query_pipeline(filter, |query_pipeline| {
+                for (e, co, intersection) in
+                    query_pipeline.intersect_ray(ray_origin, ray_dir, max_toi, solid)
+                {
+                    if !callback(e, co, intersection) {
+                        break;
+                    }
+                }
+            });
+        }
+
+        /// Shortcut to [`RapierQueryPipeline::intersect_shape`].
+        pub fn intersect_shape(
+            &self,
+            shape_pos: Vect,
+            shape_rot: Rot,
+            shape: &(impl AsShape + ?Sized),
+            filter: QueryFilter,
+            mut callback: impl FnMut(Entity, &RapierCollider) -> bool,
+        ) {
+            self.with_query_pipeline(filter, |query_pipeline| {
+                for (e, co) in query_pipeline.intersect_shape(shape_pos, shape_rot, shape) {
+                    if !callback(e, co) {
+                        break;
+                    }
+                }
+            });
+        }
+
+        /// Shortcut to [`RapierQueryPipeline::intersect_aabb_conservative`].
+        pub fn intersect_aabb_conservative(
+            &self,
+            #[cfg(feature = "dim2")] aabb: bevy::shape::Aabb2d,
+            #[cfg(feature = "dim3")] aabb: bevy::shape::Aabb3d,
+            filter: QueryFilter,
+            mut callback: impl FnMut(Entity, &RapierCollider) -> bool,
+        ) {
+            self.with_query_pipeline(filter, |query_pipeline| {
+                for (e, co) in query_pipeline.intersect_aabb_conservative(aabb) {
+                    if !callback(e, co) {
+                        break;
+                    }
+                }
+            });
+        }
+
+        /// Shortcut to [`RapierQueryPipeline::cast_shape`].
+        pub fn cast_shape(
+            &self,
+            shape_pos: Vect,
+            shape_rot: Rot,
+            shape_vel: Vect,
+            shape: &(impl AsShape + ?Sized),
+            options: ShapeCastOptions,
+            filter: QueryFilter,
+        ) -> Option<(Entity, ShapeCastHit)> {
+            self.with_query_pipeline(filter, |query_pipeline| {
+                query_pipeline.cast_shape(shape_pos, shape_rot, shape_vel, shape, options)
+            })
+        }
+
+        /// Shortcut to [`RapierQueryPipeline::project_point`].
+        pub fn project_point(
+            &self,
+            point: Vect,
+            max_dist: f32,
+            solid: bool,
+            filter: QueryFilter,
+        ) -> Option<(Entity, PointProjection)> {
+            self.with_query_pipeline(filter, |query_pipeline| {
+                query_pipeline.project_point(point, max_dist, solid)
+            })
+        }
+    }
+
+    impl RapierContextMut<'_> {
+        /// Shortcut to [RapierQueryPipeline::new_scoped].
+        pub fn with_query_pipeline<'a, T>(
+            &'a self,
+            filter: QueryFilter<'a>,
+            scoped_fn: impl FnOnce(RapierQueryPipeline<'_>) -> T,
+        ) -> T {
+            crate::prelude::RapierQueryPipeline::new_scoped(
+                &self.simulation.broad_phase,
+                &self.colliders,
+                &self.rigidbody_set,
+                &filter,
+                self.simulation.query_dispatcher(),
+                scoped_fn,
+            )
+        }
+    }
+}
+
+mod rigidbody_set {
+    use std::collections::HashMap;
+
+    use super::*;
+    pub use rapier::prelude::RigidBodyHandle;
+
+    impl RapierContext<'_> {
+        /// Shortcut to [`RapierRigidBodySet::entity2body`].
+        pub fn entity2body(&self) -> &HashMap<Entity, RigidBodyHandle> {
+            self.rigidbody_set.entity2body()
+        }
+
+        /// Shortcut to [`RapierRigidBodySet::rigid_body_entity`].
+        pub fn rigid_body_entity(&self, handle: RigidBodyHandle) -> Option<Entity> {
+            self.rigidbody_set.rigid_body_entity(handle)
+        }
+
+        /// Shortcut to [`RapierRigidBodySet::impulse_revolute_joint_angle`].
+        pub fn impulse_revolute_joint_angle(&self, entity: Entity) -> Option<f32> {
+            self.rigidbody_set
+                .impulse_revolute_joint_angle(self.joints, entity)
+        }
+    }
+
+    impl RapierContextMut<'_> {
+        /// Shortcut to [`RapierRigidBodySet::propagate_modified_body_positions_to_colliders`].
+        pub fn propagate_modified_body_positions_to_colliders(&mut self) {
+            self.rigidbody_set
+                .propagate_modified_body_positions_to_colliders(&mut self.colliders)
+        }
+
+        /// Shortcut to [`RapierRigidBodySet::entity2body`].
+        pub fn entity2body(&self) -> &HashMap<Entity, RigidBodyHandle> {
+            self.rigidbody_set.entity2body()
+        }
+
+        /// Shortcut to [`RapierRigidBodySet::rigid_body_entity`].
+        pub fn rigid_body_entity(&self, handle: RigidBodyHandle) -> Option<Entity> {
+            self.rigidbody_set.rigid_body_entity(handle)
+        }
+
+        /// Shortcut to [`RapierRigidBodySet::impulse_revolute_joint_angle`].
+        pub fn impulse_revolute_joint_angle(&self, entity: Entity) -> Option<f32> {
+            self.rigidbody_set
+                .impulse_revolute_joint_angle(&self.joints, entity)
+        }
+    }
+}
+
+mod soft_bodies {
+    use super::*;
+    use crate::dynamics::RapierSoftBody;
+    use crate::pipeline::SoftBodyTearResult;
+    use rapier::dynamics::{RigidBodyHandle, SoftBodyHandle};
+    use std::collections::HashMap;
+
+    impl RapierContext<'_> {
+        /// Shortcut to [`RapierRigidBodySet::entity2soft_body`].
+        pub fn entity2soft_body(&self) -> &HashMap<Entity, SoftBodyHandle> {
+            self.rigidbody_set.entity2soft_body()
+        }
+
+        /// Shortcut to [`RapierRigidBodySet::soft_body_entity`].
+        pub fn soft_body_entity(&self, handle: SoftBodyHandle) -> Option<Entity> {
+            self.rigidbody_set.soft_body_entity(handle)
+        }
+
+        /// Shortcut to [`RapierRigidBodySet::soft_body`].
+        pub fn soft_body(&self, entity: Entity) -> Option<&RapierSoftBody> {
+            self.rigidbody_set.soft_body(entity)
+        }
+
+        /// Shortcut to [`RapierRigidBodySet::soft_body_particle_positions`].
+        pub fn soft_body_particle_positions(
+            &self,
+            entity: Entity,
+        ) -> Option<impl ExactSizeIterator<Item = Vect> + '_> {
+            self.rigidbody_set.soft_body_particle_positions(entity)
+        }
+
+        /// Shortcut to [`RapierRigidBodySet::soft_body_particle_velocities`].
+        pub fn soft_body_particle_velocities(
+            &self,
+            entity: Entity,
+        ) -> Option<impl ExactSizeIterator<Item = Vect> + '_> {
+            self.rigidbody_set.soft_body_particle_velocities(entity)
+        }
+
+        /// Shortcut to [`RapierRigidBodySet::soft_body_volume`].
+        pub fn soft_body_volume(&self, entity: Entity) -> Option<Real> {
+            self.rigidbody_set.soft_body_volume(entity)
+        }
+
+        /// Shortcut to [`RapierRigidBodySet::soft_body_mass`].
+        pub fn soft_body_mass(&self, entity: Entity) -> Option<Real> {
+            self.rigidbody_set.soft_body_mass(entity)
+        }
+
+        /// Shortcut to [`RapierRigidBodySet::soft_body_center_of_mass`].
+        pub fn soft_body_center_of_mass(&self, entity: Entity) -> Option<Vect> {
+            self.rigidbody_set.soft_body_center_of_mass(entity)
+        }
+
+        /// Shortcut to [`RapierRigidBodySet::is_soft_body_sleeping`].
+        pub fn is_soft_body_sleeping(&self, entity: Entity) -> Option<bool> {
+            self.rigidbody_set.is_soft_body_sleeping(entity)
+        }
+
+        /// Shortcut to [`RapierRigidBodySet::soft_body_whole_proxy`].
+        pub fn soft_body_whole_proxy(&self, entity: Entity) -> Option<RigidBodyHandle> {
+            self.rigidbody_set.soft_body_whole_proxy(entity)
+        }
+
+        /// Shortcut to [`RapierRigidBodySet::soft_body_cluster_index`].
+        pub fn soft_body_cluster_index(&self, entity: Entity) -> Option<(SoftBodyHandle, u32)> {
+            self.rigidbody_set.soft_body_cluster_index(entity)
+        }
+    }
+
+    impl RapierContextMut<'_> {
+        /// Shortcut to [`RapierRigidBodySet::entity2soft_body`].
+        pub fn entity2soft_body(&self) -> &HashMap<Entity, SoftBodyHandle> {
+            self.rigidbody_set.entity2soft_body()
+        }
+
+        /// Shortcut to [`RapierRigidBodySet::soft_body_entity`].
+        pub fn soft_body_entity(&self, handle: SoftBodyHandle) -> Option<Entity> {
+            self.rigidbody_set.soft_body_entity(handle)
+        }
+
+        /// Shortcut to [`RapierRigidBodySet::soft_body`].
+        pub fn soft_body(&self, entity: Entity) -> Option<&RapierSoftBody> {
+            self.rigidbody_set.soft_body(entity)
+        }
+
+        /// Shortcut to [`RapierRigidBodySet::soft_body_particle_positions`].
+        pub fn soft_body_particle_positions(
+            &self,
+            entity: Entity,
+        ) -> Option<impl ExactSizeIterator<Item = Vect> + '_> {
+            self.rigidbody_set.soft_body_particle_positions(entity)
+        }
+
+        /// Shortcut to [`RapierRigidBodySet::soft_body_particle_velocities`].
+        pub fn soft_body_particle_velocities(
+            &self,
+            entity: Entity,
+        ) -> Option<impl ExactSizeIterator<Item = Vect> + '_> {
+            self.rigidbody_set.soft_body_particle_velocities(entity)
+        }
+
+        /// Shortcut to [`RapierRigidBodySet::soft_body_volume`].
+        pub fn soft_body_volume(&self, entity: Entity) -> Option<Real> {
+            self.rigidbody_set.soft_body_volume(entity)
+        }
+
+        /// Shortcut to [`RapierRigidBodySet::soft_body_mass`].
+        pub fn soft_body_mass(&self, entity: Entity) -> Option<Real> {
+            self.rigidbody_set.soft_body_mass(entity)
+        }
+
+        /// Shortcut to [`RapierRigidBodySet::soft_body_center_of_mass`].
+        pub fn soft_body_center_of_mass(&self, entity: Entity) -> Option<Vect> {
+            self.rigidbody_set.soft_body_center_of_mass(entity)
+        }
+
+        /// Shortcut to [`RapierRigidBodySet::is_soft_body_sleeping`].
+        pub fn is_soft_body_sleeping(&self, entity: Entity) -> Option<bool> {
+            self.rigidbody_set.is_soft_body_sleeping(entity)
+        }
+
+        /// Shortcut to [`RapierRigidBodySet::soft_body_whole_proxy`].
+        pub fn soft_body_whole_proxy(&self, entity: Entity) -> Option<RigidBodyHandle> {
+            self.rigidbody_set.soft_body_whole_proxy(entity)
+        }
+
+        /// Shortcut to [`RapierRigidBodySet::soft_body_cluster_index`].
+        pub fn soft_body_cluster_index(&self, entity: Entity) -> Option<(SoftBodyHandle, u32)> {
+            self.rigidbody_set.soft_body_cluster_index(entity)
+        }
+
+        /// Shortcut to [`RapierRigidBodySet::soft_body_mut`].
+        pub fn soft_body_mut(&mut self, entity: Entity) -> Option<&mut RapierSoftBody> {
+            self.rigidbody_set.soft_body_mut(entity)
+        }
+
+        /// Shortcut to [`RapierRigidBodySet::wake_up_soft_body`].
+        pub fn wake_up_soft_body(&mut self, entity: Entity, strong: bool) -> bool {
+            self.rigidbody_set.wake_up_soft_body(entity, strong)
+        }
+
+        /// Shortcut to [`RapierContextSimulation::tear_soft_body`].
+        pub fn tear_soft_body(
+            &mut self,
+            commands: &mut Commands,
+            entity: Entity,
+            edges: &[u32],
+            cells: &[u32],
+        ) -> Option<SoftBodyTearResult> {
+            self.simulation.tear_soft_body(
+                &mut self.colliders,
+                &mut self.joints,
+                &mut self.rigidbody_set,
+                commands,
+                entity,
+                edges,
+                cells,
+            )
+        }
+
+        /// Shortcut to [`RapierContextSimulation::cut_soft_body`].
+        pub fn cut_soft_body(
+            &mut self,
+            commands: &mut Commands,
+            entity: Entity,
+            blade: &[Vect; rapier::math::DIM],
+        ) -> Option<SoftBodyTearResult> {
+            self.simulation.cut_soft_body(
+                &mut self.colliders,
+                &mut self.joints,
+                &mut self.rigidbody_set,
+                commands,
+                entity,
+                blade,
+            )
+        }
+    }
+}
+
+mod joints {
+    use super::*;
+    use crate::dynamics::{ImpulseJointImpulses, InverseKinematicsOption, MultibodyJointState};
+    use rapier::dynamics::Multibody;
+    use rapier::math::Jacobian;
+    use std::ops::Range;
+
+    impl RapierContext<'_> {
+        /// Shortcut to [`RapierContextJoints::impulse_joint_impulses`].
+        pub fn impulse_joint_impulses(&self, entity: Entity) -> Option<ImpulseJointImpulses> {
+            self.joints.impulse_joint_impulses(entity)
+        }
+
+        /// Shortcut to [`RapierContextJoints::impulse_joints_between`].
+        pub fn impulse_joints_between(
+            &self,
+            body1: Entity,
+            body2: Entity,
+        ) -> impl Iterator<Item = Entity> + '_ {
+            self.joints
+                .impulse_joints_between(self.rigidbody_set, body1, body2)
+        }
+
+        /// Shortcut to [`RapierContextJoints::attached_impulse_joints`].
+        pub fn attached_impulse_joints(&self, body: Entity) -> impl Iterator<Item = Entity> + '_ {
+            self.joints
+                .attached_impulse_joints(self.rigidbody_set, body)
+        }
+
+        /// Shortcut to [`RapierContextJoints::attached_enabled_impulse_joints`].
+        pub fn attached_enabled_impulse_joints(
+            &self,
+            body: Entity,
+        ) -> impl Iterator<Item = Entity> + '_ {
+            self.joints
+                .attached_enabled_impulse_joints(self.rigidbody_set, body)
+        }
+
+        /// Shortcut to [`RapierContextJoints::multibody`].
+        pub fn multibody(&self, entity: Entity) -> Option<(&Multibody, usize)> {
+            self.joints.multibody(self.rigidbody_set, entity)
+        }
+
+        /// Shortcut to [`RapierContextJoints::multibody_root`].
+        pub fn multibody_root(&self, entity: Entity) -> Option<Entity> {
+            self.joints.multibody_root(self.rigidbody_set, entity)
+        }
+
+        /// Shortcut to [`RapierContextJoints::multibody_links`].
+        pub fn multibody_links(&self, entity: Entity) -> impl Iterator<Item = Entity> + '_ {
+            self.joints.multibody_links(self.rigidbody_set, entity)
+        }
+
+        /// Shortcut to [`RapierContextJoints::multibody_parent_link`].
+        pub fn multibody_parent_link(&self, entity: Entity) -> Option<Entity> {
+            self.joints
+                .multibody_parent_link(self.rigidbody_set, entity)
+        }
+
+        /// Shortcut to [`RapierContextJoints::multibody_joint_between`].
+        pub fn multibody_joint_between(&self, body1: Entity, body2: Entity) -> Option<Entity> {
+            self.joints
+                .multibody_joint_between(self.rigidbody_set, body1, body2)
+        }
+
+        /// Shortcut to [`RapierContextJoints::attached_multibody_joints`].
+        pub fn attached_multibody_joints(&self, body: Entity) -> impl Iterator<Item = Entity> + '_ {
+            self.joints
+                .attached_multibody_joints(self.rigidbody_set, body)
+        }
+
+        /// Shortcut to [`RapierContextJoints::multibody_link_dofs`].
+        pub fn multibody_link_dofs(&self, entity: Entity) -> Option<Range<usize>> {
+            self.joints.multibody_link_dofs(self.rigidbody_set, entity)
+        }
+
+        /// Shortcut to [`RapierContextJoints::multibody_generalized_velocity`].
+        pub fn multibody_generalized_velocity(&self, entity: Entity) -> Option<&[Real]> {
+            self.joints
+                .multibody_generalized_velocity(self.rigidbody_set, entity)
+        }
+
+        /// Shortcut to [`RapierContextJoints::multibody_joint_state`].
+        pub fn multibody_joint_state(&self, entity: Entity) -> Option<MultibodyJointState> {
+            self.joints.multibody_joint_state(entity)
+        }
+
+        /// Shortcut to [`RapierContextJoints::multibody_body_jacobian`].
+        pub fn multibody_body_jacobian(&self, entity: Entity) -> Option<&Jacobian<Real>> {
+            self.joints
+                .multibody_body_jacobian(self.rigidbody_set, entity)
+        }
+
+        /// Shortcut to [`RapierContextJoints::multibody_inverse_kinematics`].
+        pub fn multibody_inverse_kinematics(
+            &self,
+            link: Entity,
+            target: Transform,
+            options: &InverseKinematicsOption,
+            joint_can_move: impl Fn(Entity) -> bool,
+            displacements: &mut Vec<Real>,
+        ) -> bool {
+            self.joints.multibody_inverse_kinematics(
+                self.rigidbody_set,
+                link,
+                target,
+                options,
+                joint_can_move,
+                displacements,
+            )
+        }
+    }
+
+    impl RapierContextMut<'_> {
+        /// Shortcut to [`RapierContextJoints::impulse_joint_impulses`].
+        pub fn impulse_joint_impulses(&self, entity: Entity) -> Option<ImpulseJointImpulses> {
+            self.joints.impulse_joint_impulses(entity)
+        }
+
+        /// Shortcut to [`RapierContextJoints::impulse_joints_between`].
+        pub fn impulse_joints_between(
+            &self,
+            body1: Entity,
+            body2: Entity,
+        ) -> impl Iterator<Item = Entity> + '_ {
+            self.joints
+                .impulse_joints_between(&self.rigidbody_set, body1, body2)
+        }
+
+        /// Shortcut to [`RapierContextJoints::attached_impulse_joints`].
+        pub fn attached_impulse_joints(&self, body: Entity) -> impl Iterator<Item = Entity> + '_ {
+            self.joints
+                .attached_impulse_joints(&self.rigidbody_set, body)
+        }
+
+        /// Shortcut to [`RapierContextJoints::attached_enabled_impulse_joints`].
+        pub fn attached_enabled_impulse_joints(
+            &self,
+            body: Entity,
+        ) -> impl Iterator<Item = Entity> + '_ {
+            self.joints
+                .attached_enabled_impulse_joints(&self.rigidbody_set, body)
+        }
+
+        /// Shortcut to [`RapierContextJoints::multibody`].
+        pub fn multibody(&self, entity: Entity) -> Option<(&Multibody, usize)> {
+            self.joints.multibody(&self.rigidbody_set, entity)
+        }
+
+        /// Shortcut to [`RapierContextJoints::multibody_root`].
+        pub fn multibody_root(&self, entity: Entity) -> Option<Entity> {
+            self.joints.multibody_root(&self.rigidbody_set, entity)
+        }
+
+        /// Shortcut to [`RapierContextJoints::multibody_links`].
+        pub fn multibody_links(&self, entity: Entity) -> impl Iterator<Item = Entity> + '_ {
+            self.joints.multibody_links(&self.rigidbody_set, entity)
+        }
+
+        /// Shortcut to [`RapierContextJoints::multibody_parent_link`].
+        pub fn multibody_parent_link(&self, entity: Entity) -> Option<Entity> {
+            self.joints
+                .multibody_parent_link(&self.rigidbody_set, entity)
+        }
+
+        /// Shortcut to [`RapierContextJoints::multibody_joint_between`].
+        pub fn multibody_joint_between(&self, body1: Entity, body2: Entity) -> Option<Entity> {
+            self.joints
+                .multibody_joint_between(&self.rigidbody_set, body1, body2)
+        }
+
+        /// Shortcut to [`RapierContextJoints::attached_multibody_joints`].
+        pub fn attached_multibody_joints(&self, body: Entity) -> impl Iterator<Item = Entity> + '_ {
+            self.joints
+                .attached_multibody_joints(&self.rigidbody_set, body)
+        }
+
+        /// Shortcut to [`RapierContextJoints::multibody_link_dofs`].
+        pub fn multibody_link_dofs(&self, entity: Entity) -> Option<Range<usize>> {
+            self.joints.multibody_link_dofs(&self.rigidbody_set, entity)
+        }
+
+        /// Shortcut to [`RapierContextJoints::multibody_generalized_velocity`].
+        pub fn multibody_generalized_velocity(&self, entity: Entity) -> Option<&[Real]> {
+            self.joints
+                .multibody_generalized_velocity(&self.rigidbody_set, entity)
+        }
+
+        /// Shortcut to [`RapierContextJoints::multibody_joint_state`].
+        pub fn multibody_joint_state(&self, entity: Entity) -> Option<MultibodyJointState> {
+            self.joints.multibody_joint_state(entity)
+        }
+
+        /// Shortcut to [`RapierContextJoints::multibody_body_jacobian`].
+        pub fn multibody_body_jacobian(&self, entity: Entity) -> Option<&Jacobian<Real>> {
+            self.joints
+                .multibody_body_jacobian(&self.rigidbody_set, entity)
+        }
+
+        /// Shortcut to [`RapierContextJoints::multibody_inverse_kinematics`].
+        pub fn multibody_inverse_kinematics(
+            &self,
+            link: Entity,
+            target: Transform,
+            options: &InverseKinematicsOption,
+            joint_can_move: impl Fn(Entity) -> bool,
+            displacements: &mut Vec<Real>,
+        ) -> bool {
+            self.joints.multibody_inverse_kinematics(
+                &self.rigidbody_set,
+                link,
+                target,
+                options,
+                joint_can_move,
+                displacements,
+            )
+        }
+
+        /// Shortcut to [`RapierContextJoints::multibody_mut`].
+        pub fn multibody_mut(&mut self, entity: Entity) -> Option<(&mut Multibody, usize)> {
+            self.joints.multibody_mut(&self.rigidbody_set, entity)
+        }
+
+        /// Shortcut to [`RapierContextJoints::multibody_generalized_velocity_mut`].
+        pub fn multibody_generalized_velocity_mut(
+            &mut self,
+            entity: Entity,
+        ) -> Option<&mut [Real]> {
+            self.joints
+                .multibody_generalized_velocity_mut(&mut self.rigidbody_set, entity)
+        }
+
+        /// Shortcut to [`RapierContextJoints::multibody_joint_velocity_mut`].
+        pub fn multibody_joint_velocity_mut(&mut self, entity: Entity) -> Option<&mut [Real]> {
+            self.joints
+                .multibody_joint_velocity_mut(&mut self.rigidbody_set, entity)
+        }
+
+        /// Shortcut to [`RapierContextJoints::multibody_apply_displacements`].
+        pub fn multibody_apply_displacements(
+            &mut self,
+            entity: Entity,
+            displacements: &[Real],
+        ) -> bool {
+            self.joints
+                .multibody_apply_displacements(&self.rigidbody_set, entity, displacements)
+        }
+
+        /// Shortcut to [`RapierContextJoints::multibody_forward_kinematics`].
+        pub fn multibody_forward_kinematics(
+            &mut self,
+            entity: Entity,
+            read_root_pose_from_rigid_body: bool,
+        ) -> bool {
+            self.joints.multibody_forward_kinematics(
+                &mut self.rigidbody_set,
+                entity,
+                read_root_pose_from_rigid_body,
+            )
+        }
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+    use crate::geometry::{Collider, NonlinearMotion, ShapeCastOptions, ShapeClosestPoints};
+    use crate::plugin::{NoUserData, RapierPhysicsPlugin};
+    use crate::prelude::QueryFilter;
+    use approx::assert_relative_eq;
+    use bevy::ecs::system::RunSystemOnce;
+    use bevy::time::{TimePlugin, TimeUpdateStrategy};
+
+    #[cfg(feature = "dim2")]
+    fn v(x: Real, y: Real) -> Vect {
+        Vect::new(x, y)
+    }
+    #[cfg(feature = "dim3")]
+    fn v(x: Real, y: Real) -> Vect {
+        Vect::new(x, y, 0.0)
+    }
+
+    #[cfg(feature = "dim2")]
+    fn quarter_turn() -> Rot {
+        std::f32::consts::FRAC_PI_2
+    }
+    #[cfg(feature = "dim3")]
+    fn quarter_turn() -> Rot {
+        Rot::from_rotation_z(std::f32::consts::FRAC_PI_2)
+    }
+
+    #[cfg(feature = "dim2")]
+    fn unit_cuboid() -> Collider {
+        Collider::cuboid(0.5, 0.5)
+    }
+    #[cfg(feature = "dim3")]
+    fn unit_cuboid() -> Collider {
+        Collider::cuboid(0.5, 0.5, 0.5)
+    }
+
+    fn transform_at(x: Real, y: Real) -> Transform {
+        Transform::from_xyz(x, y, 0.0)
+    }
+
+    fn test_app() -> App {
+        let mut app = App::new();
+        app.add_plugins((
+            TransformPlugin,
+            TimePlugin,
+            RapierPhysicsPlugin::<NoUserData>::default(),
+        ))
+        .insert_resource(TimeUpdateStrategy::ManualDuration(
+            std::time::Duration::from_secs_f32(1.0 / 60.0),
+        ));
+        app.finish();
+        app.update();
+        app
+    }
+
+    /// Spawns a fixed ball at the origin and a fixed cuboid at `x = 10`, then steps the world.
+    fn ball_and_cuboid_app() -> (App, Entity, Entity) {
+        let mut app = test_app();
+        let ball = app
+            .world_mut()
+            .spawn((transform_at(0.0, 0.0), Collider::ball(0.5)))
+            .id();
+        let cuboid = app
+            .world_mut()
+            .spawn((transform_at(10.0, 0.0), unit_cuboid()))
+            .id();
+        app.update();
+        app.update();
+        (app, ball, cuboid)
+    }
+
+    fn run<T: Send + 'static>(
+        app: &mut App,
+        f: impl Fn(RapierContext) -> T + Send + Sync + 'static,
+    ) -> T {
+        app.world_mut()
+            .run_system_once(move |context: ReadRapierContext| f(context.single().unwrap()))
+            .unwrap()
+    }
+
+    #[test]
+    fn cast_shape_nonlinear_hits_the_first_collider() {
+        let (mut app, ball, _) = ball_and_cuboid_app();
+        let (from_context, from_pipeline) = run(&mut app, |context| {
+            let shape = Collider::ball(0.5);
+            let mut motion = NonlinearMotion::constant_position(v(-5.0, 0.0), Rot::default());
+            motion.linear_velocity = v(1.0, 0.0);
+            let from_context = context.cast_shape_nonlinear(
+                &motion,
+                &*shape.raw,
+                0.0,
+                10.0,
+                true,
+                QueryFilter::default(),
+            );
+            let from_pipeline = context.with_query_pipeline(QueryFilter::default(), |pipeline| {
+                pipeline.cast_shape_nonlinear(&motion, &*shape.raw, 0.0, 2.0, true)
+            });
+            (from_context, from_pipeline)
+        });
+
+        let (entity, hit) = from_context.unwrap();
+        assert_eq!(entity, ball);
+        assert_relative_eq!(hit.time_of_impact, 4.0, epsilon = 1.0e-2);
+        // The end time is too short to reach the ball.
+        assert!(from_pipeline.is_none());
+    }
+
+    #[test]
+    fn scene_queries_report_subshapes() {
+        let mut app = test_app();
+        let compound = app
+            .world_mut()
+            .spawn((
+                transform_at(0.0, 0.0),
+                Collider::compound(vec![
+                    (v(0.0, 0.0), Rot::default(), Collider::ball(0.5)),
+                    (v(3.0, 0.0), Rot::default(), Collider::ball(0.5)),
+                ]),
+            ))
+            .id();
+        app.update();
+        app.update();
+
+        run(&mut app, move |context| {
+            let filter = QueryFilter::default();
+            let (e, inter) = context
+                .cast_ray_and_get_normal(v(3.0, 5.0), v(0.0, -1.0), Real::MAX, true, filter)
+                .unwrap();
+            assert_eq!(e, compound);
+            assert_eq!(inter.subshape, 1);
+
+            let mut ray_subshapes = vec![];
+            context.intersect_ray(
+                v(3.0, 5.0),
+                v(0.0, -1.0),
+                Real::MAX,
+                true,
+                filter,
+                |_, _, i| {
+                    ray_subshapes.push(i.subshape);
+                    true
+                },
+            );
+            assert_eq!(ray_subshapes, vec![1]);
+
+            let (_, proj) = context
+                .project_point(v(3.0, 2.0), Real::MAX, true, filter)
+                .unwrap();
+            assert_eq!(proj.subshape, 1);
+            let (_, proj) = context
+                .project_point(v(0.0, 2.0), Real::MAX, true, filter)
+                .unwrap();
+            assert_eq!(proj.subshape, 0);
+
+            let shape = Collider::ball(0.25);
+            let (_, hit) = context
+                .cast_shape(
+                    v(3.0, 5.0),
+                    Rot::default(),
+                    v(0.0, -1.0),
+                    &*shape.raw,
+                    ShapeCastOptions::default(),
+                    filter,
+                )
+                .unwrap();
+            assert_eq!(hit.subshape1, 1);
+            assert_eq!(hit.subshape2, 0);
+
+            let (_, contact) = context
+                .contact_with_shape(v(3.0, 1.0), Rot::default(), &*shape.raw, 1.0, filter)
+                .unwrap();
+            assert_eq!(contact.subshape1, 1);
+        });
+    }
+
+    #[test]
+    fn project_point_and_get_feature_honors_max_dist() {
+        let (mut app, ball, _) = ball_and_cuboid_app();
+        run(&mut app, move |context| {
+            let filter = QueryFilter::default();
+            assert!(context
+                .project_point_and_get_feature(v(0.0, 2.5), 1.0, filter)
+                .is_none());
+            let (e, proj, _) = context
+                .project_point_and_get_feature(v(0.0, 2.5), 3.0, filter)
+                .unwrap();
+            assert_eq!(e, ball);
+            assert_relative_eq!(proj.point, v(0.0, 0.5), epsilon = 1.0e-4);
+
+            let from_pipeline = context.with_query_pipeline(filter, |pipeline| {
+                pipeline.project_point_and_get_feature(v(0.0, 2.5), 1.0)
+            });
+            assert!(from_pipeline.is_none());
+        });
+    }
+
+    #[test]
+    fn predicate_receives_the_collider() {
+        let (mut app, ball, cuboid) = ball_and_cuboid_app();
+        run(&mut app, move |context| {
+            let hits = |filter: QueryFilter| {
+                let mut hits = vec![];
+                context.intersect_ray(
+                    v(-5.0, 0.0),
+                    v(1.0, 0.0),
+                    Real::MAX,
+                    true,
+                    filter,
+                    |e, _, _| {
+                        hits.push(e);
+                        true
+                    },
+                );
+                hits.sort();
+                hits
+            };
+            let mut all = vec![ball, cuboid];
+            all.sort();
+
+            let is_cuboid =
+                |_: Entity, co: &rapier::geometry::Collider| co.shape().as_cuboid().is_some();
+            let not_cuboid = |e: Entity, _: &rapier::geometry::Collider| e != cuboid;
+
+            assert_eq!(hits(QueryFilter::default()), all);
+            assert_eq!(
+                hits(QueryFilter::default().predicate(&is_cuboid)),
+                vec![cuboid]
+            );
+            assert_eq!(
+                hits(QueryFilter::default().predicate(&not_cuboid)),
+                vec![ball]
+            );
+        });
+    }
+
+    #[test]
+    fn intersect_queries_yield_colliders() {
+        let (mut app, ball, cuboid) = ball_and_cuboid_app();
+        run(&mut app, move |context| {
+            let filter = QueryFilter::default();
+            let is_ball = |co: &rapier::geometry::Collider| co.shape().as_ball().is_some();
+
+            let mut point_hits = vec![];
+            context.intersect_point(v(0.0, 0.0), filter, |e, co| {
+                point_hits.push((e, is_ball(co)));
+                true
+            });
+            assert_eq!(point_hits, vec![(ball, true)]);
+
+            let mut ray_hits = vec![];
+            context.intersect_ray(
+                v(10.0, 5.0),
+                v(0.0, -1.0),
+                Real::MAX,
+                true,
+                filter,
+                |e, co, inter| {
+                    ray_hits.push((e, is_ball(co), inter.time_of_impact));
+                    true
+                },
+            );
+            assert_eq!(ray_hits.len(), 1);
+            assert_eq!(ray_hits[0].0, cuboid);
+            assert!(!ray_hits[0].1);
+            assert_relative_eq!(ray_hits[0].2, 4.5, epsilon = 1.0e-4);
+
+            let shape = Collider::ball(1.0);
+            let mut shape_hits = vec![];
+            context.intersect_shape(
+                v(10.0, 1.0),
+                Rot::default(),
+                &*shape.raw,
+                filter,
+                |e, co| {
+                    shape_hits.push((e, is_ball(co)));
+                    true
+                },
+            );
+            assert_eq!(shape_hits, vec![(cuboid, false)]);
+
+            let aabb = Collider::ball(0.1).aabb(v(0.0, 0.0), Rot::default());
+            let mut aabb_hits = vec![];
+            context.intersect_aabb_conservative(aabb, filter, |e, co| {
+                aabb_hits.push((e, is_ball(co)));
+                true
+            });
+            assert_eq!(aabb_hits, vec![(ball, true)]);
+
+            // The pipeline iterators yield the same colliders.
+            context.with_query_pipeline(filter, |pipeline| {
+                let hits: Vec<_> = pipeline
+                    .intersect_point(v(10.0, 0.0))
+                    .map(|(e, co)| (e, is_ball(co)))
+                    .collect();
+                assert_eq!(hits, vec![(cuboid, false)]);
+            });
+        });
+    }
+
+    #[test]
+    fn distance_closest_points_and_contact_with_scene() {
+        let (mut app, ball, cuboid) = ball_and_cuboid_app();
+        run(&mut app, move |context| {
+            let filter = QueryFilter::default();
+            let shape = Collider::ball(0.5);
+            // The shape is rotated to check that its local results are moved to world-space.
+            let rot = quarter_turn();
+
+            let (e, dist) = context
+                .distance_to_shape(v(2.0, 0.0), rot, &*shape.raw, filter)
+                .unwrap();
+            assert_eq!(e, ball);
+            assert_relative_eq!(dist, 1.0, epsilon = 1.0e-4);
+
+            let (e, dist) = context
+                .distance_to_shape(
+                    v(2.0, 0.0),
+                    rot,
+                    &*shape.raw,
+                    QueryFilter::default().exclude_collider(ball),
+                )
+                .unwrap();
+            assert_eq!(e, cuboid);
+            assert_relative_eq!(dist, 7.0, epsilon = 1.0e-4);
+
+            assert!(context
+                .closest_points_to_shape(v(2.0, 0.0), rot, &*shape.raw, 0.5, filter)
+                .is_none());
+            let (e, pts) = context
+                .closest_points_to_shape(v(2.0, 0.0), rot, &*shape.raw, 2.0, filter)
+                .unwrap();
+            assert_eq!(e, ball);
+            let ShapeClosestPoints::WithinMargin(p1, p2) = pts else {
+                panic!("unexpected closest points: {pts:?}");
+            };
+            assert_relative_eq!(p1, v(0.5, 0.0), epsilon = 1.0e-4);
+            assert_relative_eq!(p2, v(1.5, 0.0), epsilon = 1.0e-4);
+            let (_, pts) = context
+                .closest_points_to_shape(v(0.5, 0.0), rot, &*shape.raw, 2.0, filter)
+                .unwrap();
+            assert_eq!(pts, ShapeClosestPoints::Intersecting);
+
+            assert!(context
+                .contact_with_shape(v(2.0, 0.0), rot, &*shape.raw, 0.5, filter)
+                .is_none());
+            let (e, contact) = context
+                .contact_with_shape(v(2.0, 0.0), rot, &*shape.raw, 2.0, filter)
+                .unwrap();
+            assert_eq!(e, ball);
+            assert_relative_eq!(contact.distance, 1.0, epsilon = 1.0e-4);
+            assert_relative_eq!(contact.point1, v(0.5, 0.0), epsilon = 1.0e-4);
+            assert_relative_eq!(contact.point2, v(1.5, 0.0), epsilon = 1.0e-4);
+            assert_relative_eq!(contact.normal1, v(1.0, 0.0), epsilon = 1.0e-4);
+            assert_relative_eq!(contact.normal2, v(-1.0, 0.0), epsilon = 1.0e-4);
+        });
+    }
+
+    #[test]
+    fn bvh_leaves_resolve_to_filtered_colliders() {
+        let (mut app, ball, cuboid) = ball_and_cuboid_app();
+        run(&mut app, move |context| {
+            let leaves: Vec<u32> = context.bvh().leaves(|_| true).collect();
+            assert_eq!(leaves.len(), 2);
+
+            let filter = QueryFilter::default().exclude_collider(cuboid);
+            context.with_query_pipeline(filter, |pipeline| {
+                let mut resolved: Vec<_> = leaves
+                    .iter()
+                    .filter_map(|leaf| pipeline.bvh_leaf_collider(*leaf))
+                    .map(|(e, _)| e)
+                    .collect();
+                resolved.sort();
+                assert_eq!(resolved, vec![ball]);
+                assert_eq!(pipeline.bvh().leaves(|_| true).count(), 2);
+            });
+        });
+    }
+
+    #[test]
+    fn scene_shape_casts_report_world_space_collider_witnesses() {
+        let (mut app, _, cuboid) = ball_and_cuboid_app();
+        let (entity, hit) = run(&mut app, |context| {
+            let shape = Collider::ball(0.5);
+            context.cast_shape(
+                v(5.0, 0.0),
+                quarter_turn(),
+                v(1.0, 0.0),
+                &shape,
+                ShapeCastOptions::default(),
+                QueryFilter::default(),
+            )
+        })
+        .unwrap();
+        assert_eq!(entity, cuboid);
+        let details = hit.details.unwrap();
+        // The collider hit (the first shape) is in world-space.
+        assert_relative_eq!(details.witness1, v(9.5, 0.0), epsilon = 1.0e-2);
+        assert_relative_eq!(details.normal1, v(-1.0, 0.0), epsilon = 1.0e-2);
+        // The cast shape (the second shape), rotated by a quarter turn, is in its local-space.
+        assert_relative_eq!(details.witness2, v(0.0, -0.5), epsilon = 1.0e-2);
+        assert_relative_eq!(details.normal2, v(0.0, -1.0), epsilon = 1.0e-2);
+    }
+
+    #[test]
+    fn move_shape_from_a_user_system() {
+        let (mut app, ball, _) = ball_and_cuboid_app();
+        let (output, hits) = app
+            .world_mut()
+            .run_system_once(|mut context: WriteRapierContext| {
+                let mut context = context.single_mut().unwrap();
+                let options = crate::control::MoveShapeOptions {
+                    snap_to_ground: None,
+                    ..Default::default()
+                };
+                let mut hits = vec![];
+                let output = context.move_shape(
+                    v(8.0, 0.0),
+                    &rapier::parry::shape::Ball::new(0.5),
+                    v(-5.0, 0.0),
+                    Rot::default(),
+                    1.0,
+                    &options,
+                    QueryFilter::default(),
+                    |collision| hits.push(collision.entity),
+                );
+                (output, hits)
+            })
+            .unwrap();
+
+        // The ball at the origin stops the shape before it reaches `x = -1`.
+        assert!(output.effective_translation.x < 4.0);
+        assert!(output.effective_translation.x > 3.5);
+        assert!(hits.contains(&ball));
+    }
+
+    /// A query dispatcher counting its shape-casts before forwarding every query to the default
+    /// dispatcher.
+    struct CountingDispatcher(std::sync::Arc<std::sync::atomic::AtomicUsize>);
+
+    mod counting_dispatcher {
+        use super::CountingDispatcher;
+        use rapier::geometry::{ContactData, ContactManifoldData};
+        use rapier::math::{Pose, Real, Vector};
+        use rapier::parry::query::{
+            details::NormalConstraints, ClosestPoints, Contact, ContactManifold,
+            ContactManifoldsWorkspace, DefaultQueryDispatcher, NonlinearRigidMotion,
+            PersistentQueryDispatcher, QueryDispatcher, ShapeCastHit, ShapeCastOptions,
+            ShapeDistance, ShapeIntersection, Unsupported,
+        };
+        use rapier::parry::shape::Shape;
+        use std::sync::atomic::Ordering;
+
+        impl QueryDispatcher for CountingDispatcher {
+            fn intersection_test(
+                &self,
+                pos12: &Pose,
+                g1: &dyn Shape,
+                g2: &dyn Shape,
+            ) -> Result<ShapeIntersection, Unsupported> {
+                DefaultQueryDispatcher.intersection_test(pos12, g1, g2)
+            }
+
+            fn distance(
+                &self,
+                pos12: &Pose,
+                g1: &dyn Shape,
+                g2: &dyn Shape,
+            ) -> Result<ShapeDistance, Unsupported> {
+                DefaultQueryDispatcher.distance(pos12, g1, g2)
+            }
+
+            fn contact(
+                &self,
+                pos12: &Pose,
+                g1: &dyn Shape,
+                g2: &dyn Shape,
+                prediction: Real,
+            ) -> Result<Option<Contact>, Unsupported> {
+                DefaultQueryDispatcher.contact(pos12, g1, g2, prediction)
+            }
+
+            fn closest_points(
+                &self,
+                pos12: &Pose,
+                g1: &dyn Shape,
+                g2: &dyn Shape,
+                max_dist: Real,
+            ) -> Result<ClosestPoints, Unsupported> {
+                DefaultQueryDispatcher.closest_points(pos12, g1, g2, max_dist)
+            }
+
+            fn cast_shapes(
+                &self,
+                pos12: &Pose,
+                local_vel12: Vector,
+                g1: &dyn Shape,
+                g2: &dyn Shape,
+                options: ShapeCastOptions,
+            ) -> Result<Option<ShapeCastHit>, Unsupported> {
+                self.0.fetch_add(1, Ordering::Relaxed);
+                DefaultQueryDispatcher.cast_shapes(pos12, local_vel12, g1, g2, options)
+            }
+
+            fn cast_shapes_nonlinear(
+                &self,
+                motion1: &NonlinearRigidMotion,
+                g1: &dyn Shape,
+                motion2: &NonlinearRigidMotion,
+                g2: &dyn Shape,
+                start_time: Real,
+                end_time: Real,
+                stop_at_penetration: bool,
+            ) -> Result<Option<ShapeCastHit>, Unsupported> {
+                DefaultQueryDispatcher.cast_shapes_nonlinear(
+                    motion1,
+                    g1,
+                    motion2,
+                    g2,
+                    start_time,
+                    end_time,
+                    stop_at_penetration,
+                )
+            }
+        }
+
+        impl PersistentQueryDispatcher<ContactManifoldData, ContactData> for CountingDispatcher {
+            fn contact_manifolds(
+                &self,
+                pos12: &Pose,
+                g1: &dyn Shape,
+                g2: &dyn Shape,
+                prediction: Real,
+                manifolds: &mut Vec<ContactManifold<ContactManifoldData, ContactData>>,
+                workspace: &mut Option<ContactManifoldsWorkspace>,
+            ) -> Result<(), Unsupported> {
+                DefaultQueryDispatcher
+                    .contact_manifolds(pos12, g1, g2, prediction, manifolds, workspace)
+            }
+
+            fn contact_manifold_convex_convex(
+                &self,
+                pos12: &Pose,
+                g1: &dyn Shape,
+                g2: &dyn Shape,
+                normal_constraints1: Option<&dyn NormalConstraints>,
+                normal_constraints2: Option<&dyn NormalConstraints>,
+                prediction: Real,
+                manifold: &mut ContactManifold<ContactManifoldData, ContactData>,
+            ) -> Result<(), Unsupported> {
+                DefaultQueryDispatcher.contact_manifold_convex_convex(
+                    pos12,
+                    g1,
+                    g2,
+                    normal_constraints1,
+                    normal_constraints2,
+                    prediction,
+                    manifold,
+                )
+            }
+        }
+    }
+
+    #[test]
+    fn scene_queries_use_the_context_query_dispatcher() {
+        let mut app = test_app();
+        let casts = std::sync::Arc::new(std::sync::atomic::AtomicUsize::new(0));
+        let dispatcher = CountingDispatcher(casts.clone());
+        app.world_mut()
+            .run_system_once(move |mut context: WriteRapierContext| {
+                context
+                    .single_mut()
+                    .unwrap()
+                    .simulation
+                    .set_query_dispatcher(CountingDispatcher(dispatcher.0.clone()));
+            })
+            .unwrap();
+        let ball = app
+            .world_mut()
+            .spawn((transform_at(0.0, 0.0), Collider::ball(0.5)))
+            .id();
+        app.update();
+        app.update();
+
+        let casts_before = casts.load(std::sync::atomic::Ordering::Relaxed);
+        let hit = run(&mut app, |context| {
+            let shape = Collider::ball(0.5);
+            context.cast_shape(
+                v(-5.0, 0.0),
+                Rot::default(),
+                v(1.0, 0.0),
+                &*shape.raw,
+                ShapeCastOptions::default(),
+                QueryFilter::default(),
+            )
+        });
+        assert_eq!(hit.map(|(e, _)| e), Some(ball));
+        assert!(casts.load(std::sync::atomic::Ordering::Relaxed) > casts_before);
+
+        // The character-controller shortcut goes through the same dispatcher.
+        let casts_before = casts.load(std::sync::atomic::Ordering::Relaxed);
+        app.world_mut()
+            .run_system_once(|mut context: WriteRapierContext| {
+                let shape = Collider::ball(0.5);
+                context.single_mut().unwrap().move_shape(
+                    v(8.0, 0.0),
+                    &*shape.raw,
+                    v(-5.0, 0.0),
+                    Rot::default(),
+                    1.0,
+                    &Default::default(),
+                    QueryFilter::default(),
+                    |_| {},
+                );
+            })
+            .unwrap();
+        assert!(casts.load(std::sync::atomic::Ordering::Relaxed) > casts_before);
+    }
+}
diff --git a/bindings/bevy_rapier/src/plugin/diagnostics.rs b/bindings/bevy_rapier/src/plugin/diagnostics.rs
new file mode 100644
index 000000000..7cf920c42
--- /dev/null
+++ b/bindings/bevy_rapier/src/plugin/diagnostics.rs
@@ -0,0 +1,344 @@
+//! Integration of the simulation statistics with Bevy’s diagnostics.
+
+use bevy::diagnostic::{
+    Diagnostic, DiagnosticPath, Diagnostics, DiagnosticsStore, RegisterDiagnostic,
+};
+use bevy::ecs::entity::EntityHashSet;
+use bevy::ecs::{intern::Interned, schedule::ScheduleLabel};
+use bevy::prelude::*;
+
+use crate::plugin::context::{
+    RapierContextColliders, RapierContextJoints, RapierContextSimulation, RapierRigidBodySet,
+};
+use crate::plugin::PhysicsSet;
+
+/// Plugin registering Bevy [`Diagnostic`]s measuring the simulation of every Rapier context.
+///
+/// The measurements are taken after each physics update that executed at least one simulation
+/// step, from [`RapierContextSimulation::step_stats`] (which relies on Rapier’s counters) and
+/// from the current state of the contexts. They can be displayed, for example, with Bevy’s
+/// `LogDiagnosticsPlugin`.
+///
+/// The diagnostics at the paths of the associated constants (e.g. [`Self::STEP_TIME`]) are sums
+/// over all the contexts (counts and timings alike), so they measure the whole physics workload
+/// of the app. Enable [`Self::per_context`] to also measure each context separately at the paths
+/// returned by [`Self::context_path`], registered when a context is first measured.
+///
+/// Only [`Self::STEP_TIME`] and the counts are measured by default: the other timings rely on
+/// Rapier’s internal profiler and are only registered if the `profiler` feature is enabled. This
+/// plugin enables the [`PhysicsPipeline::counters`](rapier::pipeline::PhysicsPipeline::counters)
+/// of every context.
+pub struct RapierDiagnosticsPlugin {
+    schedule: Interned<dyn ScheduleLabel>,
+    /// The maximum number of measurements kept in the history of each diagnostic.
+    pub max_history_length: usize,
+    /// Whether each context is also measured separately, at the paths returned by
+    /// [`Self::context_path`] (default: `false`).
+    pub per_context: bool,
+}
+
+impl Default for RapierDiagnosticsPlugin {
+    fn default() -> Self {
+        Self {
+            schedule: PostUpdate.intern(),
+            max_history_length: bevy::diagnostic::DEFAULT_MAX_HISTORY_LENGTH,
+            per_context: false,
+        }
+    }
+}
+
+impl RapierDiagnosticsPlugin {
+    /// Total wall-clock time spent running the simulation steps of a physics update, in
+    /// milliseconds.
+    pub const STEP_TIME: DiagnosticPath = DiagnosticPath::const_new("rapier/step_time");
+    /// Number of simulation steps (including substeps) executed by a physics update.
+    pub const STEPS: DiagnosticPath = DiagnosticPath::const_new("rapier/steps");
+    /// Time spent on collision detection, in milliseconds (requires the `profiler` feature).
+    pub const COLLISION_DETECTION_TIME: DiagnosticPath =
+        DiagnosticPath::const_new("rapier/collision_detection_time");
+    /// Time spent in the broad-phase, in milliseconds (requires the `profiler` feature).
+    pub const BROAD_PHASE_TIME: DiagnosticPath =
+        DiagnosticPath::const_new("rapier/broad_phase_time");
+    /// Time spent in the narrow-phase, in milliseconds (requires the `profiler` feature).
+    pub const NARROW_PHASE_TIME: DiagnosticPath =
+        DiagnosticPath::const_new("rapier/narrow_phase_time");
+    /// Time spent building the simulation islands, in milliseconds (requires the `profiler`
+    /// feature).
+    pub const ISLAND_CONSTRUCTION_TIME: DiagnosticPath =
+        DiagnosticPath::const_new("rapier/island_construction_time");
+    /// Time spent in the constraints solver, in milliseconds (requires the `profiler` feature).
+    pub const SOLVER_TIME: DiagnosticPath = DiagnosticPath::const_new("rapier/solver_time");
+    /// Time spent on Continuous Collision Detection, in milliseconds (requires the `profiler`
+    /// feature).
+    pub const CCD_TIME: DiagnosticPath = DiagnosticPath::const_new("rapier/ccd_time");
+    /// Time spent updating the rigid-bodies’ positions and velocities, in milliseconds (requires
+    /// the `profiler` feature).
+    pub const UPDATE_TIME: DiagnosticPath = DiagnosticPath::const_new("rapier/update_time");
+    /// Number of CCD substeps executed by a physics update (zero when the CCD didn't need to act).
+    pub const CCD_SUBSTEPS: DiagnosticPath = DiagnosticPath::const_new("rapier/ccd_substeps");
+    /// Number of rigid-bodies.
+    pub const RIGID_BODIES: DiagnosticPath = DiagnosticPath::const_new("rapier/rigid_bodies");
+    /// Number of awake (active) dynamic and kinematic rigid-bodies.
+    pub const ACTIVE_BODIES: DiagnosticPath = DiagnosticPath::const_new("rapier/active_bodies");
+    /// Number of colliders.
+    pub const COLLIDERS: DiagnosticPath = DiagnosticPath::const_new("rapier/colliders");
+    /// Number of impulse joints.
+    pub const IMPULSE_JOINTS: DiagnosticPath = DiagnosticPath::const_new("rapier/impulse_joints");
+    /// Number of multibody joints.
+    pub const MULTIBODY_JOINTS: DiagnosticPath =
+        DiagnosticPath::const_new("rapier/multibody_joints");
+    /// Number of contact pairs tracked by the narrow-phase (touching or not) after the last step.
+    pub const CONTACT_PAIRS: DiagnosticPath = DiagnosticPath::const_new("rapier/contact_pairs");
+    /// Number of contact pairs with at least one active contact.
+    pub const ACTIVE_CONTACT_PAIRS: DiagnosticPath =
+        DiagnosticPath::const_new("rapier/active_contact_pairs");
+    /// Number of contact points (soft-body contacts included) handed to the constraints solver
+    /// by a physics update.
+    pub const CONTACT_CONSTRAINTS: DiagnosticPath =
+        DiagnosticPath::const_new("rapier/contact_constraints");
+    /// Number of contact manifolds and impulse joints handed to the constraints solver by a
+    /// physics update. The contacts and joints of sleeping bodies aren't counted.
+    pub const SOLVER_CONSTRAINTS: DiagnosticPath =
+        DiagnosticPath::const_new("rapier/solver_constraints");
+    /// Number of intersecting sensor pairs.
+    pub const INTERSECTIONS: DiagnosticPath = DiagnosticPath::const_new("rapier/intersections");
+
+    /// The diagnostics measured in every build, with their unit suffix.
+    const ALWAYS_MEASURED: [(DiagnosticPath, &'static str); 13] = [
+        (Self::STEP_TIME, "ms"),
+        (Self::STEPS, ""),
+        (Self::CCD_SUBSTEPS, ""),
+        (Self::RIGID_BODIES, ""),
+        (Self::ACTIVE_BODIES, ""),
+        (Self::COLLIDERS, ""),
+        (Self::IMPULSE_JOINTS, ""),
+        (Self::MULTIBODY_JOINTS, ""),
+        (Self::CONTACT_PAIRS, ""),
+        (Self::ACTIVE_CONTACT_PAIRS, ""),
+        (Self::CONTACT_CONSTRAINTS, ""),
+        (Self::SOLVER_CONSTRAINTS, ""),
+        (Self::INTERSECTIONS, ""),
+    ];
+
+    /// The timings relying on Rapier’s internal profiler.
+    #[cfg(feature = "profiler")]
+    const PROFILER_TIMINGS: [DiagnosticPath; 7] = [
+        Self::COLLISION_DETECTION_TIME,
+        Self::BROAD_PHASE_TIME,
+        Self::NARROW_PHASE_TIME,
+        Self::ISLAND_CONSTRUCTION_TIME,
+        Self::SOLVER_TIME,
+        Self::CCD_TIME,
+        Self::UPDATE_TIME,
+    ];
+
+    /// Measures the diagnostics in the given schedule (default: [`PostUpdate`]).
+    ///
+    /// This should be the schedule the physics runs in (see
+    /// [`RapierPhysicsPlugin::in_schedule`](crate::plugin::RapierPhysicsPlugin::in_schedule)).
+    pub fn in_schedule(mut self, schedule: impl ScheduleLabel) -> Self {
+        self.schedule = schedule.intern();
+        self
+    }
+
+    /// Also measures each context separately (see [`Self::per_context`]).
+    pub fn with_per_context_diagnostics(mut self, per_context: bool) -> Self {
+        self.per_context = per_context;
+        self
+    }
+
+    /// The path of the diagnostic measuring `path` (one of the associated constants, e.g.
+    /// [`Self::STEP_TIME`]) for the context `context` only, e.g. `rapier/12v0/step_time`.
+    ///
+    /// These diagnostics are only measured if [`Self::per_context`] is enabled.
+    pub fn context_path(path: &DiagnosticPath, context: Entity) -> DiagnosticPath {
+        let name = path.as_str();
+        let name = name.strip_prefix("rapier/").unwrap_or(name);
+        DiagnosticPath::new(format!("rapier/{context}/{name}"))
+    }
+
+    /// The path and unit suffix of every diagnostic measured by this plugin.
+    fn measured_paths() -> impl Iterator<Item = (DiagnosticPath, &'static str)> {
+        let always = Self::ALWAYS_MEASURED.into_iter();
+        #[cfg(feature = "profiler")]
+        let always = always.chain(Self::PROFILER_TIMINGS.into_iter().map(|path| (path, "ms")));
+        always
+    }
+
+    /// The measurements of one context, or `None` if it didn’t execute any step during the last
+    /// physics update.
+    fn measure_context(
+        simulation: &mut Mut<RapierContextSimulation>,
+        colliders: &RapierContextColliders,
+        bodies: &RapierRigidBodySet,
+        joints: &RapierContextJoints,
+    ) -> Option<Vec<(DiagnosticPath, f64)>> {
+        if !simulation.pipeline.counters.enabled() {
+            simulation
+                .bypass_change_detection()
+                .pipeline
+                .counters
+                .enable();
+        }
+
+        let stats = *simulation.step_stats();
+        if stats.num_steps == 0 {
+            return None;
+        }
+
+        #[allow(unused_mut)] // Only mutated with the `profiler` feature.
+        let mut measurements = vec![
+            (Self::STEP_TIME, stats.step_time_ms),
+            (Self::STEPS, stats.num_steps as f64),
+            (Self::CCD_SUBSTEPS, stats.ccd_substeps as f64),
+            (Self::RIGID_BODIES, bodies.bodies.len() as f64),
+            (
+                Self::ACTIVE_BODIES,
+                simulation.islands.active_bodies().count() as f64,
+            ),
+            (Self::COLLIDERS, colliders.colliders.len() as f64),
+            (Self::IMPULSE_JOINTS, joints.impulse_joints.len() as f64),
+            (
+                Self::MULTIBODY_JOINTS,
+                joints.multibody_joints.iter().count() as f64,
+            ),
+            (Self::CONTACT_PAIRS, stats.num_contact_pairs as f64),
+            (
+                Self::ACTIVE_CONTACT_PAIRS,
+                simulation
+                    .narrow_phase
+                    .contact_pairs()
+                    .filter(|pair| pair.has_any_active_contact())
+                    .count() as f64,
+            ),
+            (Self::CONTACT_CONSTRAINTS, stats.num_solver_contacts as f64),
+            (
+                Self::SOLVER_CONSTRAINTS,
+                stats.num_solver_constraints as f64,
+            ),
+            (
+                Self::INTERSECTIONS,
+                simulation
+                    .narrow_phase
+                    .intersection_pairs()
+                    .filter(|(_, _, intersecting)| *intersecting)
+                    .count() as f64,
+            ),
+        ];
+        #[cfg(feature = "profiler")]
+        measurements.extend([
+            (
+                Self::COLLISION_DETECTION_TIME,
+                stats.collision_detection_time_ms,
+            ),
+            (Self::BROAD_PHASE_TIME, stats.broad_phase_time_ms),
+            (Self::NARROW_PHASE_TIME, stats.narrow_phase_time_ms),
+            (
+                Self::ISLAND_CONSTRUCTION_TIME,
+                stats.island_construction_time_ms,
+            ),
+            (Self::SOLVER_TIME, stats.solver_time_ms),
+            (Self::CCD_TIME, stats.ccd_time_ms),
+            (Self::UPDATE_TIME, stats.update_time_ms),
+        ]);
+        Some(measurements)
+    }
+
+    /// Updates the measurements of the diagnostics registered by this plugin.
+    ///
+    /// If `per_context` is set, the per-context diagnostics of the contexts not in `registered`
+    /// are registered (their first measurement is then taken on the next update).
+    fn diagnostic_system(
+        per_context: bool,
+        max_history_length: usize,
+        commands: &mut Commands,
+        diagnostics: &mut Diagnostics,
+        contexts: &mut Query<(
+            Entity,
+            &mut RapierContextSimulation,
+            &RapierContextColliders,
+            &RapierRigidBodySet,
+            &RapierContextJoints,
+        )>,
+        registered: &mut EntityHashSet,
+    ) {
+        let mut totals: Option<Vec<(DiagnosticPath, f64)>> = None;
+
+        for (context, mut simulation, colliders, bodies, joints) in contexts.iter_mut() {
+            let Some(measurements) =
+                Self::measure_context(&mut simulation, colliders, bodies, joints)
+            else {
+                continue;
+            };
+
+            if per_context {
+                if registered.insert(context) {
+                    commands.queue(move |world: &mut World| {
+                        let mut store = world.resource_mut::<DiagnosticsStore>();
+                        for (path, suffix) in Self::measured_paths() {
+                            store.add(
+                                Diagnostic::new(Self::context_path(&path, context))
+                                    .with_suffix(suffix)
+                                    .with_max_history_length(max_history_length),
+                            );
+                        }
+                    });
+                }
+                for (path, value) in &measurements {
+                    diagnostics.add_measurement(&Self::context_path(path, context), || *value);
+                }
+            }
+
+            match &mut totals {
+                Some(totals) => {
+                    for ((_, total), (_, value)) in totals.iter_mut().zip(&measurements) {
+                        *total += value;
+                    }
+                }
+                None => totals = Some(measurements),
+            }
+        }
+
+        for (path, total) in totals.into_iter().flatten() {
+            diagnostics.add_measurement(&path, || total);
+        }
+    }
+}
+
+impl Plugin for RapierDiagnosticsPlugin {
+    fn build(&self, app: &mut App) {
+        for (path, suffix) in Self::measured_paths() {
+            app.register_diagnostic(
+                Diagnostic::new(path)
+                    .with_suffix(suffix)
+                    .with_max_history_length(self.max_history_length),
+            );
+        }
+
+        let per_context = self.per_context;
+        let max_history_length = self.max_history_length;
+        app.add_systems(
+            self.schedule,
+            (move |mut commands: Commands,
+                   mut diagnostics: Diagnostics,
+                   mut contexts: Query<(
+                Entity,
+                &mut RapierContextSimulation,
+                &RapierContextColliders,
+                &RapierRigidBodySet,
+                &RapierContextJoints,
+            )>,
+                   mut registered: Local<EntityHashSet>| {
+                Self::diagnostic_system(
+                    per_context,
+                    max_history_length,
+                    &mut commands,
+                    &mut diagnostics,
+                    &mut contexts,
+                    &mut registered,
+                )
+            })
+            .after(PhysicsSet::Writeback),
+        );
+    }
+}
diff --git a/bindings/bevy_rapier/src/plugin/mod.rs b/bindings/bevy_rapier/src/plugin/mod.rs
new file mode 100644
index 000000000..970f18fac
--- /dev/null
+++ b/bindings/bevy_rapier/src/plugin/mod.rs
@@ -0,0 +1,31 @@
+#[cfg(feature = "dim3")]
+pub use self::configuration::FrictionModel;
+pub use self::configuration::{
+    BroadPhaseOptimizationStrategy, IntegrationParameters, RapierConfiguration, SimulationMode,
+    TimestepMode,
+};
+pub use self::context::{
+    systemparams::{RapierContext, RapierContextMut, ReadRapierContext, WriteRapierContext},
+    DefaultRapierContext, RapierContextEntityLink, SimulationToRenderTime,
+};
+pub use self::diagnostics::RapierDiagnosticsPlugin;
+pub use self::plugin::{
+    NoUserData, PhysicsSet, RapierBevyComponentApply, RapierContextInitialization,
+    RapierPhysicsPlugin, RapierTransformPropagateSet,
+};
+pub use narrow_phase::{ContactManifoldView, ContactPairView, ContactView, SolverContactView};
+
+#[allow(clippy::type_complexity)]
+#[allow(clippy::too_many_arguments)]
+pub mod systems;
+
+pub mod configuration;
+pub mod context;
+mod diagnostics;
+mod narrow_phase;
+#[allow(clippy::module_inception)]
+mod plugin;
+#[cfg(test)]
+mod soft_body_tests;
+#[cfg(test)]
+mod tests;
diff --git a/bindings/bevy_rapier/src/plugin/narrow_phase.rs b/bindings/bevy_rapier/src/plugin/narrow_phase.rs
new file mode 100644
index 000000000..0c0e94041
--- /dev/null
+++ b/bindings/bevy_rapier/src/plugin/narrow_phase.rs
@@ -0,0 +1,675 @@
+use crate::math::{Real, Vect};
+use crate::plugin::context::{RapierContextColliders, RapierContextSimulation, RapierRigidBodySet};
+use crate::utils::iso_to_transform;
+use bevy::prelude::*;
+use rapier::geometry::{
+    ColliderHandle, Contact, ContactManifold, ContactManifoldData, ContactPair, InteractionGraph,
+    IntersectionPair, PairContacts, SoftPairContacts, SolverContact, SolverFlags, NEW_CONTACT_BIT,
+};
+
+impl RapierContextSimulation {
+    /// All the contact pairs involving the non-sensor collider attached to the given entity.
+    ///
+    /// The returned contact pairs identify pairs of colliders with intersecting bounding-volumes.
+    /// To check if any geometric contact happened between the collider shapes, check
+    /// [`ContactPairView::has_any_active_contact`].
+    pub fn contact_pairs_with<'a, 'b: 'a>(
+        &'a self,
+        context_colliders: &'b RapierContextColliders,
+        rigidbody_set: &'b RapierRigidBodySet,
+        collider: Entity,
+    ) -> impl Iterator<Item = ContactPairView<'a>> {
+        context_colliders
+            .entity2collider
+            .get(&collider)
+            .into_iter()
+            .flat_map(|h| {
+                self.narrow_phase
+                    .contact_pairs_with(*h)
+                    .map(|raw| ContactPairView {
+                        context_colliders,
+                        rigidbody_set,
+                        raw,
+                    })
+            })
+    }
+
+    /// All the intersection pairs involving the collider attached to the given entity, where at least one collider
+    /// involved in the intersection is a sensor.
+    ///
+    /// The returned contact pairs identify pairs of colliders (where at least one is a sensor) with
+    /// intersecting bounding-volumes. To check if any geometric overlap happened between the collider shapes, check
+    /// the returned boolean.
+    pub fn intersection_pairs_with<'a, 'b: 'a>(
+        &'a self,
+        rapier_colliders: &'b RapierContextColliders,
+        collider: Entity,
+    ) -> impl Iterator<Item = (Entity, Entity, bool)> + 'a {
+        rapier_colliders
+            .entity2collider
+            .get(&collider)
+            .into_iter()
+            .flat_map(|h| {
+                self.narrow_phase
+                    .intersection_pairs_with(*h)
+                    .filter_map(|(h1, h2, inter)| {
+                        let e1 = rapier_colliders.collider_entity(h1);
+                        let e2 = rapier_colliders.collider_entity(h2);
+                        match (e1, e2) {
+                            (Some(e1), Some(e2)) => Some((e1, e2, inter)),
+                            _ => None,
+                        }
+                    })
+            })
+    }
+
+    /// The contact pair involving two specific colliders.
+    ///
+    /// If this returns `None`, there is no contact between the two colliders.
+    /// If this returns `Some`, then there may be a contact between the two colliders. Check the
+    /// result [`ContactPairView::has_any_active_contact`] method to see if there is an actual contact.
+    pub fn contact_pair<'a, 'b: 'a>(
+        &'a self,
+        context_colliders: &'b RapierContextColliders,
+        rigidbody_set: &'b RapierRigidBodySet,
+        collider1: Entity,
+        collider2: Entity,
+    ) -> Option<ContactPairView<'a>> {
+        let h1 = context_colliders.entity2collider.get(&collider1)?;
+        let h2 = context_colliders.entity2collider.get(&collider2)?;
+        self.narrow_phase
+            .contact_pair(*h1, *h2)
+            .map(|raw| ContactPairView {
+                context_colliders,
+                rigidbody_set,
+                raw,
+            })
+    }
+
+    /// The intersection pair involving two specific colliders (at least one being a sensor).
+    ///
+    /// If this returns `None` or `Some(false)`, then there is no intersection between the two colliders.
+    /// If this returns `Some(true)`, then there may be an intersection between the two colliders.
+    pub fn intersection_pair(
+        &self,
+        rapier_colliders: &RapierContextColliders,
+        collider1: Entity,
+        collider2: Entity,
+    ) -> Option<bool> {
+        let h1 = rapier_colliders.entity2collider.get(&collider1)?;
+        let h2 = rapier_colliders.entity2collider.get(&collider2)?;
+        self.narrow_phase.intersection_pair(*h1, *h2)
+    }
+
+    /// All the contact pairs detected during the last timestep.
+    pub fn contact_pairs<'a, 'b: 'a>(
+        &'a self,
+        context_colliders: &'b RapierContextColliders,
+        rigidbody_set: &'b RapierRigidBodySet,
+    ) -> impl Iterator<Item = ContactPairView<'a>> {
+        self.narrow_phase
+            .contact_pairs()
+            .map(|raw| ContactPairView {
+                context_colliders,
+                rigidbody_set,
+                raw,
+            })
+    }
+
+    /// The raw contact graph of the narrow-phase.
+    ///
+    /// Its nodes are the Rapier handles of the colliders, and its edges the raw contact pairs
+    /// between non-sensor colliders with intersecting bounding volumes. Prefer
+    /// [`Self::contact_pairs`] and [`Self::contact_pairs_with`] which yield Bevy entities.
+    pub fn contact_graph(&self) -> &InteractionGraph<ColliderHandle, ContactPair> {
+        self.narrow_phase.contact_graph()
+    }
+
+    /// The raw intersection graph of the narrow-phase.
+    ///
+    /// Its nodes are the Rapier handles of the colliders, and its edges the raw intersection
+    /// pairs involving at least one sensor. Prefer [`Self::intersection_pairs`] and
+    /// [`Self::intersection_pairs_with`] which yield Bevy entities.
+    pub fn intersection_graph(&self) -> &InteractionGraph<ColliderHandle, IntersectionPair> {
+        self.narrow_phase.intersection_graph()
+    }
+
+    /// All the intersection pairs detected during the last timestep.
+    pub fn intersection_pairs<'a, 'b: 'a>(
+        &'a self,
+        rapier_colliders: &'b RapierContextColliders,
+    ) -> impl Iterator<Item = (Entity, Entity, bool)> + 'a {
+        self.narrow_phase
+            .intersection_pairs()
+            .filter_map(|(h1, h2, inter)| {
+                let e1 = rapier_colliders.collider_entity(h1);
+                let e2 = rapier_colliders.collider_entity(h2);
+                match (e1, e2) {
+                    (Some(e1), Some(e2)) => Some((e1, e2, inter)),
+                    _ => None,
+                }
+            })
+    }
+}
+
+/// Read-only access to the properties of a contact manifold.
+pub struct ContactManifoldView<'a> {
+    rigidbody_set: &'a RapierRigidBodySet,
+    /// The raw contact manifold from Rapier.
+    pub raw: &'a ContactManifold,
+}
+
+impl ContactManifoldView<'_> {
+    /// The number of points on this contact manifold.
+    pub fn num_points(&self) -> usize {
+        self.raw.points.len()
+    }
+
+    /// Retrieves the i-th point of this contact manifold.
+    pub fn point(&self, i: usize) -> Option<ContactView<'_>> {
+        self.raw.points.get(i).map(|raw| ContactView { raw })
+    }
+
+    /// The contacts points.
+    pub fn points(&self) -> impl ExactSizeIterator<Item = ContactView<'_>> {
+        self.raw.points.iter().map(|raw| ContactView { raw })
+    }
+
+    /// The contact normal of all the contacts of this manifold, expressed in the local space of the first shape.
+    pub fn local_n1(&self) -> Vect {
+        self.raw.local_n1
+    }
+
+    /// The contact normal of all the contacts of this manifold, expressed in the local space of the second shape.
+    pub fn local_n2(&self) -> Vect {
+        self.raw.local_n2
+    }
+
+    /// The first subshape involved in this contact manifold.
+    ///
+    /// This is zero if the first shape is not a composite shape.
+    pub fn subshape1(&self) -> u32 {
+        self.raw.subshape1
+    }
+
+    /// The second subshape involved in this contact manifold.
+    ///
+    /// This is zero if the second shape is not a composite shape.
+    pub fn subshape2(&self) -> u32 {
+        self.raw.subshape2
+    }
+
+    /// The first rigid-body involved in this contact manifold.
+    pub fn rigid_body1(&self) -> Option<Entity> {
+        self.raw
+            .data
+            .rigid_body1
+            .and_then(|h| self.rigidbody_set.rigid_body_entity(h))
+    }
+
+    /// The second rigid-body involved in this contact manifold.
+    pub fn rigid_body2(&self) -> Option<Entity> {
+        self.raw
+            .data
+            .rigid_body2
+            .and_then(|h| self.rigidbody_set.rigid_body_entity(h))
+    }
+
+    /// Flags used to control some aspects of the constraints solver for this contact manifold.
+    pub fn solver_flags(&self) -> SolverFlags {
+        self.raw.data.solver_flags
+    }
+
+    /// The world-space contact normal shared by all the contact in this contact manifold.
+    pub fn normal(&self) -> Vect {
+        self.raw.data.normal
+    }
+
+    /// The contacts that will be seen by the constraints solver for computing forces.
+    pub fn num_solver_contacts(&self) -> usize {
+        self.raw.data.solver_contacts.len()
+    }
+
+    /// Gets the i-th solver contact.
+    pub fn solver_contact(&self, i: usize) -> Option<SolverContactView<'_>> {
+        self.raw
+            .data
+            .solver_contacts
+            .get(i)
+            .map(|raw| SolverContactView {
+                rigidbody_set: self.rigidbody_set,
+                manifold_data: &self.raw.data,
+                raw,
+            })
+    }
+
+    /// The contacts that will be seen by the constraints solver for computing forces.
+    pub fn solver_contacts(&self) -> impl ExactSizeIterator<Item = SolverContactView<'_>> {
+        self.raw
+            .data
+            .solver_contacts
+            .iter()
+            .map(|raw| SolverContactView {
+                rigidbody_set: self.rigidbody_set,
+                manifold_data: &self.raw.data,
+                raw,
+            })
+    }
+
+    /// The relative dominance of the bodies involved in this contact manifold.
+    pub fn relative_dominance(&self) -> i16 {
+        self.raw.data.relative_dominance
+    }
+
+    /// A user-defined piece of data.
+    pub fn user_data(&self) -> u32 {
+        self.raw.data.user_data
+    }
+
+    /// The effective friction coefficient of this manifold's contacts, combined from both
+    /// colliders' materials (or as set by a contact modification hook).
+    pub fn friction(&self) -> Real {
+        self.raw.data.friction
+    }
+
+    /// The effective restitution coefficient of this manifold's contacts, combined from both
+    /// colliders' materials (or as set by a contact modification hook).
+    pub fn restitution(&self) -> Real {
+        self.raw.data.restitution
+    }
+
+    /// The pose of the first shape's subshape involved in this manifold, relative to the first
+    /// collider, if the first shape is a composite shape.
+    pub fn subshape_pose1(&self) -> Option<Transform> {
+        self.raw.subshape_pos1().map(iso_to_transform)
+    }
+
+    /// The pose of the second shape's subshape involved in this manifold, relative to the second
+    /// collider, if the second shape is a composite shape.
+    pub fn subshape_pose2(&self) -> Option<Transform> {
+        self.raw.subshape_pos2().map(iso_to_transform)
+    }
+}
+
+impl ContactManifoldView<'_> {
+    /// Returns the contact with the smallest distance (i.e. the largest penetration depth).
+    pub fn find_deepest_contact(&self) -> Option<ContactView<'_>> {
+        self.raw
+            .find_deepest_contact()
+            .map(|raw| ContactView { raw })
+    }
+}
+
+/// Read-only access to the properties of a single contact.
+pub struct ContactView<'a> {
+    /// The raw contact from Rapier.
+    pub raw: &'a Contact,
+}
+
+impl ContactView<'_> {
+    /// The contact point in the local-space of the first shape.
+    pub fn local_p1(&self) -> Vect {
+        self.raw.local_p1
+    }
+
+    /// The contact point in the local-space of the second shape.
+    pub fn local_p2(&self) -> Vect {
+        self.raw.local_p2
+    }
+
+    /// The distance between the two contact points.
+    pub fn dist(&self) -> Real {
+        self.raw.dist
+    }
+
+    /// The feature ID of the first shape involved in the contact.
+    pub fn fid1(&self) -> u32 {
+        self.raw.fid1.0
+    }
+
+    /// The feature ID of the second shape involved in the contact.
+    pub fn fid2(&self) -> u32 {
+        self.raw.fid2.0
+    }
+
+    /// The impulse, along the contact normal, applied by this contact to the first collider's rigid-body.
+    ///
+    /// The impulse applied to the second collider's rigid-body is given by `-impulse`.
+    pub fn impulse(&self) -> Real {
+        self.raw.data.impulse
+    }
+
+    /// The friction impulse along the vector orthonormal to the contact normal, applied to the first
+    /// collider's rigid-body.
+    #[cfg(feature = "dim2")]
+    pub fn tangent_impulse(&self) -> Real {
+        self.raw.data.tangent_impulse.x
+    }
+
+    /// The friction impulse along the vector orthonormal to the contact normal, applied to the first
+    /// collider's rigid-body.
+    #[cfg(feature = "dim3")]
+    pub fn tangent_impulse(&self) -> [Real; 2] {
+        self.raw.data.tangent_impulse.into()
+    }
+
+    /// The normal impulse retained for warmstarting the next simulation step.
+    pub fn warmstart_impulse(&self) -> Real {
+        self.raw.data.warmstart_impulse
+    }
+
+    /// The friction impulse retained for warmstarting the next simulation step.
+    #[cfg(feature = "dim2")]
+    pub fn warmstart_tangent_impulse(&self) -> Real {
+        self.raw.data.warmstart_tangent_impulse.x
+    }
+
+    /// The friction impulse retained for warmstarting the next simulation step.
+    #[cfg(feature = "dim3")]
+    pub fn warmstart_tangent_impulse(&self) -> [Real; 2] {
+        self.raw.data.warmstart_tangent_impulse.into()
+    }
+
+    /// The twist (rotational friction) impulse retained for warmstarting the next simulation step.
+    #[cfg(feature = "dim3")]
+    pub fn warmstart_twist_impulse(&self) -> Real {
+        self.raw.data.warmstart_twist_impulse
+    }
+}
+
+/// Read-only access to the properties of a single solver contact.
+pub struct SolverContactView<'a> {
+    rigidbody_set: &'a RapierRigidBodySet,
+    /// The data of the contact manifold this solver contact is part of.
+    pub manifold_data: &'a ContactManifoldData,
+    /// The raw solver contact from Rapier.
+    pub raw: &'a SolverContact,
+}
+
+impl SolverContactView<'_> {
+    /// The world-space contact point.
+    pub fn point(&self) -> Vect {
+        let (p1, p2) = self
+            .manifold_data
+            .solver_contact_world_points(self.raw, &self.rigidbody_set.bodies);
+        (p1 + p2) / 2.0
+    }
+    /// The distance between the two original contacts points along the contact normal.
+    /// If negative, this is measures the penetration depth.
+    pub fn dist(&self) -> Real {
+        self.raw.dist
+    }
+    /// The effective friction coefficient at this contact point.
+    pub fn friction(&self) -> Real {
+        self.manifold_data.friction
+    }
+    /// The effective restitution coefficient at this contact point.
+    pub fn restitution(&self) -> Real {
+        self.manifold_data.restitution
+    }
+    /// The desired tangent relative velocity at the contact point.
+    ///
+    /// This is set to zero by default. Set to a non-zero value to
+    /// simulate, e.g., conveyor belts.
+    pub fn tangent_velocity(&self) -> Vect {
+        self.raw.tangent_velocity
+    }
+    /// Whether or not this contact existed during the last timestep.
+    pub fn is_new(&self) -> bool {
+        self.raw.contact_id[0] & NEW_CONTACT_BIT != 0
+    }
+    /// The index, in its manifold's contact points, of the contact this solver contact was
+    /// generated from.
+    ///
+    /// This index is only valid for the timestep that produced this solver contact.
+    pub fn contact_id(&self) -> u32 {
+        self.raw.contact_indices()[0]
+    }
+    /// The raw contact point on the first body's surface, as stored for the solver.
+    ///
+    /// This is expressed in the center-of-mass-centered local frame of the first rigid-body, or in
+    /// world-space if that side is attached to the world (no rigid-body, or a fixed one). Use
+    /// [`Self::world_point1`] for a world-space point.
+    pub fn anchor1(&self) -> Vect {
+        self.raw.anchor1
+    }
+    /// The raw contact point on the second body's surface, as stored for the solver.
+    ///
+    /// See [`Self::anchor1`] for the frame it is expressed in.
+    pub fn anchor2(&self) -> Vect {
+        self.raw.anchor2
+    }
+    /// The world-space contact point on the first body's surface.
+    pub fn world_point1(&self) -> Vect {
+        self.manifold_data
+            .solver_contact_world_points(self.raw, &self.rigidbody_set.bodies)
+            .0
+    }
+    /// The world-space contact point on the second body's surface.
+    pub fn world_point2(&self) -> Vect {
+        self.manifold_data
+            .solver_contact_world_points(self.raw, &self.rigidbody_set.bodies)
+            .1
+    }
+}
+
+/// Read-only access to the properties of a contact pair.
+pub struct ContactPairView<'a> {
+    context_colliders: &'a RapierContextColliders,
+    rigidbody_set: &'a RapierRigidBodySet,
+    /// The raw contact pair from Rapier.
+    pub raw: &'a ContactPair,
+}
+
+impl ContactPairView<'_> {
+    /// The first collider involved in this contact pair.
+    pub fn collider1(&self) -> Option<Entity> {
+        self.context_colliders.collider_entity(self.raw.collider1)
+    }
+
+    /// The second collider involved in this contact pair.
+    pub fn collider2(&self) -> Option<Entity> {
+        self.context_colliders.collider_entity(self.raw.collider2)
+    }
+
+    /// The number of contact manifolds detected for this contact pair.
+    pub fn manifolds_len(&self) -> usize {
+        self.raw.manifolds().len()
+    }
+
+    /// Gets the i-th contact manifold.
+    pub fn manifold(&self, i: usize) -> Option<ContactManifoldView<'_>> {
+        self.raw.manifolds().get(i).map(|raw| ContactManifoldView {
+            rigidbody_set: self.rigidbody_set,
+            raw,
+        })
+    }
+
+    /// Iterate through all the contact manifolds of this contact pair.
+    pub fn manifolds(&self) -> impl ExactSizeIterator<Item = ContactManifoldView<'_>> {
+        self.raw.manifolds().iter().map(|raw| ContactManifoldView {
+            rigidbody_set: self.rigidbody_set,
+            raw,
+        })
+    }
+
+    /// Is there any active contact in this contact pair?
+    pub fn has_any_active_contact(&self) -> bool {
+        self.raw.has_any_active_contact()
+    }
+
+    /// Does this pair hold contact manifolds (every pair except two soft surfaces)?
+    pub fn is_rigid(&self) -> bool {
+        self.raw.rigid().is_some()
+    }
+
+    /// Is this a pair of two soft surfaces, whose contacts are candidates instead of manifolds?
+    ///
+    /// Such pairs have no manifolds; their candidates can be read through
+    /// [`Self::soft_contacts`].
+    pub fn is_soft(&self) -> bool {
+        self.raw.soft().is_some()
+    }
+
+    /// The contacts of this pair: manifolds, or the contact candidates of two soft surfaces.
+    pub fn contacts(&self) -> &PairContacts {
+        &self.raw.contacts
+    }
+
+    /// The contact candidates of a pair of two soft surfaces (`None` for other pairs).
+    pub fn soft_contacts(&self) -> Option<&SoftPairContacts> {
+        self.raw.soft()
+    }
+
+    /// Whether the two soft surfaces of this pair touch: some feature of one surface is within
+    /// contact reach of the other, or the two surfaces cross (`None` for other pairs).
+    pub fn soft_touching(&self) -> Option<bool> {
+        match &self.raw.contacts {
+            PairContacts::Soft { touching, .. } => Some(*touching),
+            PairContacts::Rigid(_) => None,
+        }
+    }
+
+    /// The number of manifolds seen by the constraints solver, see [`Self::solver_manifolds`].
+    pub fn solver_manifolds_len(&self) -> usize {
+        self.raw.solver_manifolds().len()
+    }
+
+    /// Iterate through the contact manifolds actually seen by the constraints solver.
+    ///
+    /// These are the contact clusters if contact clustering applied to this pair (merging the
+    /// manifolds sharing nearly the same normal), and the plain [`Self::manifolds`] otherwise.
+    /// The contact impulses applied by the solver are stored in these manifolds.
+    pub fn solver_manifolds(&self) -> impl ExactSizeIterator<Item = ContactManifoldView<'_>> {
+        self.raw
+            .solver_manifolds()
+            .iter()
+            .map(|raw| ContactManifoldView {
+                rigidbody_set: self.rigidbody_set,
+                raw,
+            })
+    }
+
+    /// The sum of all the contact impulses applied by the solver to the first collider during
+    /// the last timestep.
+    ///
+    /// Divide by the timestep length to obtain a force.
+    pub fn total_impulse(&self) -> Vect {
+        self.raw.total_impulse()
+    }
+
+    /// The sum of the magnitudes of all the contact impulses applied during the last timestep.
+    ///
+    /// This is not the magnitude of [`Self::total_impulse`]; it is the quantity compared against
+    /// the contact force event threshold (after conversion to a force).
+    pub fn total_impulse_magnitude(&self) -> Real {
+        self.raw.total_impulse_magnitude()
+    }
+
+    /// The magnitude and world-space direction of the strongest contact impulse applied during
+    /// the last timestep.
+    pub fn max_impulse(&self) -> (Real, Vect) {
+        self.raw.max_impulse()
+    }
+
+    /// Finds the contact with the smallest signed distance.
+    ///
+    /// If the colliders involved in this contact pair are penetrating, then
+    /// this returns the contact with the largest penetration depth.
+    ///
+    /// Returns a reference to the contact, as well as the contact manifold
+    /// it is part of.
+    pub fn find_deepest_contact(&self) -> Option<(ContactManifoldView<'_>, ContactView<'_>)> {
+        self.raw.find_deepest_contact().map(|(manifold, contact)| {
+            (
+                ContactManifoldView {
+                    rigidbody_set: self.rigidbody_set,
+                    raw: manifold,
+                },
+                ContactView { raw: contact },
+            )
+        })
+    }
+}
+
+#[cfg(test)]
+mod test {
+    use crate::math::Real;
+    use crate::prelude::*;
+    use bevy::{
+        prelude::*,
+        time::{TimePlugin, TimeUpdateStrategy},
+    };
+
+    #[cfg(feature = "dim3")]
+    fn cuboid(hx: Real, hy: Real, hz: Real) -> Collider {
+        Collider::cuboid(hx, hy, hz)
+    }
+    #[cfg(feature = "dim2")]
+    fn cuboid(hx: Real, hy: Real, _hz: Real) -> Collider {
+        Collider::cuboid(hx, hy)
+    }
+
+    #[test]
+    fn resting_box_contact_impulses() {
+        let mut app = App::new();
+        app.add_plugins((
+            TransformPlugin,
+            TimePlugin,
+            RapierPhysicsPlugin::<NoUserData>::default(),
+        ))
+        .insert_resource(TimeUpdateStrategy::ManualDuration(
+            std::time::Duration::from_secs_f32(1f32 / 60f32),
+        ));
+        let ground = app
+            .world_mut()
+            .spawn((Transform::from_xyz(0.0, -1.0, 0.0), cuboid(4.0, 1.0, 4.0)))
+            .id();
+        let body = app
+            .world_mut()
+            .spawn((
+                Transform::from_xyz(0.0, 0.6, 0.0),
+                RigidBody::Dynamic,
+                cuboid(0.5, 0.5, 0.5),
+                // Keep the box awake so the impulses are refreshed at every step.
+                Sleeping::disabled(),
+            ))
+            .id();
+        app.finish();
+        for _ in 0..60 {
+            app.update();
+        }
+
+        let mut query = app.world_mut().query::<(
+            &RapierContextSimulation,
+            &RapierContextColliders,
+            &RapierRigidBodySet,
+        )>();
+        let (simulation, colliders, bodies) = query.single(app.world()).unwrap();
+        let pair = simulation
+            .contact_pair(colliders, bodies, ground, body)
+            .unwrap();
+        assert!(pair.is_rigid());
+        assert!(!pair.is_soft());
+        assert!(pair.has_any_active_contact());
+        assert!(pair.solver_manifolds_len() > 0);
+        assert!(pair.total_impulse_magnitude() > 0.0);
+        assert!(pair.total_impulse().length() > 0.0);
+        let (max_impulse, max_dir) = pair.max_impulse();
+        assert!(max_impulse > 0.0);
+        assert!(max_dir.y.abs() > 0.9);
+
+        let manifold = pair.solver_manifolds().next().unwrap();
+        assert!(manifold.friction() > 0.0);
+        assert!(manifold.subshape_pose1().is_none());
+        assert!(manifold.points().any(|c| c.warmstart_impulse() > 0.0));
+        for solver_contact in manifold.solver_contacts() {
+            assert!((solver_contact.contact_id() as usize) < manifold.num_points());
+            let midpoint = (solver_contact.world_point1() + solver_contact.world_point2()) / 2.0;
+            assert!((midpoint - solver_contact.point()).length() < 1.0e-5);
+        }
+
+        assert!(simulation.contact_graph().interactions().count() > 0);
+        assert_eq!(simulation.intersection_graph().interactions().count(), 0);
+    }
+}
diff --git a/bindings/bevy_rapier/src/plugin/plugin.rs b/bindings/bevy_rapier/src/plugin/plugin.rs
new file mode 100644
index 000000000..159c1ff0a
--- /dev/null
+++ b/bindings/bevy_rapier/src/plugin/plugin.rs
@@ -0,0 +1,883 @@
+use crate::pipeline::{CollisionEvent, ContactForceEvent};
+use crate::prelude::*;
+use crate::reflect::{IntegrationParametersWrapper, JointAxisWrapper, SpringCoefficientsWrapper};
+use bevy::app::DynEq;
+use bevy::ecs::{
+    intern::Interned,
+    schedule::{IntoScheduleConfigs, ScheduleConfigs, ScheduleLabel},
+    system::{ScheduleSystem, SystemParamItem},
+};
+use bevy::platform::collections::HashSet;
+use bevy::{prelude::*, transform::TransformSystems};
+use rapier::dynamics::IntegrationParameters;
+use std::marker::PhantomData;
+
+use super::context::DefaultRapierContext;
+
+#[cfg(doc)]
+use crate::plugin::context::systemparams::RapierContext;
+
+/// No specific user-data is associated to the hooks.
+pub type NoUserData = ();
+
+/// A plugin responsible for setting up a full Rapier physics simulation pipeline and resources.
+///
+/// This will automatically setup all the resources needed to run a physics simulation with the
+/// Rapier physics engine.
+pub struct RapierPhysicsPlugin<PhysicsHooks = ()> {
+    schedule: Interned<dyn ScheduleLabel>,
+    default_system_setup: bool,
+    /// Read during [`RapierPhysicsPlugin::build()`],
+    /// to help initializing [`RapierContextInitialization`] resource.
+    /// This will be ignored if that resource already exists.
+    default_world_setup: RapierContextInitialization,
+    /// Controls whether given `PhysicsSets` systems are injected into the scheduler.
+    ///
+    /// This is useful to opt out of default plugin behaviour, for example if you need to reorganize
+    /// the systems in different schedules.
+    ///
+    /// If passing an empty set, the plugin will still add the Physics Sets to the plugin schedule,
+    /// but no systems will be added automatically.
+    enabled_physics_schedules: HashSet<PhysicsSet>,
+    _phantom: PhantomData<PhysicsHooks>,
+}
+
+impl<PhysicsHooks> RapierPhysicsPlugin<PhysicsHooks>
+where
+    PhysicsHooks: 'static + BevyPhysicsHooks,
+    for<'w, 's> SystemParamItem<'w, 's, PhysicsHooks>: BevyPhysicsHooks,
+{
+    /// Specifies a scale ratio between the physics world and the bevy transforms.
+    ///
+    /// This affects the size of every elements in the physics engine, by multiplying
+    /// all the length-related quantities by the `length_unit` factor. This should
+    /// likely always be 1.0 in 3D. In 2D, this is useful to specify a "pixels-per-meter"
+    /// conversion ratio.
+    pub fn with_length_unit(mut self, length_unit: f32) -> Self {
+        self.default_world_setup =
+            RapierContextInitialization::default_with_length_unit(length_unit);
+        self
+    }
+
+    /// Specifies a default world initialization strategy.
+    ///
+    /// The default is to initialize a [`RapierContext`] with a length unit of 1.
+    pub fn with_custom_initialization(
+        mut self,
+        default_world_initialization: RapierContextInitialization,
+    ) -> Self {
+        self.default_world_setup = default_world_initialization;
+        self
+    }
+
+    /// Specifies whether the plugin should setup each of its [`PhysicsSet`]
+    /// (`true`), or if the user will set them up later (`false`).
+    ///
+    /// The default value is `true`.
+    pub fn with_default_system_setup(mut self, default_system_setup: bool) -> Self {
+        self.default_system_setup = default_system_setup;
+        self
+    }
+
+    /// Specifies how many pixels on the 2D canvas equal one meter on the physics world.
+    ///
+    /// This conversion unit assumes that the 2D camera uses an unscaled projection.
+    #[cfg(feature = "dim2")]
+    pub fn pixels_per_meter(pixels_per_meter: f32) -> Self {
+        Self {
+            default_system_setup: true,
+            default_world_setup: RapierContextInitialization::default_with_length_unit(
+                pixels_per_meter,
+            ),
+            ..default()
+        }
+    }
+
+    /// Controls whether given `PhysicsSets` systems are injected into the scheduler.
+    ///
+    /// This is useful to opt out of default plugin behaviour, for example if you need to reorganize
+    /// the systems in different schedules.
+    ///
+    /// If passing an empty set, the plugin will still add the Physics Sets to the plugin schedule,
+    /// but no systems will be added automatically.
+    pub fn with_physics_sets_systems(
+        mut self,
+        enabled_physics_schedules: HashSet<PhysicsSet>,
+    ) -> Self {
+        self.enabled_physics_schedules = enabled_physics_schedules;
+        self
+    }
+
+    /// Adds the physics systems to the `FixedUpdate` schedule rather than `PostUpdate`.
+    pub fn in_fixed_schedule(self) -> Self {
+        self.in_schedule(FixedUpdate)
+    }
+
+    /// Adds the physics systems to the provided schedule rather than `PostUpdate`.
+    pub fn in_schedule(mut self, schedule: impl ScheduleLabel) -> Self {
+        self.schedule = schedule.intern();
+        self
+    }
+
+    /// Provided for use when staging systems outside of this plugin using
+    /// [`with_default_system_setup(false)`](Self::with_default_system_setup).
+    /// See [`PhysicsSet`] for a description of these systems.
+    pub fn get_systems(set: PhysicsSet) -> ScheduleConfigs<ScheduleSystem> {
+        match set {
+            PhysicsSet::SyncBackend => (
+                (
+                    // Initialize the rapier configuration.
+                    // A good candidate for required component or hook components.
+                    // The configuration is needed for following systems, so it should be chained.
+                    setup_rapier_configuration,
+                    // Run the character controller before the manual transform propagation.
+                    systems::update_character_controls,
+                )
+                    .chain()
+                    .in_set(PhysicsSet::SyncBackend),
+                // Run Bevy transform propagation additionally to sync [`GlobalTransform`]
+                (
+                    bevy::transform::systems::sync_simple_transforms,
+                    bevy::transform::systems::propagate_parent_transforms,
+                )
+                    .chain()
+                    .in_set(RapierTransformPropagateSet),
+                (
+                    (
+                        systems::on_add_entity_with_parent,
+                        systems::on_change_context,
+                        systems::reset_removed_soft_body_cluster_components,
+                        systems::sync_removals,
+                        systems::reset_removed_rigid_body_components,
+                        systems::reset_removed_collider_components,
+                        systems::sync_soft_body_removals,
+                        systems::reset_removed_soft_body_components,
+                        #[cfg(all(feature = "dim3", feature = "async-collider"))]
+                        systems::init_async_scene_colliders,
+                        #[cfg(all(feature = "dim3", feature = "async-collider"))]
+                        systems::init_async_colliders,
+                        systems::init_rigid_bodies,
+                        systems::init_soft_bodies,
+                        systems::init_soft_body_clusters,
+                        systems::init_colliders,
+                        systems::init_joints,
+                    )
+                        .chain()
+                        .in_set(PhysicsSet::SyncBackend),
+                    (
+                        (
+                            systems::apply_scale.in_set(RapierBevyComponentApply),
+                            systems::apply_collider_user_changes.in_set(RapierBevyComponentApply),
+                        )
+                            .chain(),
+                        systems::apply_joint_user_changes.in_set(RapierBevyComponentApply),
+                    ),
+                    // TODO: joints and colliders might be parallelizable.
+                    systems::apply_multibody_joint_properties.in_set(RapierBevyComponentApply),
+                    systems::apply_initial_rigid_body_impulses.in_set(RapierBevyComponentApply),
+                    systems::apply_rigid_body_user_changes.in_set(RapierBevyComponentApply),
+                    systems::apply_soft_body_user_changes.in_set(RapierBevyComponentApply),
+                    systems::apply_soft_body_cluster_changes.in_set(RapierBevyComponentApply),
+                    // Controllers act on the rigid-bodies' up-to-date state, right before the step.
+                    systems::update_pid_controllers.in_set(RapierBevyComponentApply),
+                    #[cfg(feature = "dim3")]
+                    systems::update_vehicle_controllers.in_set(RapierBevyComponentApply),
+                )
+                    .chain(),
+            )
+                .chain()
+                .into_configs(),
+            PhysicsSet::StepSimulation => (systems::step_simulation::<PhysicsHooks>)
+                .in_set(PhysicsSet::StepSimulation)
+                .into_configs(),
+            PhysicsSet::Writeback => (
+                systems::update_colliding_entities,
+                systems::writeback_rigid_bodies,
+                // Each writeback write to different properties.
+                systems::writeback_mass_properties.ambiguous_with(systems::writeback_rigid_bodies),
+                systems::writeback_collider_mass_properties,
+                systems::writeback_impulse_joint_impulses,
+                systems::writeback_multibody_joint_states,
+                (
+                    systems::handle_soft_body_tears,
+                    systems::writeback_soft_bodies,
+                    // Modified meshes must emit their asset events this frame.
+                    #[cfg(feature = "to-bevy-mesh")]
+                    systems::sync_soft_body_meshes.before(bevy::asset::AssetEventSystems),
+                )
+                    .chain()
+                    .after(systems::writeback_rigid_bodies)
+                    .after(systems::writeback_mass_properties)
+                    .after(systems::writeback_collider_mass_properties)
+                    .after(systems::writeback_impulse_joint_impulses)
+                    .after(systems::writeback_multibody_joint_states),
+            )
+                .in_set(PhysicsSet::Writeback)
+                .into_configs(),
+        }
+    }
+}
+
+/// A set for rapier's copying bevy_rapier's Bevy components back into rapier.
+#[derive(Debug, Hash, PartialEq, Eq, Clone, SystemSet)]
+pub struct RapierBevyComponentApply;
+
+/// A set for rapier's copy of Bevy's transform propagation systems.
+///
+/// See [`TransformSystems`](bevy::transform::TransformSystems::Propagate).
+#[derive(Debug, Hash, PartialEq, Eq, Clone, SystemSet)]
+pub struct RapierTransformPropagateSet;
+
+impl<PhysicsHooksSystemParam> Default for RapierPhysicsPlugin<PhysicsHooksSystemParam> {
+    fn default() -> Self {
+        Self {
+            schedule: PostUpdate.intern(),
+            default_system_setup: true,
+            default_world_setup: Default::default(),
+            enabled_physics_schedules: HashSet::from_iter([
+                PhysicsSet::SyncBackend,
+                PhysicsSet::StepSimulation,
+                PhysicsSet::Writeback,
+            ]),
+            _phantom: PhantomData,
+        }
+    }
+}
+
+/// [`SystemSet`] for each phase of the plugin.
+#[derive(SystemSet, Debug, Hash, PartialEq, Eq, Clone)]
+pub enum PhysicsSet {
+    /// This set runs the systems responsible for synchronizing (and
+    /// initializing) backend data structures with current component state.
+    /// These systems typically run at the after [`Update`].
+    SyncBackend,
+    /// The systems responsible for advancing the physics simulation, and
+    /// updating the internal state for scene queries.
+    /// These systems typically run immediately after [`PhysicsSet::SyncBackend`].
+    StepSimulation,
+    /// The systems responsible for updating
+    /// [`crate::geometry::CollidingEntities`] and writing
+    /// the result of the last simulation step into our `bevy_rapier`
+    /// components and the [`GlobalTransform`] component.
+    /// These systems typically run immediately after [`PhysicsSet::StepSimulation`].
+    Writeback,
+}
+
+impl<PhysicsHooks> Plugin for RapierPhysicsPlugin<PhysicsHooks>
+where
+    PhysicsHooks: 'static + BevyPhysicsHooks,
+    for<'w, 's> SystemParamItem<'w, 's, PhysicsHooks>: BevyPhysicsHooks,
+{
+    fn build(&self, app: &mut App) {
+        // Register components as reflectable.
+        app.register_type::<RigidBody>()
+            .register_type::<Velocity>()
+            .register_type::<AdditionalMassProperties>()
+            .register_type::<MassProperties>()
+            .register_type::<LockedAxes>()
+            .register_type::<ExternalForce>()
+            .register_type::<ExternalImpulse>()
+            .register_type::<Sleeping>()
+            .register_type::<Damping>()
+            .register_type::<Dominance>()
+            .register_type::<Ccd>()
+            .register_type::<SoftCcd>()
+            .register_type::<GravityScale>()
+            .register_type::<ReadWorldMassProperties>()
+            .register_type::<AdditionalSolverIterations>()
+            .register_type::<AdditionalPgsIterations>()
+            .register_type::<AllowFastRotation>()
+            .register_type::<CollidingEntities>()
+            .register_type::<Sensor>()
+            .register_type::<Friction>()
+            .register_type::<Restitution>()
+            .register_type::<CollisionGroups>()
+            .register_type::<SolverGroups>()
+            .register_type::<ContactForceEventThreshold>()
+            .register_type::<ContactSkin>()
+            .register_type::<ReadColliderMassProperties>()
+            .register_type::<InteractionTestMode>()
+            .register_type::<Group>()
+            .register_type::<RapierContextEntityLink>()
+            .register_type::<RapierConfiguration>()
+            .register_type::<SimulationMode>()
+            .register_type::<BroadPhaseOptimizationStrategy>()
+            .register_type::<SimulationToRenderTime>()
+            .register_type::<DefaultRapierContext>()
+            .register_type::<RapierContextInitialization>()
+            .register_type::<ImpulseJointDisabled>()
+            .register_type::<ImpulseJointImpulses>()
+            .register_type::<KinematicMultibodyJoint>()
+            .register_type::<MultibodyJointDamping>()
+            .register_type::<MultibodyJointFriction>()
+            .register_type::<MultibodyJointArmature>()
+            .register_type::<MultibodyJointSprings>()
+            .register_type::<MultibodyJointCoupling>()
+            .register_type::<MultibodyJointCouplings>()
+            .register_type::<MultibodySelfContactsDisabled>()
+            .register_type::<MultibodyJointState>()
+            .register_type::<SpringCoefficientsWrapper>()
+            .register_type::<JointAxisWrapper>()
+            .register_type::<AxesMask>()
+            .register_type::<PidTarget>()
+            .register_type::<ControllerIgnored>()
+            .register_type::<PdController>()
+            .register_type::<PidController>()
+            .register_type::<SoftBodyMaterial>()
+            .register_type::<SoftBodyDisabled>()
+            .register_type::<SoftBodyPinnedParticles>()
+            .register_type::<SoftBodyKinematicTargets>()
+            .register_type::<SoftBodyAttachment>()
+            .register_type::<SoftBodyAttachments>()
+            .register_type::<SoftBodyExternalForce>()
+            .register_type::<SoftBodyExternalImpulse>()
+            .register_type::<SoftBodyVolumeFactor>()
+            .register_type::<SoftBodyState>()
+            .register_type::<SoftBodyCluster>()
+            .register_type::<SoftBodyClusterPinned>()
+            .register_type::<SoftBodyClusterKinematicTarget>()
+            .register_type::<SoftBodyClusterShapeMatching>()
+            .register_type::<crate::reflect::SoftBodiesSettingsWrapper>()
+            .register_type::<crate::reflect::SoftRecoverySettingsWrapper>()
+            .register_type::<crate::reflect::SoftPatchConstraintsWrapper>()
+            .register_type::<crate::reflect::SoftBodyMaterialWrapper>()
+            .register_type::<crate::reflect::SoftEdgePlasticFlowWrapper>();
+        #[cfg(feature = "fem")]
+        app.register_type::<crate::reflect::SoftFemParametersWrapper>();
+        #[cfg(feature = "dim3")]
+        app.register_type::<GyroscopicForces>()
+            .register_type::<crate::reflect::WheelTuningWrapper>()
+            .register_type::<VehicleWheelState>()
+            .register_type::<VehicleWheel>()
+            .register_type::<RayCastVehicleController>();
+
+        app.insert_resource(Messages::<CollisionEvent>::default())
+            .insert_resource(Messages::<ContactForceEvent>::default())
+            .insert_resource(Messages::<MassModifiedEvent>::default())
+            .add_message::<PhysicsQuarantineEvent>()
+            .add_message::<SoftBodyTearEvent>();
+        let default_world_init = app.world().get_resource::<RapierContextInitialization>();
+        if let Some(world_init) = default_world_init {
+            log::warn!("RapierPhysicsPlugin added but a `RapierContextInitialization` resource was already existing.\
+            This might overwrite previous configuration made via `RapierPhysicsPlugin::with_custom_initialization`\
+            or `RapierPhysicsPlugin::with_length_unit`.
+            The following resource will be used: {world_init:?}");
+        } else {
+            app.insert_resource(self.default_world_setup.clone());
+        }
+
+        app.add_systems(
+            PreStartup,
+            (insert_default_context, setup_rapier_configuration).chain(),
+        );
+
+        // These *must* be in the main schedule currently so that they do not miss events.
+        // See test `test_sync_removal` for an example of this.
+        if self.schedule != PostUpdate.intern() {
+            app.add_systems(
+                PostUpdate,
+                (
+                    systems::reset_removed_soft_body_cluster_components,
+                    systems::sync_removals,
+                    systems::reset_removed_rigid_body_components,
+                    systems::reset_removed_collider_components,
+                    systems::sync_soft_body_removals,
+                    systems::reset_removed_soft_body_components,
+                )
+                    .chain()
+                    .before(TransformSystems::Propagate),
+            );
+        }
+
+        // Add each set as necessary
+        if self.default_system_setup {
+            app.configure_sets(
+                self.schedule,
+                (
+                    PhysicsSet::SyncBackend,
+                    PhysicsSet::StepSimulation,
+                    PhysicsSet::Writeback,
+                )
+                    .chain()
+                    .before(TransformSystems::Propagate),
+            );
+            app.configure_sets(
+                self.schedule,
+                RapierTransformPropagateSet.in_set(PhysicsSet::SyncBackend),
+            );
+            app.configure_sets(
+                self.schedule,
+                RapierBevyComponentApply.in_set(PhysicsSet::SyncBackend),
+            );
+            let mut add_systems_if_enabled = |physics_set: PhysicsSet| {
+                if self.enabled_physics_schedules.contains(&physics_set) {
+                    app.add_systems(self.schedule, Self::get_systems(physics_set));
+                }
+            };
+            add_systems_if_enabled(PhysicsSet::SyncBackend);
+            add_systems_if_enabled(PhysicsSet::Writeback);
+            add_systems_if_enabled(PhysicsSet::StepSimulation);
+
+            app.init_resource::<TimestepMode>();
+
+            // Warn user if the timestep mode isn't in Fixed
+            if self.schedule.dyn_eq(&FixedUpdate as &dyn DynEq) {
+                let config = app.world_mut().resource::<TimestepMode>();
+                match config {
+                    TimestepMode::Fixed { .. } => {}
+                    mode => {
+                        log::warn!("TimestepMode is set to `{mode:?}`, it is recommended to use `TimestepMode::Fixed` if you have the physics in `FixedUpdate`");
+                    }
+                }
+            }
+        }
+    }
+
+    fn finish(&self, _app: &mut App) {
+        #[cfg(all(feature = "dim3", feature = "async-collider"))]
+        {
+            use bevy::{
+                asset::AssetPlugin, mesh::MeshPlugin, world_serialization::WorldSerializationPlugin,
+            };
+            if !_app.is_plugin_added::<AssetPlugin>() {
+                _app.add_plugins(AssetPlugin::default());
+            }
+            if !_app.is_plugin_added::<MeshPlugin>() {
+                _app.add_plugins(MeshPlugin);
+            }
+            if !_app.is_plugin_added::<WorldSerializationPlugin>() {
+                _app.add_plugins(WorldSerializationPlugin);
+            }
+        }
+    }
+}
+
+/// Specifies a default configuration for the default [`RapierContext`]
+///
+/// Designed to be passed as parameter to [`RapierPhysicsPlugin::with_custom_initialization`].
+#[derive(Resource, Debug, Reflect, Clone)]
+#[cfg_attr(feature = "serde-serialize", derive(Serialize, Deserialize))]
+#[allow(clippy::large_enum_variant)] // Only a single instance of this resource exists.
+pub enum RapierContextInitialization {
+    /// [`RapierPhysicsPlugin`] will not spawn any entity containing [`RapierContextSimulation`] automatically.
+    ///
+    /// You are responsible for creating a [`RapierContextSimulation`],
+    /// before spawning any rapier entities (rigidbodies, colliders, joints).
+    ///
+    /// You might be interested in adding [`DefaultRapierContext`] to the created physics context.
+    NoAutomaticRapierContext,
+    /// [`RapierPhysicsPlugin`] will spawn an entity containing a [`RapierContextSimulation`]
+    /// automatically during [`PreStartup`], with the [`DefaultRapierContext`] marker component.
+    InitializeDefaultRapierContext {
+        /// Integration parameters component which will be added to the default rapier context.
+        #[reflect(remote = IntegrationParametersWrapper)]
+        integration_parameters: IntegrationParameters,
+        /// Rapier configuration component which will be added to the default rapier context.
+        rapier_configuration: RapierConfiguration,
+        /// The strategy used to keep the broad-phase BVH of the default rapier context efficient.
+        broad_phase_optimization_strategy: BroadPhaseOptimizationStrategy,
+    },
+}
+
+impl Default for RapierContextInitialization {
+    fn default() -> Self {
+        Self::default_with_length_unit(1f32)
+    }
+}
+
+impl RapierContextInitialization {
+    /// Configures rapier with the specified length unit.
+    ///
+    /// See the documentation of [`IntegrationParameters::length_unit`] for additional details
+    /// on that argument.
+    ///
+    /// The default gravity is automatically scaled by that length unit.
+    pub fn default_with_length_unit(length_unit: f32) -> Self {
+        let integration_parameters = IntegrationParameters {
+            length_unit,
+            ..default()
+        };
+
+        RapierContextInitialization::InitializeDefaultRapierContext {
+            integration_parameters,
+            rapier_configuration: RapierConfiguration::new(length_unit),
+            broad_phase_optimization_strategy: BroadPhaseOptimizationStrategy::default(),
+        }
+    }
+}
+
+pub fn insert_default_context(
+    mut commands: Commands,
+    initialization_data: Res<RapierContextInitialization>,
+) {
+    match initialization_data.as_ref() {
+        RapierContextInitialization::NoAutomaticRapierContext => {}
+        RapierContextInitialization::InitializeDefaultRapierContext {
+            integration_parameters,
+            rapier_configuration,
+            broad_phase_optimization_strategy,
+        } => {
+            commands.spawn((
+                Name::new("Rapier Context"),
+                RapierContextSimulation {
+                    integration_parameters: *integration_parameters,
+                    ..RapierContextSimulation::with_broad_phase_optimization_strategy(
+                        *broad_phase_optimization_strategy,
+                    )
+                },
+                *rapier_configuration,
+                DefaultRapierContext,
+            ));
+        }
+    }
+}
+
+pub fn setup_rapier_configuration(
+    mut commands: Commands,
+    rapier_context: Query<(Entity, &RapierContextSimulation), Without<RapierConfiguration>>,
+) {
+    for (e, rapier_context) in rapier_context.iter() {
+        commands.entity(e).insert(RapierConfiguration::new(
+            rapier_context.integration_parameters.length_unit,
+        ));
+    }
+}
+
+#[cfg(test)]
+mod test {
+
+    use bevy::{
+        ecs::schedule::{NodeId, Stepping},
+        prelude::Component,
+        time::{TimePlugin, TimeUpdateStrategy},
+    };
+    use rapier::{data::Index, dynamics::RigidBodyHandle};
+
+    use crate::{plugin::context::*, plugin::*, prelude::*};
+
+    #[cfg(feature = "dim3")]
+    fn cuboid(hx: Real, hy: Real, hz: Real) -> Collider {
+        Collider::cuboid(hx, hy, hz)
+    }
+    #[cfg(feature = "dim2")]
+    fn cuboid(hx: Real, hy: Real, _hz: Real) -> Collider {
+        Collider::cuboid(hx, hy)
+    }
+
+    #[derive(Component)]
+    pub struct TestMarker;
+
+    #[test]
+    pub fn hierarchy_link_propagation() {
+        return main();
+
+        use bevy::prelude::*;
+
+        fn run_test(app: &mut App) {
+            app.insert_resource(TimeUpdateStrategy::ManualDuration(
+                std::time::Duration::from_secs_f32(1f32 / 60f32),
+            ));
+
+            app.add_systems(Update, setup_physics);
+
+            app.finish();
+
+            let mut stepping = Stepping::new();
+
+            app.update();
+
+            stepping
+                .add_schedule(PostUpdate)
+                .add_schedule(Update)
+                .enable()
+                .set_breakpoint(PostUpdate, systems::on_add_entity_with_parent)
+                .set_breakpoint(PostUpdate, systems::init_rigid_bodies)
+                .set_breakpoint(PostUpdate, systems::on_change_context)
+                .set_breakpoint(PostUpdate, systems::sync_removals)
+                .set_breakpoint(Update, setup_physics);
+
+            app.insert_resource(stepping);
+
+            let mut stepping = app.world_mut().resource_mut::<Stepping>();
+            // Advancing once to get the context.
+            stepping.continue_frame();
+            app.update();
+            // arbitrary hardcoded amount to run the simulation for a few frames.
+            // This test uses stepping so the actual amount of frames is this `number / breakpoints`
+            for _ in 0..20 {
+                let world = app.world_mut();
+                let stepping = world.resource_mut::<Stepping>();
+                if let Some(cursor) = &stepping.cursor() {
+                    let system = world
+                        .resource::<Schedules>()
+                        .get(cursor.0)
+                        .unwrap()
+                        .systems()
+                        .unwrap()
+                        .find(|s| NodeId::System(s.0) == cursor.1)
+                        .unwrap();
+                    println!(
+                        "next system: {}",
+                        system
+                            .1
+                            .name()
+                            .to_string()
+                            .split_terminator("::")
+                            .last()
+                            .unwrap()
+                    );
+                } else {
+                    println!("no cursor, new frame!");
+                }
+                let mut stepping = world.resource_mut::<Stepping>();
+                stepping.continue_frame();
+                app.update();
+
+                let rigidbody_set = app
+                    .world_mut()
+                    .query::<&RapierRigidBodySet>()
+                    .single(app.world())
+                    .unwrap();
+
+                println!("{:?}", rigidbody_set.entity2body);
+            }
+            let rigidbody_set = app
+                .world_mut()
+                .query::<&RapierRigidBodySet>()
+                .single(app.world())
+                .unwrap();
+
+            assert_eq!(
+                rigidbody_set.entity2body.iter().next().unwrap().1,
+                // assert the generation is 0, that means we didn't modify it twice (due to change world detection)
+                &RigidBodyHandle(Index::from_raw_parts(0, 0))
+            );
+        }
+
+        fn main() {
+            let mut app = App::new();
+            app.add_plugins((
+                TransformPlugin,
+                TimePlugin,
+                RapierPhysicsPlugin::<NoUserData>::default(),
+            ));
+            run_test(&mut app);
+        }
+
+        pub fn setup_physics(mut commands: Commands, mut counter: Local<i32>) {
+            // run on the 3rd iteration: I believe current logic is:
+            // - 1st is to setup bevy internals
+            // - 2nd is to wait for having stepping enabled, as I couldnt get it to work for the first update.
+            // - 3rd, we're looking to test adding a rapier entity while playing, opposed to a Startup function,
+            //   which most examples are focused on.
+            let run_at = 3;
+            if *counter == run_at {
+                return;
+            }
+            *counter += 1;
+            if *counter < run_at {
+                return;
+            }
+
+            commands.spawn((
+                Transform::from_xyz(0.0, 13.0, 0.0),
+                RigidBody::Dynamic,
+                cuboid(0.5, 0.5, 0.5),
+                TestMarker,
+            ));
+        }
+    }
+
+    #[test]
+    pub fn test_sync_removal() {
+        return main();
+
+        use bevy::prelude::*;
+
+        fn run_test(app: &mut App) {
+            app.insert_resource(TimeUpdateStrategy::ManualDuration(
+                std::time::Duration::from_secs_f32(1f32 / 60f32),
+            ));
+            app.insert_resource(Time::<Fixed>::from_hz(20.0));
+
+            app.add_systems(Startup, setup_physics);
+            app.add_systems(Update, remove_rapier_entity);
+            app.add_systems(FixedUpdate, || println!("Fixed Update"));
+            app.add_systems(Update, || println!("Update"));
+            app.finish();
+            // startup
+            app.update();
+            // normal updates starting
+            // render only
+            app.update();
+            app.update();
+            // render + physics
+            app.update();
+
+            let mut context_query = app.world_mut().query::<RapierContext>();
+            let context = context_query.single(app.world()).unwrap();
+            assert_eq!(context.rigidbody_set.entity2body.len(), 1);
+
+            // render only + remove entities
+            app.update();
+            // Fixed Update hasn´t run yet, so it's a risk of not having caught the bevy removed event, which will be cleaned next frame.
+
+            let mut context_query = app.world_mut().query::<RapierContext>();
+            let context = context_query.single(app.world()).unwrap();
+
+            println!("{:?}", context.rigidbody_set.entity2body);
+            assert_eq!(context.rigidbody_set.entity2body.len(), 0);
+        }
+
+        fn main() {
+            let mut app = App::new();
+            app.add_plugins((
+                TransformPlugin,
+                TimePlugin,
+                RapierPhysicsPlugin::<NoUserData>::default().in_fixed_schedule(),
+            ));
+            run_test(&mut app);
+        }
+
+        pub fn setup_physics(mut commands: Commands) {
+            commands.spawn((
+                Transform::from_xyz(0.0, 13.0, 0.0),
+                RigidBody::Dynamic,
+                cuboid(0.5, 0.5, 0.5),
+                TestMarker,
+            ));
+            println!("spawned rapier entity");
+        }
+        pub fn remove_rapier_entity(
+            mut commands: Commands,
+            to_remove: Query<Entity, With<TestMarker>>,
+            mut counter: Local<i32>,
+        ) {
+            *counter += 1;
+            if *counter != 5 {
+                return;
+            }
+            println!("removing rapier entity");
+            for e in &to_remove {
+                commands.entity(e).despawn();
+            }
+        }
+    }
+
+    #[test]
+    fn parent_child() {
+        return main();
+
+        use bevy::prelude::*;
+
+        fn main() {
+            let mut app = App::new();
+            app.add_plugins((
+                TransformPlugin,
+                TimePlugin,
+                RapierPhysicsPlugin::<NoUserData>::default().in_fixed_schedule(),
+            ));
+            run_test(&mut app);
+        }
+
+        fn run_test(app: &mut App) {
+            app.insert_resource(TimeUpdateStrategy::ManualDuration(
+                std::time::Duration::from_secs_f32(1f32 / 60f32),
+            ));
+            app.add_systems(Startup, init_rapier_configuration);
+            app.add_systems(Startup, setup_physics);
+
+            app.finish();
+            for _ in 0..100 {
+                app.update();
+            }
+
+            let mut context_query = app.world_mut().query::<RapierContext>();
+            let context = context_query.single(app.world()).unwrap();
+
+            println!("{:#?}", context.rigidbody_set.bodies);
+        }
+
+        pub fn init_rapier_configuration(
+            mut config: Query<&mut RapierConfiguration, With<DefaultRapierContext>>,
+        ) {
+            let mut config = config.single_mut().unwrap();
+            *config = RapierConfiguration {
+                force_update_from_transform_changes: true,
+                ..RapierConfiguration::new(1f32)
+            };
+        }
+
+        pub fn setup_physics(mut commands: Commands) {
+            let parent = commands
+                .spawn(Transform::from_scale(Vec3::splat(5f32)))
+                .id();
+            let mut entity_commands = commands.spawn((
+                Collider::ball(1f32),
+                Transform::from_translation(Vec3::new(200f32, 100f32, 3f32)),
+                RigidBody::Fixed,
+            ));
+            entity_commands.insert(ChildOf(parent));
+        }
+    }
+
+    #[test]
+    fn initial_scale() {
+        return main();
+
+        use bevy::prelude::*;
+
+        fn main() {
+            let mut app = App::new();
+            app.add_plugins((
+                TransformPlugin,
+                TimePlugin,
+                RapierPhysicsPlugin::<NoUserData>::default().in_fixed_schedule(),
+            ));
+            run_test(&mut app);
+        }
+
+        fn run_test(app: &mut App) {
+            app.insert_resource(TimeUpdateStrategy::ManualDuration(
+                std::time::Duration::from_secs_f32(1f32 / 60f32),
+            ));
+            app.add_systems(Update, setup_physics.run_if(run_once));
+
+            app.finish();
+
+            // Running startup
+            app.update();
+            // Running first physics setup, initializes colliders and scaling.
+            app.update();
+
+            let collider = app
+                .world_mut()
+                .query::<&Collider>()
+                .single(app.world())
+                .unwrap();
+            approx::assert_relative_eq!(collider.scale, Vect::splat(0.1), epsilon = 1.0e-5);
+
+            let mut context_query = app.world_mut().query::<RapierContext>();
+            let context = context_query.single(app.world()).unwrap();
+            let physics_ball_radius = context
+                .colliders
+                .colliders
+                .iter()
+                .next()
+                .unwrap()
+                .1
+                .shape()
+                .as_ball()
+                .unwrap()
+                .radius;
+            approx::assert_relative_eq!(physics_ball_radius, 0.1, epsilon = 0.1);
+        }
+
+        pub fn setup_physics(mut commands: Commands) {
+            commands.spawn((
+                Transform::from_translation(Vec3::new(-0.2, 0.0, 0.0)).with_scale(Vec3::splat(0.1)),
+                Collider::ball(1.0),
+            ));
+        }
+    }
+}
diff --git a/bindings/bevy_rapier/src/plugin/soft_body_tests.rs b/bindings/bevy_rapier/src/plugin/soft_body_tests.rs
new file mode 100644
index 000000000..da5b8d30f
--- /dev/null
+++ b/bindings/bevy_rapier/src/plugin/soft_body_tests.rs
@@ -0,0 +1,1607 @@
+//! Tests of the soft-body integration.
+
+use bevy::ecs::system::RunSystemOnce;
+use bevy::prelude::*;
+use bevy::time::{TimePlugin, TimeUpdateStrategy};
+
+use crate::math::Real;
+use crate::plugin::context::DefaultRapierContext;
+use crate::prelude::*;
+
+/// An app running the physics at a fixed 60Hz timestep.
+fn test_app() -> App {
+    test_app_with(|_| {})
+}
+
+/// Same as [`test_app`], calling `setup` before finishing the app.
+fn test_app_with(setup: impl FnOnce(&mut App)) -> App {
+    let mut app = App::new();
+    setup(&mut app);
+    app.add_plugins((
+        TransformPlugin,
+        TimePlugin,
+        RapierPhysicsPlugin::<NoUserData>::default(),
+    ));
+    app.insert_resource(TimestepMode::Fixed {
+        dt: 1.0 / 60.0,
+        substeps: 1,
+    });
+    app.insert_resource(TimeUpdateStrategy::ManualDuration(
+        std::time::Duration::from_secs_f32(1.0 / 60.0),
+    ));
+    app.finish();
+    // Create the default context.
+    app.update();
+    app
+}
+
+fn run(app: &mut App, frames: usize) {
+    for _ in 0..frames {
+        app.update();
+    }
+}
+
+fn context_entity(app: &mut App) -> Entity {
+    app.world_mut()
+        .query_filtered::<Entity, With<DefaultRapierContext>>()
+        .single(app.world())
+        .unwrap()
+}
+
+fn rigid_body_set(app: &mut App) -> &RapierRigidBodySet {
+    let context = context_entity(app);
+    app.world().get::<RapierRigidBodySet>(context).unwrap()
+}
+
+fn colliders(app: &mut App) -> &RapierContextColliders {
+    let context = context_entity(app);
+    app.world().get::<RapierContextColliders>(context).unwrap()
+}
+
+#[cfg(feature = "dim3")]
+fn v(x: Real, y: Real) -> Vect {
+    Vect::new(x, y, 0.0)
+}
+#[cfg(feature = "dim2")]
+fn v(x: Real, y: Real) -> Vect {
+    Vect::new(x, y)
+}
+
+#[cfg(feature = "dim3")]
+fn ground() -> Collider {
+    Collider::cuboid(10.0, 0.5, 10.0)
+}
+#[cfg(feature = "dim2")]
+fn ground() -> Collider {
+    Collider::cuboid(10.0, 0.5)
+}
+
+/// A small volumetric soft body centered at the entity's origin.
+#[cfg(feature = "dim3")]
+fn soft_box() -> SoftBody {
+    SoftBody::cuboid(Vect::splat(0.5), 3, 3, 3)
+}
+#[cfg(feature = "dim2")]
+fn soft_box() -> SoftBody {
+    SoftBody::grid(Vect::splat(0.5), 4, 4)
+}
+
+#[derive(Resource)]
+struct Received<M: Message> {
+    messages: Vec<M>,
+}
+
+impl<M: Message> Default for Received<M> {
+    fn default() -> Self {
+        Self { messages: vec![] }
+    }
+}
+
+fn collect<M: Message + Clone>(app: &mut App) {
+    app.init_resource::<Received<M>>().add_systems(
+        PostUpdate,
+        (|mut reader: MessageReader<M>, mut received: ResMut<Received<M>>| {
+            received.messages.extend(reader.read().cloned());
+        })
+        .after(PhysicsSet::Writeback),
+    );
+}
+
+/// Tears the soft body of `body` along its edge `edge` from a system.
+fn tear(app: &mut App, body: Entity, edge: u32) -> SoftBodyTearResult {
+    app.world_mut()
+        .run_system_once(
+            move |mut context: WriteRapierContext, mut commands: Commands| {
+                context
+                    .single_mut()
+                    .unwrap()
+                    .tear_soft_body(&mut commands, body, &[edge], &[])
+            },
+        )
+        .unwrap()
+        .expect("the soft body tore")
+}
+
+/// A rope of 9 particles along `x`, pinned at its first particle.
+fn pinned_rope() -> SoftBody {
+    SoftBody::rope(v(0.0, 0.0), v(4.0, 0.0), 9).map(|b| b.pinned_particles([0]).can_sleep(false))
+}
+
+#[test]
+fn soft_body_falls_and_rests_on_ground() {
+    let mut app = test_app();
+    app.world_mut()
+        .spawn((Transform::from_xyz(0.0, -0.5, 0.0), ground()));
+    let body = app
+        .world_mut()
+        .spawn((Transform::from_xyz(0.0, 3.0, 0.0), soft_box()))
+        .id();
+    app.update();
+
+    // The particles were placed by the entity's transform.
+    let com = rigid_body_set(&mut app)
+        .soft_body_center_of_mass(body)
+        .unwrap();
+    assert!((com.y - 3.0).abs() < 0.1, "{com}");
+    assert!(app.world().get::<RapierSoftBodyHandle>(body).is_some());
+
+    run(&mut app, 30);
+    let state = *app.world().get::<SoftBodyState>(body).unwrap();
+    assert!(state.center_of_mass.y < 2.9, "{state:?}");
+
+    run(&mut app, 300);
+    let state = *app.world().get::<SoftBodyState>(body).unwrap();
+    // Resting on the ground (its top is at `y = 0`): half-height 0.5, plus the contact skin.
+    assert!(
+        state.center_of_mass.y > 0.3 && state.center_of_mass.y < 1.0,
+        "{state:?}"
+    );
+    let set = rigid_body_set(&mut app);
+    let max_speed = set
+        .soft_body_particle_velocities(body)
+        .unwrap()
+        .map(|vel| vel.length())
+        .fold(0.0, Real::max);
+    assert!(max_speed < 0.1, "{max_speed}");
+
+    // The entity's transform follows the whole-body proxy, centered on the free particles.
+    let proxy = set.soft_body_whole_proxy(body).unwrap();
+    let expected = crate::utils::iso_to_transform(set.bodies[proxy].position());
+    let transform = *app.world().get::<Transform>(body).unwrap();
+    assert!((transform.translation.x - state.center_of_mass.x).abs() < 1.0e-5);
+    assert!((transform.translation.y - state.center_of_mass.y).abs() < 1.0e-5);
+    assert!((transform.translation - expected.translation).length() < 1.0e-5);
+    assert!(transform.rotation.angle_between(expected.rotation) < 1.0e-5);
+}
+
+#[test]
+fn soft_body_children_follow_the_whole_body_frame() {
+    let mut app = test_app();
+    let mut child = Entity::PLACEHOLDER;
+    let body = app
+        .world_mut()
+        .spawn((
+            Transform::from_xyz(0.0, 3.0, 0.0),
+            soft_box().map(|b| b.can_sleep(false).gravity_scale(0.0)),
+        ))
+        .with_children(|builder| {
+            child = builder
+                .spawn((Transform::from_xyz(1.0, 0.0, 0.0), Collider::ball(0.2)))
+                .id();
+        })
+        .id();
+    app.update();
+
+    // Spin the soft body around `z` while moving it (Rapier keeps the pose of a 2D proxy
+    // rotating in place counterclockwise).
+    let impulses = {
+        let sb = rigid_body_set(&mut app).soft_body(body).unwrap();
+        let center = sb.center_of_mass();
+        sb.particles()
+            .iter()
+            .enumerate()
+            .map(|(i, p)| {
+                let r = p.position() - center;
+                (i as u32, v(-r.y, r.x) * 2.0 * p.mass())
+            })
+            .collect()
+    };
+    app.world_mut()
+        .entity_mut(body)
+        .insert(SoftBodyExternalImpulse {
+            velocity_change: v(0.5, 0.0),
+            particle_impulses: impulses,
+        });
+    run(&mut app, 20);
+
+    let transform = *app.world().get::<Transform>(body).unwrap();
+    let (_, angle) = transform.rotation.to_axis_angle();
+    assert!(angle > 0.2, "{angle}");
+    // The child entity is where its collider is attached on the whole-body proxy.
+    let handle = app.world().get::<RapierColliderHandle>(child).unwrap().0;
+    let attachment = {
+        let set = rigid_body_set(&mut app);
+        let proxy = set.soft_body_whole_proxy(body).unwrap();
+        let proxy_pose = *set.bodies[proxy].position();
+        let co = &colliders(&mut app).colliders[handle];
+        assert_eq!(co.parent(), Some(proxy));
+        proxy_pose * co.position_wrt_parent().copied().unwrap()
+    };
+    let collider_pose = crate::utils::iso_to_transform(&attachment);
+    let child_pose = app
+        .world()
+        .get::<GlobalTransform>(child)
+        .unwrap()
+        .compute_transform();
+    #[cfg(feature = "dim2")]
+    let child_translation = child_pose.translation.truncate().extend(0.0);
+    #[cfg(feature = "dim3")]
+    let child_translation = child_pose.translation;
+    assert!(
+        (child_translation - collider_pose.translation).length() < 1.0e-3,
+        "{child_translation} != {}",
+        collider_pose.translation
+    );
+    assert!(child_pose.rotation.angle_between(collider_pose.rotation) < 1.0e-3);
+}
+
+#[test]
+fn soft_body_collides_as_its_entity() {
+    let mut app = test_app();
+    collect::<CollisionEvent>(&mut app);
+    let ground = app
+        .world_mut()
+        .spawn((Transform::from_xyz(0.0, -0.5, 0.0), ground()))
+        .id();
+    let body = app
+        .world_mut()
+        .spawn((
+            Transform::from_xyz(0.0, 1.0, 0.0),
+            soft_box(),
+            ActiveEvents::COLLISION_EVENTS,
+        ))
+        .id();
+    run(&mut app, 120);
+
+    let events = &app.world().resource::<Received<CollisionEvent>>().messages;
+    assert!(events.iter().any(|event| matches!(
+        event,
+        CollisionEvent::Started(a, b, _) if (*a, *b) == (body, ground) || (*a, *b) == (ground, body)
+    )));
+    // The soft body entity maps to its surface collider.
+    let collider = colliders(&mut app).entity2collider()[&body];
+    assert_eq!(colliders(&mut app).collider_entity(collider), Some(body));
+}
+
+#[test]
+fn despawn_removes_soft_body() {
+    let mut app = test_app();
+    let body = app
+        .world_mut()
+        .spawn((Transform::from_xyz(0.0, 3.0, 0.0), soft_box()))
+        .id();
+    let other = app
+        .world_mut()
+        .spawn((Transform::from_xyz(5.0, 3.0, 0.0), soft_box()))
+        .id();
+    run(&mut app, 5);
+    assert_eq!(rigid_body_set(&mut app).soft_bodies.len(), 2);
+    assert!(!colliders(&mut app).colliders.is_empty());
+
+    app.world_mut().despawn(body);
+    run(&mut app, 2);
+    let set = rigid_body_set(&mut app);
+    assert_eq!(set.soft_bodies.len(), 1);
+    assert!(set.soft_body(body).is_none());
+    assert!(!set.entity2soft_body().contains_key(&body));
+    assert!(!colliders(&mut app).entity2collider().contains_key(&body));
+
+    // Removing the component also removes the soft body.
+    app.world_mut().entity_mut(other).remove::<SoftBody>();
+    run(&mut app, 2);
+    let set = rigid_body_set(&mut app);
+    assert!(set.soft_bodies.is_empty());
+    assert!(set.bodies.is_empty(), "the proxies weren't removed");
+    assert!(colliders(&mut app).colliders.is_empty());
+    assert!(app.world().get::<RapierSoftBodyHandle>(other).is_none());
+}
+
+#[test]
+fn pinned_particles_stay_put() {
+    let mut app = test_app();
+    let body = app
+        .world_mut()
+        .spawn((Transform::from_xyz(0.0, 3.0, 0.0), pinned_rope()))
+        .id();
+    run(&mut app, 60);
+    let sb = rigid_body_set(&mut app).soft_body(body).unwrap();
+    assert!((sb.particle_position(0) - v(0.0, 3.0)).length() < 1.0e-5);
+    assert!(sb.particle_position(8).y < 2.0);
+
+    // Pin the last particle too, then move it with a kinematic target.
+    app.world_mut()
+        .entity_mut(body)
+        .insert(SoftBodyPinnedParticles(vec![0, 8]));
+    app.update();
+    let held = rigid_body_set(&mut app)
+        .soft_body(body)
+        .unwrap()
+        .particle_position(8);
+    run(&mut app, 30);
+    let sb = rigid_body_set(&mut app).soft_body(body).unwrap();
+    assert!(sb.particles()[8].is_pinned());
+    assert!((sb.particle_position(8) - held).length() < 1.0e-5);
+
+    let target = v(4.0, 3.0);
+    app.world_mut()
+        .entity_mut(body)
+        .insert(SoftBodyKinematicTargets(vec![(8, target)]));
+    run(&mut app, 3);
+    let sb = rigid_body_set(&mut app).soft_body(body).unwrap();
+    assert!((sb.particle_position(8) - target).length() < 1.0e-4);
+
+    // Removing the component restores the builder's pinned particles.
+    app.world_mut()
+        .entity_mut(body)
+        .remove::<SoftBodyPinnedParticles>();
+    run(&mut app, 30);
+    let sb = rigid_body_set(&mut app).soft_body(body).unwrap();
+    assert!(sb.particles()[0].is_pinned());
+    assert!(!sb.particles()[8].is_pinned());
+    assert!(sb.particle_position(8).y < 2.9);
+}
+
+#[test]
+fn soft_body_components_are_applied_and_reset() {
+    let mut app = test_app();
+    let body = app
+        .world_mut()
+        .spawn((
+            Transform::from_xyz(0.0, 3.0, 0.0),
+            soft_box(),
+            SoftBodyMaterial::default(),
+        ))
+        .id();
+    run(&mut app, 2);
+
+    let mut material = SoftBodyMaterial::uniform(12.0, 0.5);
+    material.tear_strain = Some(0.5);
+    app.world_mut().entity_mut(body).insert(material);
+    app.world_mut()
+        .entity_mut(body)
+        .insert((SoftBodyVolumeFactor(1.5), SoftBodyDisabled));
+    app.update();
+    let sb = rigid_body_set(&mut app).soft_body(body).unwrap();
+    assert_eq!(*sb.material(), material.0);
+    assert_eq!(sb.volume_factor(), 1.5);
+    assert!(!sb.is_enabled());
+    assert!(!app.world().get::<SoftBodyState>(body).unwrap().is_enabled);
+
+    app.world_mut()
+        .entity_mut(body)
+        .remove::<(SoftBodyMaterial, SoftBodyVolumeFactor, SoftBodyDisabled)>();
+    app.update();
+    let sb = rigid_body_set(&mut app).soft_body(body).unwrap();
+    assert_eq!(*sb.material(), soft_box().builder.material);
+    assert_eq!(sb.volume_factor(), 1.0);
+    assert!(sb.is_enabled());
+
+    // Impulses are applied once, then reset.
+    app.world_mut()
+        .entity_mut(body)
+        .insert(SoftBodyExternalImpulse {
+            velocity_change: v(3.0, 0.0),
+            particle_impulses: vec![],
+        });
+    app.update();
+    assert_eq!(
+        *app.world().get::<SoftBodyExternalImpulse>(body).unwrap(),
+        SoftBodyExternalImpulse::default()
+    );
+    let vel = rigid_body_set(&mut app)
+        .soft_body_particle_velocities(body)
+        .unwrap()
+        .next()
+        .unwrap();
+    assert!(vel.x > 2.0, "{vel}");
+}
+
+#[test]
+fn soft_body_collider_components_are_applied_and_reset() {
+    let mut app = test_app();
+    let body = app
+        .world_mut()
+        .spawn((
+            Transform::from_xyz(0.0, 3.0, 0.0),
+            soft_box(),
+            Friction::coefficient(0.3),
+        ))
+        .id();
+    app.update();
+
+    // The friction, sensor flag, contact skin and collision groups of the surface colliders.
+    let surface = |app: &mut App| {
+        let context = context_entity(app);
+        let world = app.world();
+        let set = world.get::<RapierRigidBodySet>(context).unwrap();
+        let colliders = &world
+            .get::<RapierContextColliders>(context)
+            .unwrap()
+            .colliders;
+        let handles = set.soft_body_colliders(colliders, body).unwrap();
+        assert!(!handles.is_empty());
+        let radius = set.soft_body(body).unwrap().particle_radius();
+        let states: Vec<_> = handles
+            .iter()
+            .map(|h| {
+                let co = &colliders[*h];
+                (
+                    co.friction(),
+                    co.is_sensor(),
+                    co.contact_skin(),
+                    co.collision_groups(),
+                )
+            })
+            .collect();
+        (states, radius)
+    };
+    let (states, _) = surface(&mut app);
+    assert!(states.iter().all(|s| s.0 == 0.3), "{states:?}");
+
+    let groups = CollisionGroups::new(Group::GROUP_2, Group::GROUP_3);
+    app.world_mut().entity_mut(body).insert((
+        Friction::coefficient(0.9),
+        Sensor,
+        ContactSkin(0.05),
+        groups,
+    ));
+    app.update();
+    let (states, _) = surface(&mut app);
+    for state in &states {
+        assert_eq!(state.0, 0.9);
+        assert!(state.1);
+        assert_eq!(state.2, 0.05);
+        assert_eq!(state.3, groups.into());
+    }
+
+    app.world_mut()
+        .entity_mut(body)
+        .remove::<(Friction, Sensor, ContactSkin, CollisionGroups)>();
+    app.update();
+    let (states, radius) = surface(&mut app);
+    let defaults = rapier::geometry::ColliderBuilder::default();
+    for state in &states {
+        assert_eq!(state.0, defaults.friction);
+        assert!(!state.1);
+        assert_eq!(state.2, radius);
+        assert_eq!(state.3, defaults.collision_groups);
+    }
+}
+
+#[test]
+fn non_finite_soft_body_is_quarantined() {
+    let mut app = test_app();
+    collect::<PhysicsQuarantineEvent>(&mut app);
+    let body = app
+        .world_mut()
+        .spawn((Transform::from_xyz(0.0, 3.0, 0.0), soft_box()))
+        .id();
+    run(&mut app, 2);
+
+    app.world_mut()
+        .entity_mut(body)
+        .insert(SoftBodyExternalImpulse {
+            velocity_change: Vect::splat(Real::NAN),
+            particle_impulses: vec![],
+        });
+    run(&mut app, 2);
+
+    let context = context_entity(&mut app);
+    let events = &app
+        .world()
+        .resource::<Received<PhysicsQuarantineEvent>>()
+        .messages;
+    assert_eq!(
+        events,
+        &[PhysicsQuarantineEvent {
+            context,
+            bodies: vec![],
+            colliders: vec![],
+            soft_bodies: vec![body],
+        }]
+    );
+    assert!(app.world().get::<SoftBodyDisabled>(body).is_some());
+    assert!(!rigid_body_set(&mut app)
+        .soft_body(body)
+        .unwrap()
+        .is_enabled());
+
+    // Fix the particles, then remove the component to release the soft body.
+    app.world_mut()
+        .run_system_once(move |mut context: WriteRapierContext| {
+            let mut context = context.single_mut().unwrap();
+            let sb = context.soft_body_mut(body).unwrap();
+            for i in 0..sb.num_particles() {
+                let rest = sb.particles()[i].rest_position();
+                sb.set_particle_position(i, rest + v(0.0, 3.0));
+            }
+        })
+        .unwrap();
+    app.world_mut()
+        .entity_mut(body)
+        .remove::<SoftBodyDisabled>();
+    run(&mut app, 2);
+    let sb = rigid_body_set(&mut app).soft_body(body).unwrap();
+    assert!(sb.is_enabled());
+    assert!(sb.particle_positions().all(|p| p.is_finite()));
+}
+
+#[test]
+fn particle_attachment_holds_the_soft_body() {
+    let mut app = test_app();
+    let anchor = app
+        .world_mut()
+        .spawn((Transform::from_xyz(0.0, 3.0, 0.0), RigidBody::Fixed))
+        .id();
+    let body = app
+        .world_mut()
+        .spawn((
+            Transform::from_xyz(0.0, 3.0, 0.0),
+            SoftBody::rope(v(0.0, 0.0), v(2.0, 0.0), 5).map(|b| b.can_sleep(false)),
+            SoftBodyAttachments(vec![SoftBodyAttachment {
+                particle: 0,
+                body: anchor,
+            }]),
+        ))
+        .id();
+    run(&mut app, 120);
+    let sb = rigid_body_set(&mut app).soft_body(body).unwrap();
+    assert_eq!(sb.particle_attachments().len(), 1);
+    assert!((sb.particle_position(0) - v(0.0, 3.0)).length() < 0.1);
+
+    app.world_mut()
+        .entity_mut(body)
+        .remove::<SoftBodyAttachments>();
+    run(&mut app, 60);
+    let sb = rigid_body_set(&mut app).soft_body(body).unwrap();
+    assert!(sb.particle_attachments().is_empty());
+    assert!(sb.particle_position(0).y < 2.0);
+}
+
+#[test]
+fn tear_spawns_piece_entities_and_sends_messages() {
+    let mut app = test_app();
+    collect::<SoftBodyTearEvent>(&mut app);
+    let body = app
+        .world_mut()
+        .spawn((
+            Transform::from_xyz(0.0, 3.0, 0.0),
+            pinned_rope(),
+            Name::new("rope"),
+        ))
+        .id();
+    app.update();
+
+    let context = context_entity(&mut app);
+    let torn = {
+        let sb = rigid_body_set(&mut app).soft_body(body).unwrap();
+        sb.edges()
+            .iter()
+            .position(|e| e.vertices == [4, 5] && e.kind == SoftBodyEdgeKind::Structural)
+            .unwrap() as u32
+    };
+    let result = tear(&mut app, body, torn);
+    assert_eq!(result.raw.pieces.len(), 2);
+    assert_eq!(result.pieces.len(), 2);
+    assert_eq!(result.pieces[0], body);
+    // The piece's entity is known and mapped right away.
+    let set = rigid_body_set(&mut app);
+    let piece_handle = set.entity2soft_body()[&result.pieces[1]];
+    assert_eq!(piece_handle, result.raw.pieces[1].soft_body);
+    assert_eq!(set.soft_body_entity(piece_handle), Some(result.pieces[1]));
+    run(&mut app, 60);
+
+    let events = &app
+        .world()
+        .resource::<Received<SoftBodyTearEvent>>()
+        .messages;
+    assert_eq!(events.len(), 1);
+    let event = &events[0];
+    assert_eq!(event.soft_body, body);
+    assert_eq!(event.context, context);
+    assert_eq!(event.pieces.len(), 2);
+    assert_eq!(event.pieces[0].soft_body, body);
+    let piece = event.pieces[1].soft_body;
+    assert_ne!(piece, body);
+    assert_eq!(piece, result.pieces[1]);
+
+    // The piece entity is a soft body entity, cloned from the torn one.
+    let world = app.world();
+    assert!(world.get::<RapierSoftBodyHandle>(piece).is_some());
+    assert!(world.get::<SoftBody>(piece).is_some());
+    assert_eq!(world.get::<Name>(piece).unwrap().as_str(), "rope");
+    assert_eq!(
+        world.get::<RapierContextEntityLink>(piece),
+        Some(&RapierContextEntityLink(context))
+    );
+    let piece_state = *world.get::<SoftBodyState>(piece).unwrap();
+    let body_state = *world.get::<SoftBodyState>(body).unwrap();
+    assert_eq!(piece_state.num_particles, 5);
+    // The loose piece fell away from the pinned one.
+    assert!(piece_state.center_of_mass.y < body_state.center_of_mass.y - 1.0);
+
+    let set = rigid_body_set(&mut app);
+    assert_eq!(set.soft_bodies.len(), 2);
+    let handle = set.entity2soft_body()[&piece];
+    assert_eq!(set.soft_body_entity(handle), Some(piece));
+    let proxy = set.soft_bodies[handle].root_body();
+    assert_eq!(set.rigid_body_entity(proxy), Some(piece));
+
+    // Despawning the piece removes it.
+    app.world_mut().despawn(piece);
+    app.update();
+    assert_eq!(rigid_body_set(&mut app).soft_bodies.len(), 1);
+}
+
+#[test]
+fn tear_by_force_during_the_step_sends_messages() {
+    let mut app = test_app();
+    collect::<SoftBodyTearEvent>(&mut app);
+    // A vertical rope whose middle edge bears three particles, past its tear force.
+    let positions = (0..7).map(|i| v(0.0, 3.0 - i as Real)).collect();
+    let edges = (0..6).map(|i| [i, i + 1]).collect();
+    let builder = SoftBodyBuilder::new(positions)
+        .edges(edges)
+        .pinned_particles([0])
+        .particle_mass(1.0)
+        .softness(rapier::dynamics::SpringCoefficients::new(120.0, 1.0))
+        .no_surface_collider()
+        .can_sleep(false)
+        .edge_tear_resistance([(0, 4.0), (1, 4.0), (2, 4.0)])
+        .tear_force(24.0);
+    let body = app
+        .world_mut()
+        .spawn((Transform::default(), SoftBody::new(builder)))
+        .id();
+    run(&mut app, 60);
+
+    let events = &app
+        .world()
+        .resource::<Received<SoftBodyTearEvent>>()
+        .messages;
+    assert_eq!(events.len(), 1, "{events:?}");
+    assert_eq!(events[0].soft_body, body);
+    assert_eq!(events[0].raw.torn_edges, vec![[3, 4]]);
+    let piece = events[0].pieces[1].soft_body;
+    assert!(app.world().get::<RapierSoftBodyHandle>(piece).is_some());
+    assert_eq!(rigid_body_set(&mut app).soft_bodies.len(), 2);
+}
+
+#[test]
+fn cluster_entity_gets_a_rigid_body_and_joints() {
+    let mut app = test_app();
+    let anchor = app
+        .world_mut()
+        .spawn((Transform::from_xyz(0.0, 3.0, 0.0), RigidBody::Fixed))
+        .id();
+    let body = app
+        .world_mut()
+        .spawn((
+            Transform::from_xyz(0.0, 3.0, 0.0),
+            soft_box().map(|b| b.can_sleep(false)),
+        ))
+        .id();
+    let num_particles = soft_box().builder.positions.len() as u32;
+    #[cfg(feature = "dim3")]
+    let joint = SphericalJointBuilder::new();
+    #[cfg(feature = "dim2")]
+    let joint = RevoluteJointBuilder::new();
+    let cluster = app
+        .world_mut()
+        .spawn((
+            Transform::default(),
+            SoftBodyCluster::new(body, 0..num_particles),
+            ImpulseJoint::new(anchor, joint),
+        ))
+        .id();
+    run(&mut app, 2);
+
+    let handle = app
+        .world()
+        .get::<RapierRigidBodyHandle>(cluster)
+        .expect("the cluster has no rigid-body")
+        .0;
+    assert!(app
+        .world()
+        .get::<RapierImpulseJointHandle>(cluster)
+        .is_some());
+    let set = rigid_body_set(&mut app);
+    assert!(set.bodies[handle].is_soft_frame());
+    assert_eq!(set.entity2body()[&cluster], handle);
+    assert_eq!(set.rigid_body_entity(handle), Some(cluster));
+    // The soft body entity is mapped to its whole-body proxy.
+    let whole = set.soft_body(body).unwrap().root_body();
+    assert_eq!(set.entity2body()[&body], whole);
+    assert_eq!(set.soft_body_whole_proxy(body), Some(whole));
+    assert_eq!(
+        set.soft_body_cluster_index(body),
+        Some((set.entity2soft_body()[&body], 0))
+    );
+    let cluster_index = set.soft_body_cluster_index(cluster).unwrap();
+    assert_eq!(
+        set.soft_bodies[cluster_index.0].cluster_proxy(cluster_index.1),
+        Some(handle)
+    );
+    #[cfg(feature = "to-bevy-mesh")]
+    assert!(app.world().get::<Visibility>(cluster).is_some());
+
+    // The joint holds the soft body where it would otherwise have fallen.
+    run(&mut app, 120);
+    let com = rigid_body_set(&mut app)
+        .soft_body_center_of_mass(body)
+        .unwrap();
+    assert!((com - v(0.0, 3.0)).length() < 0.5, "{com}");
+    // The cluster's pose is written back to its transform.
+    let transform = *app.world().get::<Transform>(cluster).unwrap();
+    assert!((transform.translation.y - 3.0).abs() < 0.5, "{transform:?}");
+
+    // Despawning the cluster removes its proxy and the joint.
+    app.world_mut().despawn(cluster);
+    run(&mut app, 120);
+    let set = rigid_body_set(&mut app);
+    assert!(!set.bodies.contains(handle));
+    assert!(set.soft_body_center_of_mass(body).unwrap().y < 0.0);
+}
+
+#[test]
+fn deformable_collider_follows_its_soft_body() {
+    #[cfg(feature = "dim2")]
+    use rapier::parry::shape::PolylineFlags;
+    #[cfg(feature = "dim3")]
+    use rapier::parry::shape::TriMeshFlags;
+
+    let mut app = test_app();
+    let body = app
+        .world_mut()
+        .spawn((
+            Transform::from_xyz(0.0, 3.0, 0.0),
+            soft_box().map(|b| b.no_surface_collider()),
+        ))
+        .id();
+    app.update();
+    // A collision mesh made of the soft body's surface.
+    let (vertices, surface) = {
+        let sb = rigid_body_set(&mut app).soft_body(body).unwrap();
+        (
+            sb.particle_positions().collect::<Vec<_>>(),
+            sb.boundary().to_vec(),
+        )
+    };
+    #[cfg(feature = "dim3")]
+    let collider =
+        Collider::trimesh_with_flags(vertices, surface, TriMeshFlags::DEFORMABLE).unwrap();
+    #[cfg(feature = "dim2")]
+    let collider =
+        Collider::polyline_with_flags(vertices, Some(surface), PolylineFlags::DEFORMABLE);
+    let deformable = app
+        .world_mut()
+        .spawn((
+            Transform::default(),
+            collider,
+            DeformableCollider::new(body, SoftMeshBinding::direct_by_position(1.0e-3)),
+        ))
+        .id();
+    app.update();
+    assert!(app
+        .world()
+        .get::<DeformableColliderError>(deformable)
+        .is_none());
+    let handle = app
+        .world()
+        .get::<RapierColliderHandle>(deformable)
+        .expect("the deformable collider wasn't created")
+        .0;
+    let y0 = colliders(&mut app).colliders[handle].compute_aabb().mins.y;
+    run(&mut app, 30);
+    let co = &colliders(&mut app).colliders[handle];
+    assert!(co.deformable_mesh_ref().is_some());
+    assert!(co.compute_aabb().mins.y < y0 - 0.5);
+    assert_eq!(
+        colliders(&mut app).collider_entity(handle),
+        Some(deformable)
+    );
+}
+
+#[cfg(feature = "to-bevy-mesh")]
+#[test]
+fn mesh_sync_updates_vertex_positions() {
+    #[cfg(feature = "dim2")]
+    use bevy::mesh::Mesh2d as MeshComponent;
+    #[cfg(feature = "dim3")]
+    use bevy::mesh::Mesh3d as MeshComponent;
+    use bevy::mesh::{Mesh, VertexAttributeValues};
+
+    let mut app = test_app_with(|app| {
+        app.add_plugins(AssetPlugin::default()).init_asset::<Mesh>();
+    });
+    let body = app
+        .world_mut()
+        .spawn((
+            Transform::from_xyz(1.0, 3.0, 0.0),
+            soft_box(),
+            SoftBodyMeshSync::default(),
+        ))
+        .id();
+
+    let check = |app: &mut App| {
+        let context = context_entity(app);
+        let mesh_handle = app.world().get::<MeshComponent>(body).unwrap().0.clone();
+        let transform = *app.world().get::<Transform>(body).unwrap();
+        let meshes = app.world().resource::<Assets<Mesh>>();
+        let mesh = meshes.get(&mesh_handle).unwrap();
+        let Some(VertexAttributeValues::Float32x3(positions)) =
+            mesh.attribute(Mesh::ATTRIBUTE_POSITION)
+        else {
+            panic!("no positions");
+        };
+        let set = app.world().get::<RapierRigidBodySet>(context).unwrap();
+        let particles: Vec<Vect> = set.soft_body_particle_positions(body).unwrap().collect();
+        assert_eq!(positions.len(), particles.len());
+        for (p, particle) in positions.iter().zip(particles.iter()) {
+            let world = transform.transform_point(Vec3::from_array(*p));
+            #[cfg(feature = "dim2")]
+            let world = world.truncate();
+            assert!(
+                (world - *particle).length() < 1.0e-4,
+                "{world} != {particle}"
+            );
+        }
+        #[cfg(feature = "dim3")]
+        assert!(mesh.attribute(Mesh::ATTRIBUTE_NORMAL).is_some());
+    };
+
+    run(&mut app, 2);
+    check(&mut app);
+    run(&mut app, 30);
+    check(&mut app);
+    assert!(
+        app.world()
+            .get::<SoftBodyState>(body)
+            .unwrap()
+            .center_of_mass
+            .y
+            < 2.9
+    );
+}
+
+#[cfg(all(feature = "to-bevy-mesh", feature = "dim3"))]
+#[test]
+fn mesh_sync_ignores_deformable_colliders() {
+    use bevy::mesh::{Mesh, Mesh3d};
+    use rapier::parry::shape::TriMeshFlags;
+
+    let mut app = test_app_with(|app| {
+        app.add_plugins(AssetPlugin::default()).init_asset::<Mesh>();
+    });
+    let body = app
+        .world_mut()
+        .spawn((
+            Transform::from_xyz(0.0, 3.0, 0.0),
+            soft_box().map(|b| b.gravity_scale(0.0)),
+        ))
+        .id();
+    app.update();
+    // A deformable collider made of two triangles of the soft body's surface.
+    let (vertices, boundary) = {
+        let sb = rigid_body_set(&mut app).soft_body(body).unwrap();
+        (
+            sb.particle_positions().collect::<Vec<_>>(),
+            sb.boundary().to_vec(),
+        )
+    };
+    let collider =
+        Collider::trimesh_with_flags(vertices, boundary[..2].to_vec(), TriMeshFlags::DEFORMABLE)
+            .unwrap();
+    app.world_mut().spawn((
+        Transform::default(),
+        collider,
+        DeformableCollider::new(body, SoftMeshBinding::direct_by_position(1.0e-3)),
+    ));
+    app.update();
+    app.world_mut()
+        .entity_mut(body)
+        .insert(SoftBodyMeshSync::default());
+    run(&mut app, 2);
+
+    let mesh_handle = app.world().get::<Mesh3d>(body).unwrap().0.clone();
+    let mesh = app
+        .world()
+        .resource::<Assets<Mesh>>()
+        .get(&mesh_handle)
+        .unwrap();
+    assert_eq!(mesh.indices().unwrap().len(), boundary.len() * 3);
+}
+
+#[test]
+fn soft_contacts_and_hook_views_are_exposed() {
+    let mut app = test_app();
+    let a = app
+        .world_mut()
+        .spawn((Transform::from_xyz(0.0, 0.5, 0.0), soft_box()))
+        .id();
+    let b = app
+        .world_mut()
+        .spawn((Transform::from_xyz(0.0, 2.5, 0.0), soft_box()))
+        .id();
+    app.world_mut()
+        .spawn((Transform::from_xyz(0.0, -0.5, 0.0), ground()));
+    run(&mut app, 120);
+
+    let context = context_entity(&mut app);
+    let world = app.world();
+    let simulation = world.get::<RapierContextSimulation>(context).unwrap();
+    let colliders = world.get::<RapierContextColliders>(context).unwrap();
+    let set = world.get::<RapierRigidBodySet>(context).unwrap();
+    let pair = simulation
+        .contact_pair(colliders, set, a, b)
+        .expect("the soft bodies don't touch");
+    assert!(pair.is_soft());
+    assert!(pair.soft_contacts().is_some());
+    assert!(matches!(pair.contacts(), PairContacts::Soft { .. }));
+    assert!(pair.soft_touching().is_some());
+}
+
+#[cfg(feature = "serde-serialize")]
+#[test]
+fn soft_body_settings_wrappers_serde_round_trip() {
+    use crate::reflect::{SoftBodiesSettingsWrapper, SoftRecoverySettingsWrapper};
+
+    let mut settings = SoftBodiesSettings {
+        max_extra_substeps: 7,
+        ..Default::default()
+    };
+    settings.recovery.recovery_pace = 0.25;
+    settings.recovery.overlap_patch_constraints = SoftPatchConstraints::StandDown;
+    let json = serde_json::to_string(&SoftBodiesSettingsWrapper(settings)).unwrap();
+    let back: SoftBodiesSettingsWrapper = serde_json::from_str(&json).unwrap();
+    assert_eq!(back.0, settings);
+
+    let json = serde_json::to_string(&SoftRecoverySettingsWrapper(settings.recovery)).unwrap();
+    let back: SoftRecoverySettingsWrapper = serde_json::from_str(&json).unwrap();
+    assert_eq!(back.0, settings.recovery);
+}
+
+#[test]
+fn soft_body_settings_are_reflected() {
+    use crate::reflect::IntegrationParametersWrapper;
+    use bevy::reflect::{GetPath, Reflect};
+
+    let mut params =
+        IntegrationParametersWrapper(rapier::dynamics::IntegrationParameters::default());
+    *params
+        .path_mut::<Real>("soft_bodies.recovery.recovery_pace")
+        .unwrap() = 0.125;
+    *params
+        .path_mut::<usize>("soft_bodies.max_extra_substeps")
+        .unwrap() = 2;
+    assert_eq!(params.0.soft_bodies.recovery.recovery_pace, 0.125);
+    assert_eq!(params.0.soft_bodies.max_extra_substeps, 2);
+    assert!(params.as_reflect().reflect_ref().as_struct().is_ok());
+
+    let mut material = SoftBodyMaterial::default();
+    *material.path_mut::<Real>("0.young_modulus").unwrap() = 5.0;
+    assert_eq!(material.young_modulus, 5.0);
+}
+
+#[test]
+fn contact_modification_hook_sees_soft_pairs() {
+    use bevy::ecs::system::SystemParam;
+    use std::sync::atomic::{AtomicUsize, Ordering};
+    use std::sync::Arc;
+
+    #[derive(Resource, Default)]
+    struct SoftCalls(Arc<AtomicUsize>);
+
+    #[derive(SystemParam)]
+    struct SoftHooks<'w> {
+        calls: Res<'w, SoftCalls>,
+    }
+
+    impl BevyPhysicsHooks for SoftHooks<'_> {
+        fn modify_solver_contacts(&self, mut context: ContactModificationContextView) {
+            if context.is_soft() {
+                assert!(context.soft().is_some());
+                assert!(context.manifold().is_none());
+                // Dropping every candidate lets the soft bodies pass through each other.
+                context.soft_mut().unwrap().disable_all();
+                self.calls.0.fetch_add(1, Ordering::SeqCst);
+            }
+        }
+    }
+
+    let mut app = App::new();
+    app.add_plugins((
+        TransformPlugin,
+        TimePlugin,
+        RapierPhysicsPlugin::<SoftHooks>::default(),
+    ))
+    .init_resource::<SoftCalls>()
+    .insert_resource(TimestepMode::Fixed {
+        dt: 1.0 / 60.0,
+        substeps: 1,
+    })
+    .insert_resource(TimeUpdateStrategy::ManualDuration(
+        std::time::Duration::from_secs_f32(1.0 / 60.0),
+    ));
+    app.finish();
+    app.update();
+    app.world_mut()
+        .spawn((Transform::from_xyz(0.0, -0.5, 0.0), ground()));
+    app.world_mut().spawn((
+        Transform::from_xyz(0.0, 0.5, 0.0),
+        soft_box(),
+        ActiveHooks::MODIFY_SOLVER_CONTACTS,
+    ));
+    let top = app
+        .world_mut()
+        .spawn((
+            Transform::from_xyz(0.0, 2.5, 0.0),
+            soft_box(),
+            ActiveHooks::MODIFY_SOLVER_CONTACTS,
+        ))
+        .id();
+    run(&mut app, 120);
+
+    assert!(app.world().resource::<SoftCalls>().0.load(Ordering::SeqCst) > 0);
+    // Without soft contacts, the top body sank into the bottom one.
+    let com = app
+        .world()
+        .get::<SoftBodyState>(top)
+        .unwrap()
+        .center_of_mass;
+    assert!(com.y < 1.5, "{com}");
+}
+
+#[test]
+fn tear_through_a_cluster_spawns_a_cluster_entity() {
+    let mut app = test_app();
+    collect::<SoftBodyTearEvent>(&mut app);
+    let body = app
+        .world_mut()
+        .spawn((Transform::from_xyz(0.0, 3.0, 0.0), pinned_rope()))
+        .id();
+    let cluster = app
+        .world_mut()
+        .spawn((Transform::default(), SoftBodyCluster::new(body, 0..9)))
+        .id();
+    run(&mut app, 2);
+
+    let torn = {
+        let sb = rigid_body_set(&mut app).soft_body(body).unwrap();
+        sb.edges()
+            .iter()
+            .position(|e| e.vertices == [4, 5] && e.kind == SoftBodyEdgeKind::Structural)
+            .unwrap() as u32
+    };
+    tear(&mut app, body, torn);
+    run(&mut app, 2);
+
+    let events = app
+        .world()
+        .resource::<Received<SoftBodyTearEvent>>()
+        .messages
+        .clone();
+    assert_eq!(events.len(), 1);
+    let splits = &events[0].cluster_splits;
+    assert!(!splits.is_empty(), "{events:?}");
+    // Cluster 0 is the whole-body cluster, cluster 1 the one of the cluster entity.
+    let fresh = splits
+        .iter()
+        .find(|split| split.source_cluster == 1 && !split.keeps_proxy)
+        .expect("no fresh proxy");
+    let fresh_entity = fresh.proxy.unwrap();
+    assert_ne!(fresh_entity, cluster);
+    let fresh_cluster = app.world().get::<SoftBodyCluster>(fresh_entity).unwrap();
+    assert_eq!(fresh_cluster.soft_body, fresh.soft_body);
+    let handle = app
+        .world()
+        .get::<RapierRigidBodyHandle>(fresh_entity)
+        .unwrap()
+        .0;
+    let set = rigid_body_set(&mut app);
+    assert_eq!(set.rigid_body_entity(handle), Some(fresh_entity));
+    assert!(set.bodies[handle].is_soft_frame());
+    // The fresh whole-body proxy of the new piece maps to the piece entity.
+    let whole = splits
+        .iter()
+        .find(|split| split.source_cluster == 0 && !split.keeps_proxy)
+        .unwrap();
+    assert_eq!(whole.proxy, Some(whole.soft_body));
+    assert_eq!(events[0].pieces[1].soft_body, whole.soft_body);
+    // The kept proxy still maps to the original cluster entity.
+    let kept = splits
+        .iter()
+        .find(|split| split.source_cluster == 1 && split.keeps_proxy)
+        .unwrap();
+    assert_eq!(kept.proxy, Some(cluster));
+    assert_eq!(
+        app.world()
+            .get::<SoftBodyCluster>(cluster)
+            .unwrap()
+            .soft_body,
+        kept.soft_body
+    );
+}
+
+#[test]
+fn split_clusters_inherit_the_cluster_components() {
+    let mut app = test_app();
+    collect::<SoftBodyTearEvent>(&mut app);
+    let body = app
+        .world_mut()
+        .spawn((Transform::from_xyz(0.0, 3.0, 0.0), pinned_rope()))
+        .id();
+    // The cluster holds the whole rope where it was created (its rest centroid is at `x = 2`).
+    let material = SoftBodyClusterMaterial {
+        tear_resistance: 2.0,
+        ..default()
+    };
+    let shape_matching = SoftBodyClusterShapeMatching {
+        target: Some(Transform::from_xyz(0.0, 3.0, 0.0)),
+    };
+    let target = SoftBodyClusterKinematicTarget(Transform::from_xyz(2.0, 3.0, 0.0));
+    let cluster = app
+        .world_mut()
+        .spawn((
+            Transform::default(),
+            SoftBodyCluster::new(body, 0..9),
+            target,
+            shape_matching,
+            material,
+        ))
+        .id();
+    run(&mut app, 5);
+    // An edge between two pinned particles can't tear: release the cluster first (its target is
+    // kept, but no longer applied).
+    app.world_mut()
+        .entity_mut(cluster)
+        .remove::<SoftBodyClusterPinned>();
+    app.update();
+
+    let torn = {
+        let sb = rigid_body_set(&mut app).soft_body(body).unwrap();
+        sb.edges()
+            .iter()
+            .position(|e| e.vertices == [4, 5] && e.kind == SoftBodyEdgeKind::Structural)
+            .unwrap() as u32
+    };
+    tear(&mut app, body, torn);
+    run(&mut app, 30);
+
+    let events = app
+        .world()
+        .resource::<Received<SoftBodyTearEvent>>()
+        .messages
+        .clone();
+    let fresh = events[0]
+        .cluster_splits
+        .iter()
+        .find(|split| split.source_cluster == 1 && !split.keeps_proxy)
+        .expect("no fresh cluster");
+    let fresh_entity = fresh.proxy.unwrap();
+    assert_ne!(fresh_entity, cluster);
+    let world = app.world();
+    assert!(world.get::<SoftBodyClusterPinned>(fresh_entity).is_some());
+    assert_eq!(
+        world.get::<SoftBodyClusterShapeMatching>(fresh_entity),
+        Some(&shape_matching)
+    );
+    assert_eq!(
+        world.get::<SoftBodyClusterMaterial>(fresh_entity),
+        Some(&material)
+    );
+    // The target of the fresh cluster was shifted to its own rest centroid.
+    let fresh_target = world
+        .get::<SoftBodyClusterKinematicTarget>(fresh_entity)
+        .unwrap();
+    assert!(fresh_target.0.translation.x > 2.5, "{fresh_target:?}");
+
+    // The inherited target places the particles of the fresh cluster where the original target
+    // placed them.
+    let set = rigid_body_set(&mut app);
+    let (handle, index) = set.soft_body_cluster_index(fresh_entity).unwrap();
+    let sb = &set.soft_bodies[handle];
+    let fresh_cluster = sb.cluster(index).unwrap();
+    assert!(fresh_cluster.shape_matching_enabled());
+    for &particle in fresh_cluster.particles() {
+        let p = &sb.particles()[particle as usize];
+        assert!(p.is_pinned());
+        // The rest positions are relative to the rest center of mass of the rope, at `(2, 3)`.
+        let expected = p.rest_position() + v(2.0, 3.0);
+        assert!(
+            (p.position() - expected).length() < 1.0e-3,
+            "{} != {expected}",
+            p.position(),
+        );
+    }
+}
+
+#[test]
+fn zero_dt_frame_does_not_disturb_a_welded_cluster() {
+    // Spawn everything before the first frame, whose delta time is zero.
+    let mut app = App::new();
+    app.add_plugins((
+        TransformPlugin,
+        TimePlugin,
+        RapierPhysicsPlugin::<NoUserData>::default(),
+    ));
+    app.insert_resource(TimestepMode::default());
+    app.insert_resource(TimeUpdateStrategy::ManualDuration(
+        std::time::Duration::from_secs_f32(1.0 / 60.0),
+    ));
+    app.finish();
+
+    app.world_mut()
+        .spawn((Transform::from_xyz(0.0, -0.5, 0.0), ground()));
+    #[cfg(feature = "dim3")]
+    let jelly = soft_box();
+    #[cfg(feature = "dim2")]
+    let jelly = SoftBody::grid(Vect::splat(0.6), 5, 5);
+    let jelly = jelly.map(|b| {
+        b.cell_model(SoftBodyCellModel::Corotational)
+            .particle_mass(0.08)
+            .particle_radius(0.05)
+            .can_sleep(false)
+    });
+    let top_y = jelly
+        .builder
+        .particle_positions()
+        .iter()
+        .map(|p| p.y)
+        .fold(Real::MIN, Real::max);
+    let top_edge: Vec<u32> = (0..jelly.builder.particle_positions().len() as u32)
+        .filter(|i| jelly.builder.particle_positions()[*i as usize].y > top_y - 1.0e-3)
+        .collect();
+    let body = app
+        .world_mut()
+        .spawn((Transform::from_xyz(0.0, 1.0, 0.0), jelly))
+        .id();
+    #[cfg(feature = "dim3")]
+    let plate_shape = Collider::cuboid(0.7, 0.06, 0.7);
+    #[cfg(feature = "dim2")]
+    let plate_shape = Collider::cuboid(0.7, 0.06);
+    let plate = app
+        .world_mut()
+        .spawn((
+            Transform::from_xyz(0.0, 1.0 + top_y + 0.2, 0.0),
+            RigidBody::Dynamic,
+            plate_shape,
+        ))
+        .id();
+    app.world_mut().spawn((
+        Transform::default(),
+        SoftBodyCluster::new(body, top_edge),
+        ImpulseJoint::new(plate, FixedJointBuilder::new().local_anchor1(v(0.0, -0.2))),
+    ));
+
+    // The first frame has a zero delta time: it must not inject any velocity (a zero-length step
+    // used to launch the plate and the jelly's particles).
+    let max_speeds = |app: &mut App| {
+        let set = rigid_body_set(app);
+        let particles = set
+            .soft_body_particle_velocities(body)
+            .unwrap()
+            .map(|v| v.length())
+            .fold(0.0, Real::max);
+        let plate = &set.bodies[set.entity2body()[&plate]];
+        (particles, plate.linvel().length())
+    };
+    run(&mut app, 1);
+    assert_eq!(max_speeds(&mut app), (0.0, 0.0));
+    run(&mut app, 1);
+    let (particles, plate_speed) = max_speeds(&mut app);
+    assert!(
+        particles < 0.5 && plate_speed < 0.5,
+        "{particles} {plate_speed}"
+    );
+
+    run(&mut app, 60);
+    let set = rigid_body_set(&mut app);
+    assert!(set
+        .soft_body_particle_positions(body)
+        .unwrap()
+        .all(|p| p.is_finite()));
+    assert!(set.bodies[set.entity2body()[&plate]]
+        .translation()
+        .is_finite());
+    let plate_transform = app.world().get::<Transform>(plate).unwrap();
+    assert!(plate_transform.translation.is_finite());
+}
+
+#[test]
+fn soft_body_entity_is_a_joint_target() {
+    let mut app = test_app();
+    let anchor = app
+        .world_mut()
+        .spawn((Transform::from_xyz(0.0, 3.0, 0.0), RigidBody::Fixed))
+        .id();
+    #[cfg(feature = "dim3")]
+    let joint = SphericalJointBuilder::new();
+    #[cfg(feature = "dim2")]
+    let joint = RevoluteJointBuilder::new();
+    // A joint on the soft body entity itself, and a ball hanging from the soft body entity.
+    let body = app
+        .world_mut()
+        .spawn((
+            Transform::from_xyz(0.0, 3.0, 0.0),
+            soft_box().map(|b| b.can_sleep(false)),
+            ImpulseJoint::new(anchor, joint),
+        ))
+        .id();
+    let ball = app
+        .world_mut()
+        .spawn((
+            Transform::from_xyz(0.0, 1.5, 0.0),
+            RigidBody::Dynamic,
+            Collider::ball(0.2),
+            ImpulseJoint::new(body, RopeJointBuilder::new(1.5)),
+        ))
+        .id();
+    run(&mut app, 2);
+    assert!(app.world().get::<RapierImpulseJointHandle>(body).is_some());
+    assert!(app.world().get::<RapierImpulseJointHandle>(ball).is_some());
+
+    // The soft body is held where it would otherwise have fallen, and holds the ball.
+    run(&mut app, 120);
+    let set = rigid_body_set(&mut app);
+    let com = set.soft_body_center_of_mass(body).unwrap();
+    assert!((com - v(0.0, 3.0)).length() < 0.5, "{com}");
+    let ball_rb = &set.bodies[set.entity2body()[&ball]];
+    assert!(ball_rb.translation().y > 0.5, "{}", ball_rb.translation());
+
+    // Despawning the soft body unmaps it and removes its joints.
+    app.world_mut().despawn(body);
+    run(&mut app, 2);
+    let set = rigid_body_set(&mut app);
+    assert!(!set.entity2body().contains_key(&body));
+    let context = context_entity(&mut app);
+    let joints = app.world().get::<RapierContextJoints>(context).unwrap();
+    assert!(joints.impulse_joints.is_empty());
+}
+
+#[test]
+fn cluster_components_are_applied_and_reset() {
+    let mut app = test_app();
+    let body = app
+        .world_mut()
+        .spawn((Transform::from_xyz(0.0, 3.0, 0.0), pinned_rope()))
+        .id();
+    let cluster = app
+        .world_mut()
+        .spawn(SoftBodyCluster::new(body, [7, 8]))
+        .id();
+    run(&mut app, 2);
+    let (handle, index) = rigid_body_set(&mut app)
+        .soft_body_cluster_index(cluster)
+        .unwrap();
+    assert_eq!(index, 1);
+
+    // Pin the cluster and move it with a kinematic target.
+    let target = Transform::from_xyz(5.0, 3.0, 0.0);
+    app.world_mut()
+        .entity_mut(cluster)
+        .insert(SoftBodyClusterKinematicTarget(target));
+    assert!(app.world().get::<SoftBodyClusterPinned>(cluster).is_some());
+    run(&mut app, 3);
+    let sb = &rigid_body_set(&mut app).soft_bodies[handle];
+    assert!(sb.particles()[7].is_pinned() && sb.particles()[8].is_pinned());
+    let center = (sb.particle_position(7) + sb.particle_position(8)) / 2.0;
+    assert!((center - v(5.0, 3.0)).length() < 1.0e-3, "{center}");
+
+    // Changing the soft body's pinned particles keeps the cluster pinned.
+    app.world_mut()
+        .entity_mut(body)
+        .insert(SoftBodyPinnedParticles(vec![0, 8]));
+    app.update();
+    let sb = &rigid_body_set(&mut app).soft_bodies[handle];
+    assert!(sb.particles()[7].is_pinned() && sb.particles()[8].is_pinned());
+
+    // Unpinning the cluster keeps the particles pinned by the soft body.
+    app.world_mut()
+        .entity_mut(cluster)
+        .remove::<(SoftBodyClusterKinematicTarget, SoftBodyClusterPinned)>();
+    app.update();
+    let sb = &rigid_body_set(&mut app).soft_bodies[handle];
+    assert!(!sb.particles()[7].is_pinned());
+    assert!(sb.particles()[8].is_pinned());
+    assert!(sb.particles()[0].is_pinned());
+
+    // Shape matching and regional material.
+    app.world_mut().entity_mut(cluster).insert((
+        SoftBodyClusterShapeMatching {
+            target: Some(Transform::from_xyz(1.0, 2.0, 0.0)),
+        },
+        SoftBodyClusterMaterial {
+            tear_resistance: 3.0,
+            ..default()
+        },
+    ));
+    app.update();
+    let sb = &rigid_body_set(&mut app).soft_bodies[handle];
+    assert!(sb.cluster(index).unwrap().shape_matching_enabled());
+    let edge = |sb: &RapierSoftBody| {
+        sb.edges()
+            .iter()
+            .find(|e| e.vertices == [7, 8])
+            .unwrap()
+            .tear_resistance
+    };
+    assert_eq!(edge(sb), 3.0);
+
+    app.world_mut()
+        .entity_mut(cluster)
+        .remove::<(SoftBodyClusterShapeMatching, SoftBodyClusterMaterial)>();
+    app.update();
+    let sb = &rigid_body_set(&mut app).soft_bodies[handle];
+    assert!(!sb.cluster(index).unwrap().shape_matching_enabled());
+    assert_eq!(edge(sb), 1.0);
+
+    // The components also drive the whole-body cluster of a soft body entity.
+    app.world_mut()
+        .entity_mut(body)
+        .insert(SoftBodyClusterPinned);
+    app.update();
+    let sb = &rigid_body_set(&mut app).soft_bodies[handle];
+    assert!(sb.particles().iter().all(|p| p.is_pinned()));
+}
+
+#[test]
+fn tear_remaps_the_particle_indices_of_the_components() {
+    let mut app = test_app();
+    collect::<SoftBodyTearEvent>(&mut app);
+    let anchor = app
+        .world_mut()
+        .spawn((Transform::from_xyz(4.0, 3.0, 0.0), RigidBody::Fixed))
+        .id();
+    // A rope pinned at its first particle, and held by its last one.
+    let body = app
+        .world_mut()
+        .spawn((
+            Transform::from_xyz(0.0, 3.0, 0.0),
+            pinned_rope(),
+            SoftBodyPinnedParticles(vec![0, 7]),
+            SoftBodyKinematicTargets(vec![(7, v(3.5, 3.0))]),
+            SoftBodyAttachments(vec![SoftBodyAttachment {
+                particle: 8,
+                body: anchor,
+            }]),
+            SoftBodyExternalForce {
+                force: v(0.0, 1.0),
+                particle_forces: vec![(6, v(1.0, 0.0))],
+            },
+        ))
+        .id();
+    run(&mut app, 2);
+    let (torn, held) = {
+        let sb = rigid_body_set(&mut app).soft_body(body).unwrap();
+        let torn = sb
+            .edges()
+            .iter()
+            .position(|e| e.vertices == [5, 6] && e.kind == SoftBodyEdgeKind::Structural)
+            .unwrap() as u32;
+        (torn, sb.particle_position(7))
+    };
+    // Impulses written between the step and the writeback are only applied on the next frame,
+    // after the tear remapped them.
+    #[derive(Resource)]
+    struct PendingImpulse(Option<Entity>);
+    app.insert_resource(PendingImpulse(Some(body)));
+    app.add_systems(
+        PostUpdate,
+        (|mut pending: ResMut<PendingImpulse>, mut commands: Commands| {
+            if let Some(entity) = pending.0.take() {
+                commands.entity(entity).insert(SoftBodyExternalImpulse {
+                    velocity_change: v(0.0, 1.0),
+                    particle_impulses: vec![(6, v(1.0, 0.0)), (1, v(2.0, 0.0))],
+                });
+            }
+        })
+        .after(PhysicsSet::StepSimulation)
+        .before(PhysicsSet::Writeback),
+    );
+
+    let result = tear(&mut app, body, torn);
+    let raw = result.raw;
+    assert_eq!(raw.pieces.len(), 2);
+    let dest = |particle: u32| raw.particle_destination(particle).unwrap();
+    // The particles 6 to 8 went to the other piece.
+    let (piece_handle, i7) = dest(7);
+    let (_, i6) = dest(6);
+    let (_, i8) = dest(8);
+    let (_, i0) = dest(0);
+    let (_, i1) = dest(1);
+    assert_ne!(piece_handle, raw.soft_body);
+    app.update();
+
+    let piece = result.pieces[1];
+    let world = app.world();
+    let impulse = world.get::<SoftBodyExternalImpulse>(piece).unwrap();
+    assert_eq!(impulse.velocity_change, v(0.0, 1.0));
+    assert_eq!(impulse.particle_impulses, [(i6, v(1.0, 0.0))]);
+    let impulse = world.get::<SoftBodyExternalImpulse>(body).unwrap();
+    assert_eq!(impulse.particle_impulses, [(i1, v(2.0, 0.0))]);
+    // The pinned particles of the builders were remapped too.
+    assert_eq!(world.get::<SoftBody>(body).unwrap().builder.pinned, [i0]);
+    assert!(world
+        .get::<SoftBody>(piece)
+        .unwrap()
+        .builder
+        .pinned
+        .is_empty());
+    app.update();
+
+    let events = &app
+        .world()
+        .resource::<Received<SoftBodyTearEvent>>()
+        .messages;
+    let piece = events[0].pieces[1].soft_body;
+    let world = app.world();
+    assert_eq!(world.get::<SoftBodyPinnedParticles>(body).unwrap().0, [0]);
+    assert!(world
+        .get::<SoftBodyKinematicTargets>(body)
+        .unwrap()
+        .0
+        .is_empty());
+    assert!(world.get::<SoftBodyAttachments>(body).unwrap().0.is_empty());
+    assert_eq!(world.get::<SoftBodyPinnedParticles>(piece).unwrap().0, [i7]);
+    assert_eq!(
+        world.get::<SoftBodyKinematicTargets>(piece).unwrap().0,
+        [(i7, v(3.5, 3.0))]
+    );
+    assert_eq!(
+        world.get::<SoftBodyAttachments>(piece).unwrap().0,
+        [SoftBodyAttachment {
+            particle: i8,
+            body: anchor
+        }]
+    );
+    let force = world.get::<SoftBodyExternalForce>(piece).unwrap();
+    assert_eq!(force.force, v(0.0, 1.0));
+    assert_eq!(force.particle_forces, [(i6, v(1.0, 0.0))]);
+    // The piece's whole-body proxy is mapped to its entity.
+    let set = rigid_body_set(&mut app);
+    assert_eq!(
+        set.entity2body().get(&piece),
+        set.soft_body_whole_proxy(piece).as_ref()
+    );
+    assert!(set.entity2body().contains_key(&piece));
+
+    // The pinned particle stays pinned, even after the components are applied again.
+    app.world_mut()
+        .get_mut::<SoftBodyPinnedParticles>(piece)
+        .unwrap()
+        .set_changed();
+    run(&mut app, 60);
+    let sb = rigid_body_set(&mut app).soft_body(piece).unwrap();
+    assert!(sb.particles()[i7 as usize].is_pinned());
+    assert!((sb.particle_position(i7 as usize) - held).length() < 1.0e-4);
+    assert_eq!(sb.particle_attachments().len(), 1);
+    assert_eq!(sb.particle_attachments()[0].particle, i8);
+
+    // Removing the pinned particles restores the (remapped) pins of the builder.
+    for entity in [body, piece] {
+        app.world_mut()
+            .entity_mut(entity)
+            .remove::<(SoftBodyPinnedParticles, SoftBodyKinematicTargets)>();
+    }
+    app.update();
+    let set = rigid_body_set(&mut app);
+    let pinned = |entity| -> Vec<usize> {
+        let sb = set.soft_body(entity).unwrap();
+        (0..sb.num_particles())
+            .filter(|i| sb.particles()[*i].is_pinned())
+            .collect()
+    };
+    assert_eq!(pinned(body), [i0 as usize]);
+    assert!(pinned(piece).is_empty());
+}
diff --git a/bindings/bevy_rapier/src/plugin/systems/character_controller.rs b/bindings/bevy_rapier/src/plugin/systems/character_controller.rs
new file mode 100644
index 000000000..ccb5294cf
--- /dev/null
+++ b/bindings/bevy_rapier/src/plugin/systems/character_controller.rs
@@ -0,0 +1,328 @@
+use crate::control::controller_filter::ControllerExclusions;
+use crate::control::CharacterCollision;
+use crate::control::ControllerIgnored;
+use crate::dynamics::RapierRigidBodyHandle;
+use crate::geometry::RapierColliderHandle;
+use crate::plugin::context::systemparams::RAPIER_CONTEXT_EXPECT_ERROR;
+use crate::plugin::context::RapierContextEntityLink;
+use crate::plugin::RapierConfiguration;
+use crate::prelude::context::RapierContextColliders;
+use crate::prelude::context::RapierContextSimulation;
+use crate::prelude::context::RapierRigidBodySet;
+use crate::prelude::KinematicCharacterController;
+use crate::prelude::KinematicCharacterControllerOutput;
+use crate::utils;
+use bevy::ecs::entity::EntityHashSet;
+use bevy::prelude::*;
+use rapier::geometry::{Collider as RapierCollider, ColliderHandle};
+use rapier::math::Pose;
+use rapier::pipeline::QueryFilter;
+
+/// System responsible for applying the character controller translation to the underlying
+/// collider.
+pub fn update_character_controls(
+    mut commands: Commands,
+    config: Query<&RapierConfiguration>,
+    mut context_access: Query<(
+        &mut RapierContextSimulation,
+        &mut RapierContextColliders,
+        &mut RapierRigidBodySet,
+    )>,
+    mut character_controllers: Query<(
+        Entity,
+        &RapierContextEntityLink,
+        &mut KinematicCharacterController,
+        Option<&mut KinematicCharacterControllerOutput>,
+        Option<&RapierColliderHandle>,
+        Option<&RapierRigidBodyHandle>,
+        Option<&GlobalTransform>,
+    )>,
+    mut transforms: Query<&mut Transform>,
+    ignored: Query<Entity, With<ControllerIgnored>>,
+) {
+    let ignored: EntityHashSet = ignored.iter().collect();
+    for (
+        entity,
+        rapier_context_link,
+        mut controller,
+        output,
+        collider_handle,
+        body_handle,
+        glob_transform,
+    ) in character_controllers.iter_mut()
+    {
+        if let (Some(raw_controller), Some(translation)) =
+            (controller.to_raw(), controller.translation)
+        {
+            let config = config
+                .get(rapier_context_link.0)
+                .expect("Could not get [`RapierConfiguration`]");
+            let (mut context, mut context_colliders, mut rigidbody_set) = context_access
+                .get_mut(rapier_context_link.0)
+                .expect(RAPIER_CONTEXT_EXPECT_ERROR);
+
+            let context = &mut *context;
+            let rigidbody_set = &mut *rigidbody_set;
+            let scaled_custom_shape =
+                controller
+                    .custom_shape
+                    .as_ref()
+                    .map(|(custom_shape, tra, rot)| {
+                        // TODO: avoid the systematic scale somehow?
+                        let mut scaled_shape = custom_shape.clone();
+                        scaled_shape.set_scale(custom_shape.scale, config.scaled_shape_subdivision);
+
+                        (scaled_shape, *tra, *rot)
+                    });
+
+            let parent_rigid_body = body_handle.map(|h| h.0).or_else(|| {
+                collider_handle
+                    .and_then(|h| context_colliders.colliders.get(h.0))
+                    .and_then(|c| c.parent())
+            });
+            let entity_to_move = parent_rigid_body
+                .and_then(|rb| rigidbody_set.rigid_body_entity(rb))
+                .unwrap_or(entity);
+
+            let (character_shape, character_pos) = if let Some((scaled_shape, tra, rot)) =
+                &scaled_custom_shape
+            {
+                let mut shape_pos: Pose = utils::pose_from(*tra, *rot);
+
+                if let Some(body) = body_handle.and_then(|h| rigidbody_set.bodies.get(h.0)) {
+                    shape_pos = body.position() * shape_pos
+                } else if let Some(gtransform) = glob_transform {
+                    shape_pos = utils::transform_to_iso(&gtransform.compute_transform()) * shape_pos
+                }
+
+                (&*scaled_shape.raw, shape_pos)
+            } else if let Some(collider) =
+                collider_handle.and_then(|h| context_colliders.colliders.get(h.0))
+            {
+                (collider.shape(), *collider.position())
+            } else {
+                continue;
+            };
+            let character_shape = character_shape.clone_dyn();
+
+            let exclude_collider = collider_handle.map(|h| h.0);
+
+            let character_mass = controller
+                .custom_mass
+                .or_else(|| {
+                    parent_rigid_body
+                        .and_then(|h| rigidbody_set.bodies.get(h))
+                        .map(|rb| rb.mass())
+                })
+                .unwrap_or(0.0);
+
+            let exclusions = ControllerExclusions::new(
+                &controller.exclude_colliders,
+                &controller.exclude_rigid_bodies,
+                &ignored,
+                controller.filter_predicate.as_ref(),
+                rigidbody_set,
+            );
+            let predicate =
+                |_: ColliderHandle, collider: &RapierCollider| exclusions.test(collider);
+            let mut filter = QueryFilter {
+                flags: controller.filter_flags,
+                groups: controller.filter_groups.map(|g| g.into()),
+                exclude_collider: None,
+                exclude_rigid_body: None,
+                predicate: (!exclusions.is_empty())
+                    .then_some(&predicate as &dyn Fn(ColliderHandle, &RapierCollider) -> bool),
+            };
+
+            if let Some(parent) = parent_rigid_body {
+                filter = filter.exclude_rigid_body(parent);
+            } else if let Some(excl_co) = exclude_collider {
+                filter = filter.exclude_collider(excl_co)
+            };
+
+            let collisions = &mut context.character_collisions_collector;
+            collisions.clear();
+
+            let mut query_pipeline = context.broad_phase.as_query_pipeline_mut(
+                context.narrow_phase.query_dispatcher(),
+                &mut rigidbody_set.bodies,
+                &mut context_colliders.colliders,
+                filter,
+            );
+
+            let movement = raw_controller.move_shape(
+                context.integration_parameters.dt,
+                &query_pipeline.as_ref(),
+                &*character_shape,
+                &character_pos,
+                translation,
+                |c| collisions.push(c),
+            );
+
+            if controller.apply_impulse_to_dynamic_bodies {
+                raw_controller.solve_character_collision_impulses(
+                    context.integration_parameters.dt,
+                    &mut query_pipeline,
+                    &*character_shape,
+                    character_mass,
+                    collisions.iter(),
+                )
+            }
+
+            if let Ok(mut transform) = transforms.get_mut(entity_to_move) {
+                // TODO: take the parent’s GlobalTransform rotation into account?
+                transform.translation.x += movement.translation.x;
+                transform.translation.y += movement.translation.y;
+                #[cfg(feature = "dim3")]
+                {
+                    transform.translation.z += movement.translation.z;
+                }
+            }
+
+            let converted_collisions = context
+                .character_collisions_collector
+                .iter()
+                .filter_map(|c| CharacterCollision::from_raw(&context_colliders, c));
+
+            if let Some(mut output) = output {
+                output.desired_translation = controller.translation.unwrap();
+                output.effective_translation = movement.translation;
+                output.grounded = movement.grounded;
+                output.collisions.clear();
+                output.collisions.extend(converted_collisions);
+                output.is_sliding_down_slope = movement.is_sliding_down_slope;
+            } else {
+                commands
+                    .entity(entity)
+                    .insert(KinematicCharacterControllerOutput {
+                        desired_translation: controller.translation.unwrap(),
+                        effective_translation: movement.translation,
+                        grounded: movement.grounded,
+                        collisions: converted_collisions.collect(),
+                        is_sliding_down_slope: movement.is_sliding_down_slope,
+                    });
+            }
+
+            controller.translation = None;
+        }
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use crate::control::{
+        ControllerFilterPredicate, ControllerIgnored, KinematicCharacterController,
+    };
+    use crate::geometry::Collider;
+    use crate::math::Vect;
+    use crate::plugin::{NoUserData, RapierPhysicsPlugin};
+    use crate::prelude::RigidBody;
+    use bevy::ecs::entity::EntityHashSet;
+    use bevy::prelude::*;
+    use bevy::time::{TimePlugin, TimeUpdateStrategy};
+
+    #[cfg(feature = "dim2")]
+    fn wall() -> Collider {
+        Collider::cuboid(0.25, 2.0)
+    }
+
+    #[cfg(feature = "dim3")]
+    fn wall() -> Collider {
+        Collider::cuboid(0.25, 2.0, 2.0)
+    }
+
+    #[test]
+    fn character_controller_exclusions() {
+        let mut app = App::new();
+        app.add_plugins((
+            TransformPlugin,
+            TimePlugin,
+            RapierPhysicsPlugin::<NoUserData>::default(),
+        ))
+        .insert_resource(TimeUpdateStrategy::ManualDuration(
+            std::time::Duration::from_secs_f32(1.0 / 60.0),
+        ));
+        app.finish();
+
+        // One row per scenario, each with its own wall in the character's path.
+        let mut spawn_row = |row: usize, wall_is_body: bool| {
+            let y = row as f32 * 10.0;
+            let mut wall_entity = app
+                .world_mut()
+                .spawn((Transform::from_xyz(3.0, y, 0.0), wall()));
+            if wall_is_body {
+                wall_entity.insert(RigidBody::Fixed);
+            }
+            let wall_entity = wall_entity.id();
+            let character = app
+                .world_mut()
+                .spawn((
+                    Transform::from_xyz(0.0, y, 0.0),
+                    Collider::ball(0.5),
+                    KinematicCharacterController {
+                        snap_to_ground: None,
+                        ..Default::default()
+                    },
+                ))
+                .id();
+            (wall_entity, character)
+        };
+        let (_, blocked) = spawn_row(0, false);
+        let (wall1, excluded_collider) = spawn_row(1, false);
+        let (wall2, excluded_body) = spawn_row(2, true);
+        let (wall3, predicate_filtered) = spawn_row(3, false);
+        let (wall4, ignored_collider) = spawn_row(4, false);
+        let (wall5, ignored_body) = spawn_row(5, true);
+
+        // Let the colliders be initialized and inserted into the broad-phase.
+        app.update();
+        app.update();
+
+        let world = app.world_mut();
+        world
+            .get_mut::<KinematicCharacterController>(excluded_collider)
+            .unwrap()
+            .exclude_colliders = EntityHashSet::from_iter([wall1]);
+        world
+            .get_mut::<KinematicCharacterController>(excluded_body)
+            .unwrap()
+            .exclude_rigid_bodies = EntityHashSet::from_iter([wall2]);
+        world
+            .get_mut::<KinematicCharacterController>(predicate_filtered)
+            .unwrap()
+            .filter_predicate = Some(ControllerFilterPredicate::new(move |e, _| e != wall3));
+        world.entity_mut(wall4).insert(ControllerIgnored);
+        world.entity_mut(wall5).insert(ControllerIgnored);
+        for character in [
+            blocked,
+            excluded_collider,
+            excluded_body,
+            predicate_filtered,
+            ignored_collider,
+            ignored_body,
+        ] {
+            world
+                .get_mut::<KinematicCharacterController>(character)
+                .unwrap()
+                .translation = Some(Vect::X * 6.0);
+        }
+
+        app.update();
+
+        let x = |entity: Entity| app.world().get::<Transform>(entity).unwrap().translation.x;
+        assert!(x(blocked) < 2.5, "The wall should block the character");
+        for character in [
+            excluded_collider,
+            excluded_body,
+            predicate_filtered,
+            ignored_collider,
+            ignored_body,
+        ] {
+            assert!(
+                (x(character) - 6.0).abs() < 1.0e-3,
+                "The character should pass through the excluded wall: {}",
+                x(character)
+            );
+        }
+    }
+}
diff --git a/bindings/bevy_rapier/src/plugin/systems/collider.rs b/bindings/bevy_rapier/src/plugin/systems/collider.rs
new file mode 100644
index 000000000..1cf45c5e3
--- /dev/null
+++ b/bindings/bevy_rapier/src/plugin/systems/collider.rs
@@ -0,0 +1,1108 @@
+use crate::dynamics::{DeformableCollider, DeformableColliderError, ReadMassProperties};
+use crate::geometry::Collider;
+use crate::plugin::context::systemparams::{RapierEntity, RAPIER_CONTEXT_EXPECT_ERROR};
+use crate::plugin::context::RapierContextEntityLink;
+use crate::plugin::{
+    context::{RapierContextColliders, RapierRigidBodySet},
+    RapierConfiguration,
+};
+use crate::prelude::{
+    ActiveCollisionTypes, ActiveEvents, ActiveHooks, ColliderDisabled, ColliderMassProperties,
+    ColliderScale, CollidingEntities, CollisionEvent, CollisionGroups, ContactForceEventThreshold,
+    ContactSkin, Friction, MassModifiedEvent, MassProperties, RapierColliderHandle,
+    RapierRigidBodyHandle, Restitution, Sensor, SolverGroups,
+};
+use crate::utils;
+use bevy::prelude::*;
+
+use super::RapierContextLinkResolver;
+use rapier::dynamics::RigidBodyHandle;
+use rapier::geometry::ColliderBuilder;
+#[cfg(all(feature = "dim3", feature = "async-collider"))]
+use {
+    crate::prelude::{AsyncCollider, AsyncSceneCollider},
+    bevy::world_serialization::WorldInstance,
+};
+
+#[cfg(feature = "dim2")]
+use bevy::math::Vec3Swizzles;
+
+/// Components related to colliders.
+pub type ColliderComponents<'a> = (
+    (Entity, Option<&'a RapierContextEntityLink>),
+    &'a Collider,
+    Option<&'a Sensor>,
+    Option<&'a ColliderMassProperties>,
+    Option<&'a ActiveEvents>,
+    Option<&'a ActiveHooks>,
+    Option<&'a ActiveCollisionTypes>,
+    Option<&'a Friction>,
+    Option<&'a Restitution>,
+    Option<&'a ContactSkin>,
+    Option<&'a CollisionGroups>,
+    Option<&'a SolverGroups>,
+    Option<&'a ContactForceEventThreshold>,
+    Option<&'a ColliderDisabled>,
+);
+
+/// System responsible for applying [`GlobalTransform`] scale and/or [`ColliderScale`] to
+/// colliders.
+pub fn apply_scale(
+    config: Query<&RapierConfiguration>,
+    mut changed_collider_scales: Query<
+        (
+            &mut Collider,
+            &RapierContextEntityLink,
+            &GlobalTransform,
+            Option<&ColliderScale>,
+        ),
+        Or<(
+            Changed<Collider>,
+            Changed<GlobalTransform>,
+            Changed<ColliderScale>,
+        )>,
+    >,
+) {
+    for (mut shape, link, transform, custom_scale) in changed_collider_scales.iter_mut() {
+        let config = config.get(link.0).unwrap();
+        #[cfg(feature = "dim2")]
+        let effective_scale = match custom_scale {
+            Some(ColliderScale::Absolute(scale)) => *scale,
+            Some(ColliderScale::Relative(scale)) => {
+                *scale * transform.compute_transform().scale.xy()
+            }
+            None => transform.compute_transform().scale.xy(),
+        };
+        #[cfg(feature = "dim3")]
+        let effective_scale = match custom_scale {
+            Some(ColliderScale::Absolute(scale)) => *scale,
+            Some(ColliderScale::Relative(scale)) => *scale * transform.compute_transform().scale,
+            None => transform.compute_transform().scale,
+        };
+
+        if shape.scale != crate::geometry::get_snapped_scale(effective_scale) {
+            shape.set_scale(effective_scale, config.scaled_shape_subdivision);
+        }
+    }
+}
+
+/// System responsible for applying changes the user made to a collider-related component.
+pub fn apply_collider_user_changes(
+    mut context: Query<(&RapierRigidBodySet, &mut RapierContextColliders)>,
+    config: Query<&RapierConfiguration>,
+    (changed_collider_transforms, child_of_query, transform_query): (
+        Query<
+            (RapierEntity, &RapierColliderHandle, &GlobalTransform),
+            (Without<RapierRigidBodyHandle>, Changed<GlobalTransform>),
+        >,
+        Query<&ChildOf>,
+        Query<&Transform>,
+    ),
+
+    changed_shapes: Query<(RapierEntity, &RapierColliderHandle, &Collider), Changed<Collider>>,
+    changed_active_events: Query<
+        (RapierEntity, &RapierColliderHandle, &ActiveEvents),
+        Changed<ActiveEvents>,
+    >,
+    changed_active_hooks: Query<
+        (RapierEntity, &RapierColliderHandle, &ActiveHooks),
+        Changed<ActiveHooks>,
+    >,
+    changed_active_collision_types: Query<
+        (RapierEntity, &RapierColliderHandle, &ActiveCollisionTypes),
+        Changed<ActiveCollisionTypes>,
+    >,
+    (changed_friction, changed_restitution, changed_contact_skin): (
+        Query<(RapierEntity, &RapierColliderHandle, &Friction), Changed<Friction>>,
+        Query<(RapierEntity, &RapierColliderHandle, &Restitution), Changed<Restitution>>,
+        Query<(RapierEntity, &RapierColliderHandle, &ContactSkin), Changed<ContactSkin>>,
+    ),
+    changed_collision_groups: Query<
+        (RapierEntity, &RapierColliderHandle, &CollisionGroups),
+        Changed<CollisionGroups>,
+    >,
+    changed_solver_groups: Query<
+        (RapierEntity, &RapierColliderHandle, &SolverGroups),
+        Changed<SolverGroups>,
+    >,
+    changed_sensors: Query<(RapierEntity, &RapierColliderHandle, &Sensor), Changed<Sensor>>,
+    changed_disabled: Query<
+        (RapierEntity, &RapierColliderHandle, &ColliderDisabled),
+        Changed<ColliderDisabled>,
+    >,
+    changed_contact_force_threshold: Query<
+        (
+            RapierEntity,
+            &RapierColliderHandle,
+            &ContactForceEventThreshold,
+        ),
+        Changed<ContactForceEventThreshold>,
+    >,
+    changed_collider_mass_props: Query<
+        (RapierEntity, &RapierColliderHandle, &ColliderMassProperties),
+        Changed<ColliderMassProperties>,
+    >,
+
+    mut mass_modified: MessageWriter<MassModifiedEvent>,
+) {
+    for (rapier_entity, handle, transform) in changed_collider_transforms.iter() {
+        let (rigidbody_set, mut context_colliders) = context
+            .get_mut(rapier_entity.rapier_context_link.0)
+            .expect(RAPIER_CONTEXT_EXPECT_ERROR);
+        if is_deformable(&context_colliders, handle) {
+            // A deformable collider follows the particles of its soft body.
+            continue;
+        }
+        if context_colliders
+            .collider_parent(rigidbody_set, rapier_entity.entity)
+            .is_some()
+        {
+            let (_, collider_position) = collider_offset(
+                rapier_entity.entity,
+                rigidbody_set,
+                &child_of_query,
+                &transform_query,
+            );
+
+            if let Some(co) = context_colliders.colliders.get_mut(handle.0) {
+                let new_pos = utils::transform_to_iso(&collider_position);
+
+                if co
+                    .position_wrt_parent()
+                    .map(|pos| *pos != new_pos)
+                    .unwrap_or(true)
+                {
+                    co.set_position_wrt_parent(new_pos);
+                }
+            }
+        } else if let Some(co) = context_colliders.colliders.get_mut(handle.0) {
+            let new_pos = utils::transform_to_iso(&transform.compute_transform());
+
+            if *co.position() != new_pos {
+                co.set_position(utils::transform_to_iso(&transform.compute_transform()));
+            }
+        }
+    }
+
+    for (rapier_entity, handle, shape) in changed_shapes.iter() {
+        let (rigidbody_set, mut context_colliders) = context
+            .get_mut(rapier_entity.rapier_context_link.0)
+            .expect(RAPIER_CONTEXT_EXPECT_ERROR);
+        let config = config.get(rapier_entity.rapier_context_link.0).unwrap();
+        if is_deformable(&context_colliders, handle) {
+            // The shape of a deformable collider is managed by its soft body.
+            continue;
+        }
+        if let Some(co) = context_colliders.colliders.get_mut(handle.0) {
+            let mut scaled_shape = shape.clone();
+            scaled_shape.set_scale(shape.scale, config.scaled_shape_subdivision);
+            co.set_shape(scaled_shape.raw.clone());
+
+            if let Some(body) = co.parent() {
+                if let Some(body_entity) = rigidbody_set.rigid_body_entity(body) {
+                    mass_modified.write(body_entity.into());
+                }
+            }
+        }
+    }
+
+    for (rapier_entity, handle, active_events) in changed_active_events.iter() {
+        let (_, mut context_colliders) = context
+            .get_mut(rapier_entity.rapier_context_link.0)
+            .expect(RAPIER_CONTEXT_EXPECT_ERROR);
+        if let Some(co) = context_colliders.colliders.get_mut(handle.0) {
+            co.set_active_events((*active_events).into())
+        }
+    }
+
+    for (rapier_entity, handle, active_hooks) in changed_active_hooks.iter() {
+        let (_, mut context_colliders) = context
+            .get_mut(rapier_entity.rapier_context_link.0)
+            .expect(RAPIER_CONTEXT_EXPECT_ERROR);
+        if let Some(co) = context_colliders.colliders.get_mut(handle.0) {
+            co.set_active_hooks((*active_hooks).into())
+        }
+    }
+
+    for (rapier_entity, handle, active_collision_types) in changed_active_collision_types.iter() {
+        let (_, mut context_colliders) = context
+            .get_mut(rapier_entity.rapier_context_link.0)
+            .expect(RAPIER_CONTEXT_EXPECT_ERROR);
+        if let Some(co) = context_colliders.colliders.get_mut(handle.0) {
+            co.set_active_collision_types((*active_collision_types).into())
+        }
+    }
+
+    for (rapier_entity, handle, friction) in changed_friction.iter() {
+        let (_, mut context_colliders) = context
+            .get_mut(rapier_entity.rapier_context_link.0)
+            .expect(RAPIER_CONTEXT_EXPECT_ERROR);
+        if let Some(co) = context_colliders.colliders.get_mut(handle.0) {
+            co.set_friction(friction.coefficient);
+            co.set_friction_combine_rule(friction.combine_rule.into());
+        }
+    }
+
+    for (rapier_entity, handle, restitution) in changed_restitution.iter() {
+        let (_, mut context_colliders) = context
+            .get_mut(rapier_entity.rapier_context_link.0)
+            .expect(RAPIER_CONTEXT_EXPECT_ERROR);
+        if let Some(co) = context_colliders.colliders.get_mut(handle.0) {
+            co.set_restitution(restitution.coefficient);
+            co.set_restitution_combine_rule(restitution.combine_rule.into());
+        }
+    }
+
+    for (rapier_entity, handle, contact_skin) in changed_contact_skin.iter() {
+        let (_, mut context_colliders) = context
+            .get_mut(rapier_entity.rapier_context_link.0)
+            .expect(RAPIER_CONTEXT_EXPECT_ERROR);
+        if let Some(co) = context_colliders.colliders.get_mut(handle.0) {
+            co.set_contact_skin(contact_skin.0);
+        }
+    }
+
+    for (rapier_entity, handle, collision_groups) in changed_collision_groups.iter() {
+        let (_, mut context_colliders) = context
+            .get_mut(rapier_entity.rapier_context_link.0)
+            .expect(RAPIER_CONTEXT_EXPECT_ERROR);
+        if let Some(co) = context_colliders.colliders.get_mut(handle.0) {
+            co.set_collision_groups((*collision_groups).into());
+        }
+    }
+
+    for (rapier_entity, handle, solver_groups) in changed_solver_groups.iter() {
+        let (_, mut context_colliders) = context
+            .get_mut(rapier_entity.rapier_context_link.0)
+            .expect(RAPIER_CONTEXT_EXPECT_ERROR);
+        if let Some(co) = context_colliders.colliders.get_mut(handle.0) {
+            co.set_solver_groups((*solver_groups).into());
+        }
+    }
+
+    for (rapier_entity, handle, _) in changed_sensors.iter() {
+        let (_, mut context_colliders) = context
+            .get_mut(rapier_entity.rapier_context_link.0)
+            .expect(RAPIER_CONTEXT_EXPECT_ERROR);
+        if let Some(co) = context_colliders.colliders.get_mut(handle.0) {
+            co.set_sensor(true);
+        }
+    }
+
+    for (rapier_entity, handle, _) in changed_disabled.iter() {
+        let (_, mut context_colliders) = context
+            .get_mut(rapier_entity.rapier_context_link.0)
+            .expect(RAPIER_CONTEXT_EXPECT_ERROR);
+        if let Some(co) = context_colliders.colliders.get_mut(handle.0) {
+            co.set_enabled(false);
+        }
+    }
+
+    for (rapier_entity, handle, threshold) in changed_contact_force_threshold.iter() {
+        let (_, mut context_colliders) = context
+            .get_mut(rapier_entity.rapier_context_link.0)
+            .expect(RAPIER_CONTEXT_EXPECT_ERROR);
+        if let Some(co) = context_colliders.colliders.get_mut(handle.0) {
+            co.set_contact_force_event_threshold(threshold.0);
+        }
+    }
+
+    for (rapier_entity, handle, mprops) in changed_collider_mass_props.iter() {
+        let (rigidbody_set, mut context_colliders) = context
+            .get_mut(rapier_entity.rapier_context_link.0)
+            .expect(RAPIER_CONTEXT_EXPECT_ERROR);
+        if let Some(co) = context_colliders.colliders.get_mut(handle.0) {
+            match mprops {
+                ColliderMassProperties::Density(density) => co.set_density(*density),
+                ColliderMassProperties::Mass(mass) => co.set_mass(*mass),
+                ColliderMassProperties::MassProperties(mprops) => {
+                    co.set_mass_properties(mprops.into_rapier())
+                }
+            }
+
+            if let Some(body) = co.parent() {
+                if let Some(body_entity) = rigidbody_set.rigid_body_entity(body) {
+                    mass_modified.write(body_entity.into());
+                }
+            }
+        }
+    }
+}
+
+/// Whether the collider of `handle` is bound to a soft body.
+fn is_deformable(
+    context_colliders: &RapierContextColliders,
+    handle: &RapierColliderHandle,
+) -> bool {
+    context_colliders
+        .colliders
+        .get(handle.0)
+        .is_some_and(|co| co.deformable_mesh_ref().is_some())
+}
+
+pub(crate) fn collider_offset(
+    entity: Entity,
+    rigidbody_set: &RapierRigidBodySet,
+    child_of_query: &Query<&ChildOf>,
+    transform_query: &Query<&Transform>,
+) -> (Option<RigidBodyHandle>, Transform) {
+    let mut body_entity = entity;
+    let mut body_handle = rigidbody_set.entity2body.get(&body_entity).copied();
+    let mut child_transform = Transform::default();
+    while body_handle.is_none() {
+        if let Ok(child_of) = child_of_query.get(body_entity) {
+            if let Ok(transform) = transform_query.get(body_entity) {
+                child_transform = *transform * child_transform;
+            }
+            body_entity = child_of.parent();
+        } else {
+            break;
+        }
+
+        body_handle = rigidbody_set.entity2body.get(&body_entity).copied();
+    }
+
+    if body_handle.is_some() {
+        if let Ok(transform) = transform_query.get(body_entity) {
+            let scale_transform = Transform {
+                scale: transform.scale,
+                ..default()
+            };
+
+            child_transform = scale_transform * child_transform;
+        }
+    }
+
+    (body_handle, child_transform)
+}
+
+/// The proxy rigid-body a [`DeformableCollider`] targeting `target` is bound to: the whole-body
+/// cluster's proxy of a soft body entity, or the proxy of a soft-body cluster entity.
+fn deformable_collider_parent(
+    rigidbody_set: &RapierRigidBodySet,
+    target: Entity,
+) -> Option<RigidBodyHandle> {
+    if let Some(sb) = rigidbody_set.soft_body(target) {
+        return Some(sb.root_body());
+    }
+    let handle = *rigidbody_set.entity2body.get(&target)?;
+    rigidbody_set
+        .bodies
+        .get(handle)?
+        .is_soft_frame()
+        .then_some(handle)
+}
+
+/// System responsible for creating new Rapier colliders from the related `bevy_rapier` components.
+pub fn init_colliders(
+    mut commands: Commands,
+    config: Query<&RapierConfiguration>,
+    mut context_access: Query<(&mut RapierRigidBodySet, &mut RapierContextColliders)>,
+    context_links: RapierContextLinkResolver,
+    colliders: Query<
+        (ColliderComponents, Option<&GlobalTransform>),
+        (
+            Without<RapierColliderHandle>,
+            Without<DeformableColliderError>,
+        ),
+    >,
+    mut rigid_body_mprops: Query<&mut ReadMassProperties>,
+    child_of_query: Query<&ChildOf>,
+    transform_query: Query<&Transform>,
+    deformables: Query<&DeformableCollider>,
+) {
+    for (
+        (
+            (entity, entity_context_link),
+            shape,
+            sensor,
+            mprops,
+            active_events,
+            active_hooks,
+            active_collision_types,
+            friction,
+            restitution,
+            contact_skin,
+            collision_groups,
+            solver_groups,
+            contact_force_event_threshold,
+            disabled,
+        ),
+        global_transform,
+    ) in colliders.iter()
+    {
+        // Use the RapierContextEntityLink, or insert the context of an ancestor or the default one.
+        let context_entity = context_links.resolve(entity, entity_context_link, &mut commands);
+        let Some(context_entity) = context_entity else {
+            continue;
+        };
+
+        let config = config.get(context_entity).unwrap_or_else(|_| {
+            panic!("Failed to retrieve `RapierConfiguration` on entity {context_entity}.")
+        });
+
+        let Some(mut rigidbody_set_collider_set) = context_access.get_mut(context_entity).ok()
+        else {
+            log::error!("Could not find entity {context_entity} with rapier context while initializing {entity}");
+            continue;
+        };
+        let context_colliders = &mut *rigidbody_set_collider_set.1;
+        let rigidbody_set = &mut *rigidbody_set_collider_set.0;
+        let mut scaled_shape = shape.clone();
+        scaled_shape.set_scale(shape.scale, config.scaled_shape_subdivision);
+        let mut builder = ColliderBuilder::new(scaled_shape.raw.clone());
+
+        builder = builder.sensor(sensor.is_some());
+        builder = builder.enabled(disabled.is_none());
+
+        if let Some(mprops) = mprops {
+            builder = match mprops {
+                ColliderMassProperties::Density(density) => builder.density(*density),
+                ColliderMassProperties::Mass(mass) => builder.mass(*mass),
+                ColliderMassProperties::MassProperties(mprops) => {
+                    builder.mass_properties(mprops.into_rapier())
+                }
+            };
+        }
+
+        if let Some(active_events) = active_events {
+            builder = builder.active_events((*active_events).into());
+        }
+
+        if let Some(active_hooks) = active_hooks {
+            builder = builder.active_hooks((*active_hooks).into());
+        }
+
+        if let Some(active_collision_types) = active_collision_types {
+            builder = builder.active_collision_types((*active_collision_types).into());
+        }
+
+        if let Some(friction) = friction {
+            builder = builder
+                .friction(friction.coefficient)
+                .friction_combine_rule(friction.combine_rule.into());
+        }
+
+        if let Some(restitution) = restitution {
+            builder = builder
+                .restitution(restitution.coefficient)
+                .restitution_combine_rule(restitution.combine_rule.into());
+        }
+
+        if let Some(contact_skin) = contact_skin {
+            builder = builder.contact_skin(contact_skin.0);
+        }
+
+        if let Some(collision_groups) = collision_groups {
+            builder = builder.collision_groups((*collision_groups).into());
+        }
+
+        if let Some(solver_groups) = solver_groups {
+            builder = builder.solver_groups((*solver_groups).into());
+        }
+
+        if let Some(threshold) = contact_force_event_threshold {
+            builder = builder.contact_force_event_threshold(threshold.0);
+        }
+        builder = builder.user_data(entity.to_bits() as u128);
+
+        if let Ok(deformable) = deformables.get(entity) {
+            // The soft body (or cluster) may not be created yet: try again next frame.
+            let Some(proxy) = deformable_collider_parent(rigidbody_set, deformable.target) else {
+                continue;
+            };
+            let proxy_pose = rigidbody_set
+                .bodies
+                .get(proxy)
+                .map(|rb| *rb.position())
+                .unwrap_or_default();
+            let global_transform = global_transform.cloned().unwrap_or_default();
+            let pose = utils::transform_to_iso(&global_transform.compute_transform());
+            // The vertices are placed by the entity's global transform.
+            builder = builder.position(proxy_pose.inverse() * pose);
+            match context_colliders.colliders.insert_deformable(
+                builder,
+                deformable.binding.clone(),
+                proxy,
+                &mut rigidbody_set.bodies,
+                &mut rigidbody_set.soft_bodies,
+            ) {
+                Ok(handle) => {
+                    commands.entity(entity).insert(RapierColliderHandle(handle));
+                    context_colliders.entity2collider.insert(entity, handle);
+                }
+                Err(err) => {
+                    log::error!("Failed to create the deformable collider of {entity}: {err}");
+                    commands.entity(entity).insert(DeformableColliderError(err));
+                }
+            }
+            continue;
+        }
+
+        let body_entity = entity;
+        let (body_handle, child_transform) =
+            collider_offset(entity, rigidbody_set, &child_of_query, &transform_query);
+
+        let handle = if let Some(body_handle) = body_handle {
+            builder = builder.position(utils::transform_to_iso(&child_transform));
+            let handle = context_colliders.colliders.insert_with_parent(
+                builder,
+                body_handle,
+                &mut rigidbody_set.bodies,
+            );
+            if let Ok(mut mprops) = rigid_body_mprops.get_mut(body_entity) {
+                // Inserting the collider changed the rigid-body’s mass properties.
+                // Read them back from the engine.
+                if let Some(parent_body) = rigidbody_set.bodies.get(body_handle) {
+                    mprops.set(MassProperties::from_rapier(
+                        parent_body.mass_properties().local_mprops,
+                    ));
+                }
+            }
+            handle
+        } else {
+            let global_transform = global_transform.cloned().unwrap_or_default();
+            builder = builder.position(utils::transform_to_iso(
+                &global_transform.compute_transform(),
+            ));
+            context_colliders.colliders.insert(builder)
+        };
+
+        commands.entity(entity).insert(RapierColliderHandle(handle));
+        context_colliders.entity2collider.insert(entity, handle);
+    }
+}
+
+/// System responsible for creating `Collider` components from `AsyncCollider` components if the
+/// corresponding mesh has become available.
+#[cfg(all(feature = "dim3", feature = "async-collider"))]
+pub fn init_async_colliders(
+    mut commands: Commands,
+    meshes: Res<Assets<Mesh>>,
+    async_colliders: Query<(Entity, &Mesh3d, &AsyncCollider)>,
+) {
+    for (entity, mesh_handle, async_collider) in async_colliders.iter() {
+        if let Some(mesh) = meshes.get(mesh_handle) {
+            match Collider::from_bevy_mesh(mesh, &async_collider.0) {
+                Some(collider) => {
+                    commands
+                        .entity(entity)
+                        .insert(collider)
+                        .remove::<AsyncCollider>();
+                }
+                None => log::error!("Unable to generate collider from mesh {mesh:?}"),
+            }
+        }
+    }
+}
+
+/// System responsible for creating `Collider` components from `AsyncSceneCollider` components if the
+/// corresponding scene has become available.
+#[cfg(all(feature = "dim3", feature = "async-collider"))]
+pub fn init_async_scene_colliders(
+    mut commands: Commands,
+    meshes: Res<Assets<Mesh>>,
+    scene_spawner: If<Res<WorldInstanceSpawner>>,
+    async_colliders: Query<(Entity, &WorldInstance, &AsyncSceneCollider)>,
+    children: Query<&Children>,
+    mesh_handles: Query<(&Name, &Mesh3d)>,
+) {
+    for (scene_entity, scene_instance, async_collider) in async_colliders.iter() {
+        if scene_spawner.instance_is_ready(**scene_instance) {
+            for child_entity in children.iter_descendants(scene_entity) {
+                if let Ok((name, handle)) = mesh_handles.get(child_entity) {
+                    let shape = async_collider
+                        .named_shapes
+                        .get(name.as_str())
+                        .unwrap_or(&async_collider.shape);
+                    if let Some(shape) = shape {
+                        let mesh = meshes.get(handle).unwrap(); // NOTE: Mesh is already loaded
+                        match Collider::from_bevy_mesh(mesh, shape) {
+                            Some(collider) => {
+                                commands.entity(child_entity).insert(collider);
+                            }
+                            None => log::error!(
+                                "Unable to generate collider from mesh {mesh:?} with name {name}"
+                            ),
+                        }
+                    }
+                }
+            }
+
+            commands.entity(scene_entity).remove::<AsyncSceneCollider>();
+        }
+    }
+}
+
+/// Adds entity to [`CollidingEntities`] on starting collision and removes from it when the
+/// collision ends.
+pub fn update_colliding_entities(
+    mut collision_events: MessageReader<CollisionEvent>,
+    mut colliding_entities: Query<&mut CollidingEntities>,
+) {
+    for event in collision_events.read() {
+        match event.to_owned() {
+            CollisionEvent::Started(entity1, entity2, _) => {
+                if let Ok(mut entities) = colliding_entities.get_mut(entity1) {
+                    entities.0.insert(entity2);
+                }
+                if let Ok(mut entities) = colliding_entities.get_mut(entity2) {
+                    entities.0.insert(entity1);
+                }
+            }
+            CollisionEvent::Stopped(entity1, entity2, _) => {
+                if let Ok(mut entities) = colliding_entities.get_mut(entity1) {
+                    entities.0.remove(&entity2);
+                }
+                if let Ok(mut entities) = colliding_entities.get_mut(entity2) {
+                    entities.0.remove(&entity1);
+                }
+            }
+        }
+    }
+}
+
+#[cfg(test)]
+#[allow(missing_docs)]
+pub mod test {
+    #[test]
+    #[cfg(all(feature = "dim3", feature = "async-collider"))]
+    fn async_collider_initializes() {
+        use super::*;
+        use bevy::{mesh::MeshPlugin, world_serialization::WorldSerializationPlugin};
+
+        let mut app = App::new();
+        app.add_plugins((AssetPlugin::default(), MeshPlugin, WorldSerializationPlugin));
+        app.add_systems(Update, init_async_colliders);
+
+        app.finish();
+
+        let mut meshes = app.world_mut().resource_mut::<Assets<Mesh>>();
+        let cube = meshes.add(Cuboid::default());
+
+        let entity = app
+            .world_mut()
+            .spawn((Mesh3d(cube), AsyncCollider::default()))
+            .id();
+
+        app.update();
+
+        let entity = app.world().entity(entity);
+        assert!(
+            entity.get::<Collider>().is_some(),
+            "Collider component should be added"
+        );
+        assert!(
+            entity.get::<AsyncCollider>().is_none(),
+            "AsyncCollider component should be removed after Collider component creation"
+        );
+    }
+
+    #[test]
+    #[cfg(all(feature = "dim3", feature = "async-collider"))]
+    fn async_collider_voxels_and_converted_initialize() {
+        use super::*;
+        use crate::geometry::{ComputedColliderShape, FillMode, MeshConverter};
+        use bevy::{mesh::MeshPlugin, world_serialization::WorldSerializationPlugin};
+
+        let mut app = App::new();
+        app.add_plugins((AssetPlugin::default(), MeshPlugin, WorldSerializationPlugin));
+        app.add_systems(Update, init_async_colliders);
+
+        app.finish();
+
+        let mut meshes = app.world_mut().resource_mut::<Assets<Mesh>>();
+        let cube = meshes.add(Cuboid::default());
+
+        let voxels = app
+            .world_mut()
+            .spawn((
+                Mesh3d(cube.clone()),
+                AsyncCollider(ComputedColliderShape::Voxels {
+                    voxel_size: 0.25,
+                    fill_mode: FillMode::default(),
+                }),
+            ))
+            .id();
+        let aabb = app
+            .world_mut()
+            .spawn((
+                Mesh3d(cube),
+                AsyncCollider(ComputedColliderShape::Converted(MeshConverter::Aabb)),
+            ))
+            .id();
+
+        app.update();
+
+        let voxels = app.world().entity(voxels).get::<Collider>().unwrap();
+        assert!(voxels.as_voxels().is_some());
+        let aabb = app.world().entity(aabb).get::<Collider>().unwrap();
+        assert!(aabb.as_cuboid().is_some());
+    }
+
+    #[test]
+    #[cfg(all(feature = "dim3", feature = "async-collider"))]
+    fn async_scene_collider_initializes() {
+        use super::*;
+        use bevy::{mesh::MeshPlugin, world_serialization::WorldSerializationPlugin};
+
+        let mut app = App::new();
+        app.add_plugins((AssetPlugin::default(), MeshPlugin, WorldSerializationPlugin));
+        app.add_systems(PostUpdate, init_async_scene_colliders);
+
+        let mut meshes = app.world_mut().resource_mut::<Assets<Mesh>>();
+        let cube_handle = meshes.add(Cuboid::default());
+        let capsule_handle = meshes.add(Capsule3d::default());
+        let cube = app
+            .world_mut()
+            .spawn((Name::new("Cube"), Mesh3d(cube_handle)))
+            .id();
+        let capsule = app
+            .world_mut()
+            .spawn((Name::new("Capsule"), Mesh3d(capsule_handle)))
+            .id();
+
+        let mut scenes = app.world_mut().resource_mut::<Assets<WorldAsset>>();
+        let scene = scenes.add(WorldAsset::new(World::new()));
+
+        let mut named_shapes = bevy::platform::collections::HashMap::default();
+        named_shapes.insert("Capsule".to_string(), None);
+        let parent = app
+            .world_mut()
+            .spawn((
+                WorldAssetRoot(scene),
+                AsyncSceneCollider {
+                    named_shapes,
+                    ..Default::default()
+                },
+            ))
+            .add_children(&[cube, capsule])
+            .id();
+
+        app.update();
+
+        assert!(
+            app.world().entity(cube).get::<Collider>().is_some(),
+            "Collider component should be added for cube"
+        );
+        assert!(
+            app.world().entity(capsule).get::<Collider>().is_none(),
+            "Collider component shouldn't be added for capsule"
+        );
+        assert!(
+            app.world().entity(parent).get::<AsyncCollider>().is_none(),
+            "AsyncSceneCollider component should be removed after Collider components creation"
+        );
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+    use crate::dynamics::{CoefficientCombineRule, GravityScale, RigidBody};
+    use crate::geometry::{Group, InteractionTestMode, ReadColliderMassProperties};
+    use crate::math::Vect;
+    use crate::plugin::context::systemparams::ReadRapierContext;
+    use crate::plugin::context::{RapierContextSimulation, RapierRigidBodySet};
+    use crate::plugin::{NoUserData, RapierPhysicsPlugin};
+    use crate::prelude::QueryFilter;
+    use bevy::ecs::system::RunSystemOnce;
+    use bevy::time::{TimePlugin, TimeUpdateStrategy};
+    use rapier::geometry::ColliderBuilder;
+
+    fn test_app() -> App {
+        let mut app = App::new();
+        app.add_plugins((
+            TransformPlugin,
+            TimePlugin,
+            RapierPhysicsPlugin::<NoUserData>::default(),
+        ))
+        .insert_resource(TimeUpdateStrategy::ManualDuration(
+            std::time::Duration::from_secs_f32(1.0 / 60.0),
+        ));
+        app.finish();
+        app
+    }
+
+    fn with_collider<R>(
+        app: &mut App,
+        entity: Entity,
+        f: impl FnOnce(&RapierContextColliders, &rapier::geometry::Collider) -> R,
+    ) -> R {
+        let world = app.world_mut();
+        let set = world
+            .query::<&RapierContextColliders>()
+            .single(world)
+            .unwrap();
+        let co = set.colliders.get(set.entity2collider()[&entity]).unwrap();
+        f(set, co)
+    }
+
+    #[test]
+    fn collider_components_are_reset_on_removal() {
+        let mut app = test_app();
+        app.update();
+
+        let entity = app
+            .world_mut()
+            .spawn((
+                Transform::default(),
+                Collider::ball(0.5),
+                Friction {
+                    coefficient: 1.0,
+                    combine_rule: CoefficientCombineRule::GeometricMean,
+                },
+                Restitution {
+                    coefficient: 0.8,
+                    combine_rule: CoefficientCombineRule::ClampedSum,
+                },
+                ContactSkin(0.1),
+                CollisionGroups::new(Group::GROUP_2, Group::GROUP_3)
+                    .with_test_mode(InteractionTestMode::Or),
+                SolverGroups::new(Group::GROUP_4, Group::GROUP_5),
+                (
+                    ActiveEvents::all(),
+                    ActiveHooks::all(),
+                    ActiveCollisionTypes::all(),
+                    ContactForceEventThreshold(10.0),
+                    ColliderMassProperties::Density(3.0),
+                ),
+            ))
+            .id();
+        app.update();
+
+        with_collider(&mut app, entity, |_, co| {
+            assert_eq!(co.friction(), 1.0);
+            assert_eq!(
+                co.friction_combine_rule(),
+                rapier::dynamics::CoefficientCombineRule::GeometricMean
+            );
+            assert_eq!(co.density(), 3.0);
+            assert_eq!(
+                co.collision_groups().test_mode,
+                rapier::geometry::InteractionTestMode::Or
+            );
+        });
+
+        app.world_mut().entity_mut(entity).remove::<(
+            Friction,
+            Restitution,
+            ContactSkin,
+            CollisionGroups,
+            SolverGroups,
+            ActiveEvents,
+            ActiveHooks,
+            ActiveCollisionTypes,
+            ContactForceEventThreshold,
+            ColliderMassProperties,
+        )>();
+        app.update();
+
+        let defaults = ColliderBuilder::default();
+        with_collider(&mut app, entity, |_, co| {
+            assert_eq!(co.friction(), defaults.friction);
+            assert_eq!(co.friction_combine_rule(), defaults.friction_combine_rule);
+            assert_eq!(co.restitution(), defaults.restitution);
+            assert_eq!(
+                co.restitution_combine_rule(),
+                defaults.restitution_combine_rule
+            );
+            assert_eq!(co.contact_skin(), defaults.contact_skin);
+            assert_eq!(co.collision_groups(), defaults.collision_groups);
+            assert_eq!(co.solver_groups(), defaults.solver_groups);
+            assert_eq!(co.active_events(), defaults.active_events);
+            assert_eq!(co.active_hooks(), defaults.active_hooks);
+            assert_eq!(co.active_collision_types(), defaults.active_collision_types);
+            assert_eq!(
+                co.contact_force_event_threshold(),
+                defaults.contact_force_event_threshold
+            );
+            assert_eq!(co.density(), ColliderBuilder::default_density());
+        });
+    }
+
+    #[test]
+    fn collider_mass_properties_are_read_back() {
+        let mut app = test_app();
+        app.update();
+
+        let entity = app
+            .world_mut()
+            .spawn((
+                Transform::default(),
+                RigidBody::Dynamic,
+                GravityScale(0.0),
+                Collider::ball(0.5),
+                ColliderMassProperties::Density(2.0),
+                ReadColliderMassProperties::default(),
+            ))
+            .id();
+        app.update();
+
+        #[cfg(feature = "dim2")]
+        let volume = |r: f32| std::f32::consts::PI * r * r;
+        #[cfg(feature = "dim3")]
+        let volume = |r: f32| 4.0 / 3.0 * std::f32::consts::PI * r * r * r;
+
+        let props = *app
+            .world()
+            .get::<ReadColliderMassProperties>(entity)
+            .unwrap();
+        approx::assert_relative_eq!(props.volume, volume(0.5), epsilon = 1.0e-5);
+        assert_eq!(props.density, 2.0);
+        approx::assert_relative_eq!(props.mass, 2.0 * volume(0.5), epsilon = 1.0e-5);
+        assert_eq!(props.local_mass_properties.mass, props.mass);
+
+        with_collider(&mut app, entity, |set, _| {
+            assert_eq!(set.volume(entity), Some(props.volume));
+            assert_eq!(set.mass(entity), Some(props.mass));
+            assert_eq!(set.density(entity), Some(2.0));
+            assert_eq!(set.volume(Entity::PLACEHOLDER), None);
+
+            let aabb = set.compute_aabb(entity).unwrap();
+            approx::assert_relative_eq!(Vect::from(aabb.min), Vect::splat(-0.5));
+            approx::assert_relative_eq!(Vect::from(aabb.max), Vect::splat(0.5));
+
+            let swept = set
+                .compute_swept_aabb(entity, Transform::from_xyz(2.0, 0.0, 0.0))
+                .unwrap();
+            approx::assert_relative_eq!(Vect::from(swept.min), Vect::splat(-0.5));
+            approx::assert_relative_eq!(swept.max.x, 2.5);
+        });
+
+        // Shape changes are read back.
+        app.world_mut()
+            .entity_mut(entity)
+            .insert(Collider::ball(1.0));
+        app.update();
+        let props = *app
+            .world()
+            .get::<ReadColliderMassProperties>(entity)
+            .unwrap();
+        approx::assert_relative_eq!(props.volume, volume(1.0), epsilon = 1.0e-5);
+        approx::assert_relative_eq!(props.mass, 2.0 * volume(1.0), epsilon = 1.0e-5);
+
+        // Mass-properties changes are read back.
+        app.world_mut()
+            .entity_mut(entity)
+            .insert(ColliderMassProperties::Mass(5.0));
+        app.update();
+        let props = *app
+            .world()
+            .get::<ReadColliderMassProperties>(entity)
+            .unwrap();
+        assert_eq!(props.mass, 5.0);
+        approx::assert_relative_eq!(props.density, 5.0 / volume(1.0), epsilon = 1.0e-5);
+
+        // Removing the custom mass-properties falls back to the default density.
+        app.world_mut()
+            .entity_mut(entity)
+            .remove::<ColliderMassProperties>();
+        app.update();
+        let props = *app
+            .world()
+            .get::<ReadColliderMassProperties>(entity)
+            .unwrap();
+        assert_eq!(props.density, 1.0);
+        approx::assert_relative_eq!(props.mass, volume(1.0), epsilon = 1.0e-5);
+
+        // The rigid-body mass accounts for the reset collider mass.
+        let world = app.world_mut();
+        let set = world.query::<&RapierRigidBodySet>().single(world).unwrap();
+        approx::assert_relative_eq!(set.mass(entity).unwrap(), volume(1.0), epsilon = 1.0e-5);
+    }
+
+    #[test]
+    fn collision_groups_or_mode_enables_contacts() {
+        let mut app = test_app();
+        app.update();
+
+        // The membership of `b` matches the filter of `a`, but not the other way around.
+        let groups_a = CollisionGroups::new(Group::GROUP_1, Group::GROUP_2);
+        let groups_b = CollisionGroups::new(Group::GROUP_2, Group::GROUP_3);
+
+        let mut spawn_pair = |x: f32, mode: InteractionTestMode| {
+            let a = app
+                .world_mut()
+                .spawn((
+                    Transform::from_xyz(x, 0.0, 0.0),
+                    RigidBody::Dynamic,
+                    GravityScale(0.0),
+                    Collider::ball(0.5),
+                    groups_a.with_test_mode(mode),
+                ))
+                .id();
+            let b = app
+                .world_mut()
+                .spawn((
+                    Transform::from_xyz(x + 0.5, 0.0, 0.0),
+                    Collider::ball(0.5),
+                    groups_b.with_test_mode(mode),
+                ))
+                .id();
+            (a, b)
+        };
+        let and_pair = spawn_pair(0.0, InteractionTestMode::And);
+        let or_pair = spawn_pair(10.0, InteractionTestMode::Or);
+
+        app.update();
+        app.update();
+
+        let world = app.world_mut();
+        let (simulation, colliders, bodies) = world
+            .query::<(
+                &RapierContextSimulation,
+                &RapierContextColliders,
+                &RapierRigidBodySet,
+            )>()
+            .single(world)
+            .unwrap();
+        let in_contact = |(a, b): (Entity, Entity)| {
+            simulation
+                .contact_pair(colliders, bodies, a, b)
+                .is_some_and(|pair| pair.has_any_active_contact())
+        };
+        assert!(!in_contact(and_pair));
+        assert!(in_contact(or_pair));
+    }
+
+    #[test]
+    fn query_filter_groups_honor_test_mode() {
+        let mut app = test_app();
+        app.update();
+
+        let groups = CollisionGroups::new(Group::GROUP_1, Group::GROUP_2)
+            .with_test_mode(InteractionTestMode::Or);
+        let entity = app
+            .world_mut()
+            .spawn((Transform::default(), Collider::ball(0.5), groups))
+            .id();
+        app.update();
+        app.update();
+
+        let query_groups = CollisionGroups::new(Group::GROUP_2, Group::GROUP_3);
+        let hit = |mode: InteractionTestMode| {
+            move |context: ReadRapierContext| {
+                let context = context.single().unwrap();
+                let filter = QueryFilter::new().groups(query_groups.with_test_mode(mode));
+                let mut hits = vec![];
+                context.intersect_point(Vect::ZERO, filter, |e, _| {
+                    hits.push(e);
+                    true
+                });
+                hits
+            }
+        };
+
+        let and_hits = app
+            .world_mut()
+            .run_system_once(hit(InteractionTestMode::And))
+            .unwrap();
+        assert!(and_hits.is_empty());
+        let or_hits = app
+            .world_mut()
+            .run_system_once(hit(InteractionTestMode::Or))
+            .unwrap();
+        assert_eq!(or_hits, vec![entity]);
+    }
+}
diff --git a/bindings/bevy_rapier/src/plugin/systems/joint.rs b/bindings/bevy_rapier/src/plugin/systems/joint.rs
new file mode 100644
index 000000000..35e146506
--- /dev/null
+++ b/bindings/bevy_rapier/src/plugin/systems/joint.rs
@@ -0,0 +1,1595 @@
+use crate::dynamics::free_joint_dofs;
+use crate::dynamics::ImpulseJoint;
+use crate::dynamics::ImpulseJointDisabled;
+use crate::dynamics::ImpulseJointImpulses;
+use crate::dynamics::KinematicMultibodyJoint;
+use crate::dynamics::MultibodyJoint;
+use crate::dynamics::MultibodyJointArmature;
+use crate::dynamics::MultibodyJointCoupling;
+use crate::dynamics::MultibodyJointCouplings;
+use crate::dynamics::MultibodyJointDamping;
+use crate::dynamics::MultibodyJointFriction;
+use crate::dynamics::MultibodyJointSprings;
+use crate::dynamics::MultibodyJointState;
+use crate::dynamics::MultibodySelfContactsDisabled;
+use crate::dynamics::RapierImpulseJointHandle;
+use crate::dynamics::RapierMultibodyJointHandle;
+use crate::plugin::context::systemparams::RAPIER_CONTEXT_EXPECT_ERROR;
+use crate::plugin::context::RapierContextEntityLink;
+use crate::plugin::context::RapierContextJoints;
+use crate::plugin::context::RapierRigidBodySet;
+use bevy::platform::collections::HashSet;
+use bevy::prelude::*;
+
+use super::RapierContextLinkResolver;
+use rapier::dynamics::{
+    GenericJoint as RapierGenericJoint, ImpulseJointHandle, ImpulseJointSet, JointEnabled,
+    Multibody, MultibodyDofCoupling, MultibodyJointHandle, MultibodyJointSet, RigidBodyHandle,
+    RigidBodySet,
+};
+use rapier::math::SPATIAL_DIM;
+
+/// Finds the rigid-body an [`ImpulseJoint`] of `entity` is attached to: the one of `entity`
+/// itself, or of its closest ancestor with a rigid-body.
+fn impulse_joint_target_body(
+    rigidbody_set: &RapierRigidBodySet,
+    child_of_query: &Query<&ChildOf>,
+    entity: Entity,
+) -> Option<RigidBodyHandle> {
+    let mut body_entity = entity;
+    loop {
+        if let Some(handle) = rigidbody_set.entity2body.get(&body_entity) {
+            return Some(*handle);
+        }
+        body_entity = child_of_query.get(body_entity).ok()?.parent();
+    }
+}
+
+/// Converts the joint description of an [`ImpulseJoint`] component into the Rapier joint data.
+fn impulse_joint_data(entity: Entity, joint: &ImpulseJoint, disabled: bool) -> RapierGenericJoint {
+    let mut data = joint.data.as_ref().into_rapier();
+    data.user_data = entity.to_bits() as u128;
+    if disabled {
+        data.set_enabled(false);
+    }
+    data
+}
+
+/// Converts the joint description of a [`MultibodyJoint`] component into the Rapier joint data.
+fn multibody_joint_data(entity: Entity, joint: &MultibodyJoint) -> RapierGenericJoint {
+    let mut data = joint.data.as_ref().into_rapier();
+    data.user_data = entity.to_bits() as u128;
+    data
+}
+
+/// Inserts a (possibly kinematic) multibody joint between two rigid-bodies.
+fn insert_multibody_joint(
+    joints: &mut MultibodyJointSet,
+    body1: RigidBodyHandle,
+    body2: RigidBodyHandle,
+    data: RapierGenericJoint,
+    kinematic: bool,
+) -> Option<MultibodyJointHandle> {
+    if kinematic {
+        joints.insert_kinematic(body1, body2, data, true)
+    } else {
+        joints.insert(body1, body2, data, true)
+    }
+}
+
+/// Writes the per-joint properties of a multibody joint, using the default values for the
+/// missing components.
+fn write_multibody_joint_properties(
+    mb: &mut Multibody,
+    link_id: usize,
+    kinematic: bool,
+    damping: Option<&MultibodyJointDamping>,
+    friction: Option<&MultibodyJointFriction>,
+    armature: Option<&MultibodyJointArmature>,
+    springs: Option<&MultibodyJointSprings>,
+) {
+    let Some(link) = mb.link(link_id) else {
+        return;
+    };
+    let offset = link.assembly_id();
+    let locked_axes = link.joint().data.locked_axes;
+    let damping = damping.copied().unwrap_or_default();
+    let friction = friction.copied().unwrap_or_default();
+    let armature = armature.copied().unwrap_or_default();
+    let springs = springs.copied().unwrap_or_default();
+
+    for (dof, axis) in free_joint_dofs(locked_axes) {
+        mb.damping_mut()[offset + dof] = damping.0[axis];
+        mb.frictions_mut()[offset + dof] = friction.0[axis];
+        mb.armature_mut()[offset + dof] = armature.0[axis];
+    }
+
+    let Some(link) = mb.link_mut(link_id) else {
+        return;
+    };
+    link.joint.kinematic = kinematic;
+    for axis in 0..SPATIAL_DIM {
+        if locked_axes.bits() & (1 << axis) == 0 {
+            link.joint
+                .set_spring(axis, springs.stiffness[axis], springs.rest[axis]);
+        } else {
+            link.joint.set_spring(axis, 0.0, 0.0);
+        }
+    }
+}
+
+/// Converts a [`MultibodyJointCoupling`] declared on `entity` into a Rapier coupling.
+///
+/// Returns `None` if the two joints are not part of the same multibody, or if one of the coupled
+/// axes is locked.
+fn rapier_dof_coupling(
+    joints: &MultibodyJointSet,
+    rigidbody_set: &RapierRigidBodySet,
+    entity: Entity,
+    coupling: &MultibodyJointCoupling,
+) -> Option<MultibodyDofCoupling> {
+    let link_id = |entity: &Entity| {
+        let body = rigidbody_set.entity2body.get(entity)?;
+        joints.rigid_body_link(*body)
+    };
+    let link1 = link_id(&coupling.source)?;
+    let link2 = link_id(&entity)?;
+    if link1.multibody != link2.multibody {
+        return None;
+    }
+
+    let mb = joints.get_multibody(link1.multibody)?;
+    let dof = |link: usize, axis: usize| {
+        free_joint_dofs(mb.link(link)?.joint().data.locked_axes)
+            .find(|(_, free_axis)| *free_axis == axis)
+            .map(|(dof, _)| dof)
+    };
+    let (axis1, axis2) = (coupling.source_axis as usize, coupling.axis as usize);
+    Some(MultibodyDofCoupling {
+        link1: link1.id,
+        dof1: dof(link1.id, axis1)?,
+        axis1,
+        link2: link2.id,
+        dof2: dof(link2.id, axis2)?,
+        axis2,
+        coeff: coupling.coeff,
+        offset: coupling.offset,
+    })
+}
+
+/// Makes the Rapier DoF couplings of the multibody joint of `entity` match its declared
+/// `couplings`: the stale ones are removed, and the missing ones that can be resolved are added.
+fn sync_dof_couplings(
+    joints: &mut MultibodyJointSet,
+    rigidbody_set: &RapierRigidBodySet,
+    entity: Entity,
+    handle: MultibodyJointHandle,
+    couplings: Option<&MultibodyJointCouplings>,
+) {
+    let declared: Vec<_> = couplings
+        .iter()
+        .flat_map(|couplings| couplings.0.iter())
+        .filter_map(|c| rapier_dof_coupling(joints, rigidbody_set, entity, c))
+        .collect();
+    let Some((mb, link_id)) = joints.get_mut(handle) else {
+        return;
+    };
+    // The couplings driving this joint are the ones declared on its entity.
+    mb.retain_dof_couplings(|c| {
+        c.link2 != link_id || declared.iter().any(|d| same_dof_coupling(c, d))
+    });
+    for coupling in declared {
+        if !mb
+            .couplings()
+            .iter()
+            .any(|c| same_dof_coupling(c, &coupling))
+        {
+            mb.add_dof_coupling(coupling);
+        }
+    }
+}
+
+/// Wakes up all the rigid-bodies of a multibody.
+pub(crate) fn wake_up_multibody(mb: &Multibody, bodies: &mut RigidBodySet) {
+    for link in mb.links() {
+        if let Some(body) = bodies.get_mut(link.rigid_body_handle()) {
+            body.wake_up(true);
+        }
+    }
+}
+
+/// Checks if two Rapier DoF couplings are identical.
+fn same_dof_coupling(a: &MultibodyDofCoupling, b: &MultibodyDofCoupling) -> bool {
+    (a.link1, a.dof1, a.axis1, a.link2, a.dof2, a.axis2)
+        == (b.link1, b.dof1, b.axis1, b.link2, b.dof2, b.axis2)
+        && a.coeff == b.coeff
+        && a.offset == b.offset
+}
+
+/// Enables or disables an impulse joint.
+///
+/// A joint re-enabled while attached to a disabled rigid-body stays disabled until that body is
+/// enabled again. Rapier updates the islands of joints accessed through `get_mut` at the next step.
+pub(crate) fn set_impulse_joint_enabled(
+    joints: &mut ImpulseJointSet,
+    bodies: &RigidBodySet,
+    handle: ImpulseJointHandle,
+    enabled: bool,
+) {
+    let Some(joint) = joints.get_mut(handle, true) else {
+        return;
+    };
+    let body_enabled = |h| bodies.get(h).is_none_or(|rb| rb.is_enabled());
+    joint.data.enabled = if !enabled {
+        JointEnabled::Disabled
+    } else if joint.data.enabled != JointEnabled::Disabled {
+        joint.data.enabled
+    } else if body_enabled(joint.body1()) && body_enabled(joint.body2()) {
+        JointEnabled::Enabled
+    } else {
+        JointEnabled::DisabledByAttachedBody
+    };
+}
+
+/// System responsible for creating new Rapier joints from the related `bevy_rapier` components.
+pub fn init_joints(
+    mut commands: Commands,
+    mut context_access: Query<(&RapierRigidBodySet, &mut RapierContextJoints)>,
+    context_links: RapierContextLinkResolver,
+    impulse_joints: Query<
+        (
+            Entity,
+            Option<&RapierContextEntityLink>,
+            &ImpulseJoint,
+            Has<ImpulseJointDisabled>,
+        ),
+        Without<RapierImpulseJointHandle>,
+    >,
+    multibody_joints: Query<
+        (
+            Entity,
+            Option<&RapierContextEntityLink>,
+            &MultibodyJoint,
+            Has<KinematicMultibodyJoint>,
+        ),
+        Without<RapierMultibodyJointHandle>,
+    >,
+    child_of_query: Query<&ChildOf>,
+) {
+    for (entity, entity_context_link, joint, disabled) in impulse_joints.iter() {
+        // Use the RapierContextEntityLink, or insert the context of an ancestor or the default one.
+        let context_entity = context_links.resolve(entity, entity_context_link, &mut commands);
+        let Some(context_entity) = context_entity else {
+            continue;
+        };
+
+        let Ok(rigidbody_set_joints) = context_access.get_mut(context_entity) else {
+            log::error!("Could not find entity {context_entity} with rapier context while initializing {entity}");
+            continue;
+        };
+        let rigidbody_set = rigidbody_set_joints.0;
+        let target = impulse_joint_target_body(rigidbody_set, &child_of_query, entity);
+        let joints = rigidbody_set_joints.1.into_inner();
+
+        if let (Some(target), Some(source)) = (target, rigidbody_set.entity2body.get(&joint.parent))
+        {
+            let handle = joints.impulse_joints.insert(
+                *source,
+                target,
+                impulse_joint_data(entity, joint, disabled),
+                true,
+            );
+            commands
+                .entity(entity)
+                .insert(RapierImpulseJointHandle(handle));
+            joints.entity2impulse_joint.insert(entity, handle);
+        }
+    }
+
+    for (entity, entity_context_link, joint, kinematic) in multibody_joints.iter() {
+        // Use the RapierContextEntityLink, or insert the context of an ancestor or the default one.
+        let context_entity = context_links.resolve(entity, entity_context_link, &mut commands);
+        let Some(context_entity) = context_entity else {
+            continue;
+        };
+
+        let Ok(context_joints) = context_access.get_mut(context_entity) else {
+            log::error!("Could not find entity {context_entity} with rapier context while initializing {entity}");
+            continue;
+        };
+        let context = context_joints.0;
+        let target = context.entity2body.get(&entity);
+        let joints = context_joints.1.into_inner();
+
+        if let (Some(target), Some(source)) = (target, context.entity2body.get(&joint.parent)) {
+            if let Some(handle) = insert_multibody_joint(
+                &mut joints.multibody_joints,
+                *source,
+                *target,
+                multibody_joint_data(entity, joint),
+                kinematic,
+            ) {
+                commands
+                    .entity(entity)
+                    .insert(RapierMultibodyJointHandle(handle));
+                joints.entity2multibody_joint.insert(entity, handle);
+            } else {
+                log::error!("Failed to create multibody joint: loop detected.")
+            }
+        }
+    }
+}
+
+/// System responsible for applying changes the user made to a joint component.
+///
+/// This also re-attaches an [`ImpulseJoint`] to other rigid-bodies if its `parent`, or the
+/// rigid-body of its entity, changed, and a [`MultibodyJoint`] if its `parent` changed. If one of
+/// the new bodies doesn’t exist yet, the joint is removed from the physics scene until
+/// [`init_joints`] can create it again.
+#[allow(clippy::type_complexity)]
+pub fn apply_joint_user_changes(
+    mut commands: Commands,
+    mut context: Query<(&RapierRigidBodySet, &mut RapierContextJoints)>,
+    changed_impulse_joints: Query<
+        (
+            Entity,
+            &RapierContextEntityLink,
+            &RapierImpulseJointHandle,
+            &ImpulseJoint,
+            Has<ImpulseJointDisabled>,
+        ),
+        Or<(
+            Changed<ImpulseJoint>,
+            Changed<ImpulseJointDisabled>,
+            Changed<ChildOf>,
+        )>,
+    >,
+    changed_multibody_joints: Query<
+        (
+            Entity,
+            &RapierContextEntityLink,
+            &RapierMultibodyJointHandle,
+            &MultibodyJoint,
+            Has<KinematicMultibodyJoint>,
+        ),
+        Changed<MultibodyJoint>,
+    >,
+    child_of_query: Query<&ChildOf>,
+) {
+    for (entity, link, handle, changed_joint, disabled) in changed_impulse_joints.iter() {
+        let (rigidbody_set, mut context) =
+            context.get_mut(link.0).expect(RAPIER_CONTEXT_EXPECT_ERROR);
+        let joints = &mut context.impulse_joints;
+
+        let body1 = rigidbody_set
+            .entity2body
+            .get(&changed_joint.parent)
+            .copied();
+        let body2 = impulse_joint_target_body(rigidbody_set, &child_of_query, entity);
+        let (Some(body1), Some(body2), true) = (body1, body2, joints.contains(handle.0)) else {
+            // Detach the joint until its bodies exist; `init_joints` will then re-create it.
+            joints.remove(handle.0, true);
+            context.entity2impulse_joint.remove(&entity);
+            commands.entity(entity).remove::<RapierImpulseJointHandle>();
+            continue;
+        };
+
+        let Some(joint) = joints.set_bodies(handle.0, body1, body2, true) else {
+            continue;
+        };
+
+        // Keep the solver’s warmstart impulses and let `set_impulse_joint_enabled` handle the
+        // enabled state, since Rapier may have disabled the joint because of its bodies.
+        let old_data = joint.data;
+        let mut new_data = impulse_joint_data(entity, changed_joint, false);
+        new_data.enabled = old_data.enabled;
+        for (new_limit, old_limit) in new_data.limits.iter_mut().zip(old_data.limits.iter()) {
+            new_limit.impulse = old_limit.impulse;
+        }
+        for (new_motor, old_motor) in new_data.motors.iter_mut().zip(old_data.motors.iter()) {
+            new_motor.impulse = old_motor.impulse;
+        }
+        joint.data = new_data;
+
+        let enabled = changed_joint.data.as_ref().is_enabled() && !disabled;
+        set_impulse_joint_enabled(joints, &rigidbody_set.bodies, handle.0, enabled);
+    }
+
+    for (entity, link, handle, changed_joint, kinematic) in changed_multibody_joints.iter() {
+        let (rigidbody_set, mut context) =
+            context.get_mut(link.0).expect(RAPIER_CONTEXT_EXPECT_ERROR);
+        let context = &mut *context;
+        let data = multibody_joint_data(entity, changed_joint);
+        let new_parent = rigidbody_set
+            .entity2body
+            .get(&changed_joint.parent)
+            .copied();
+
+        let Some((mb, link_id)) = context.multibody_joints.get_mut(handle.0) else {
+            continue;
+        };
+        let Some(mb_link) = mb.link(link_id) else {
+            continue;
+        };
+        let body = mb_link.rigid_body_handle();
+        let old_parent = mb_link
+            .parent_id()
+            .and_then(|id| mb.link(id))
+            .map(|parent| parent.rigid_body_handle());
+
+        if old_parent.is_some() && old_parent == new_parent {
+            // TODO: not sure this will always work properly, e.g., if the number of Dofs is changed.
+            if let Some(mb_link) = mb.link_mut(link_id) {
+                mb_link.joint.data = data;
+            }
+            continue;
+        }
+
+        // The parent changed: re-attach the joint to the new parent.
+        context.multibody_joints.remove(handle.0, true);
+        let new_handle = new_parent.and_then(|parent| {
+            insert_multibody_joint(&mut context.multibody_joints, parent, body, data, kinematic)
+        });
+        if let Some(new_handle) = new_handle {
+            context.entity2multibody_joint.insert(entity, new_handle);
+            // Insert the handle even if unchanged: this flags the multibody topology change.
+            commands
+                .entity(entity)
+                .insert(RapierMultibodyJointHandle(new_handle));
+        } else {
+            if new_parent.is_some() {
+                log::error!("Failed to re-attach multibody joint: loop detected.");
+            }
+            // Detach the joint; `init_joints` will then try to re-create it.
+            context.entity2multibody_joint.remove(&entity);
+            commands
+                .entity(entity)
+                .remove::<RapierMultibodyJointHandle>();
+        }
+    }
+}
+
+/// Components configuring a multibody joint, read by [`apply_multibody_joint_properties`].
+type MultibodyJointPropertiesComponents = (
+    &'static RapierContextEntityLink,
+    &'static RapierMultibodyJointHandle,
+    Has<KinematicMultibodyJoint>,
+    Option<&'static MultibodyJointDamping>,
+    Option<&'static MultibodyJointFriction>,
+    Option<&'static MultibodyJointArmature>,
+    Option<&'static MultibodyJointSprings>,
+    Option<&'static MultibodyJointCouplings>,
+);
+
+/// Filter selecting the multibody joints with modified properties.
+type ChangedMultibodyJointProperties = Or<(
+    Added<RapierMultibodyJointHandle>,
+    Changed<MultibodyJoint>,
+    Changed<KinematicMultibodyJoint>,
+    Changed<MultibodyJointDamping>,
+    Changed<MultibodyJointFriction>,
+    Changed<MultibodyJointArmature>,
+    Changed<MultibodyJointSprings>,
+    Changed<MultibodyJointCouplings>,
+)>;
+
+/// System responsible for applying the properties of multibody joints and multibodies set by the
+/// user through the [`KinematicMultibodyJoint`], [`MultibodyJointDamping`],
+/// [`MultibodyJointFriction`], [`MultibodyJointArmature`], [`MultibodyJointSprings`],
+/// [`MultibodyJointCouplings`] and [`MultibodySelfContactsDisabled`] components.
+///
+/// The properties are applied when the joint is created, and when these components are modified
+/// or removed. DoF couplings and disabled self-contacts are also applied again when a multibody
+/// joint is created or re-attached, since they might only be resolvable once joints are merged
+/// into the same multibody.
+#[allow(clippy::type_complexity)]
+pub fn apply_multibody_joint_properties(
+    mut context: Query<(&mut RapierRigidBodySet, &mut RapierContextJoints)>,
+    changed_joints: Query<Entity, (With<MultibodyJoint>, ChangedMultibodyJointProperties)>,
+    changed_couplings: Query<Entity, Changed<MultibodyJointCouplings>>,
+    changed_topology: Query<
+        &RapierContextEntityLink,
+        (With<MultibodyJoint>, Changed<RapierMultibodyJointHandle>),
+    >,
+    joints: Query<MultibodyJointPropertiesComponents, With<MultibodyJoint>>,
+    all_couplings: Query<(
+        Entity,
+        &RapierContextEntityLink,
+        &RapierMultibodyJointHandle,
+        &MultibodyJointCouplings,
+    )>,
+    self_contacts_disabled: Query<(
+        Entity,
+        &RapierContextEntityLink,
+        Ref<MultibodySelfContactsDisabled>,
+    )>,
+    (
+        mut removed_kinematic,
+        mut removed_damping,
+        mut removed_friction,
+        mut removed_armature,
+        mut removed_springs,
+        mut removed_couplings,
+    ): (
+        RemovedComponents<KinematicMultibodyJoint>,
+        RemovedComponents<MultibodyJointDamping>,
+        RemovedComponents<MultibodyJointFriction>,
+        RemovedComponents<MultibodyJointArmature>,
+        RemovedComponents<MultibodyJointSprings>,
+        RemovedComponents<MultibodyJointCouplings>,
+    ),
+    mut removed_self_contacts_disabled: RemovedComponents<MultibodySelfContactsDisabled>,
+) {
+    let mut couplings_modified: HashSet<Entity> = changed_couplings.iter().collect();
+    couplings_modified.extend(removed_couplings.read());
+    let mut modified: HashSet<Entity> = changed_joints.iter().collect();
+    modified.extend(couplings_modified.iter().copied());
+    modified.extend(removed_kinematic.read());
+    modified.extend(removed_damping.read());
+    modified.extend(removed_friction.read());
+    modified.extend(removed_armature.read());
+    modified.extend(removed_springs.read());
+    // The contexts where multibody joints were created or re-attached.
+    let topology_changed: HashSet<Entity> = changed_topology.iter().map(|link| link.0).collect();
+
+    for entity in modified {
+        let Ok((link, handle, kinematic, damping, friction, armature, springs, couplings)) =
+            joints.get(entity)
+        else {
+            continue;
+        };
+        let Ok((mut rigidbody_set, mut context)) = context.get_mut(link.0) else {
+            continue;
+        };
+        let (rigidbody_set, context) = (&mut *rigidbody_set, &mut *context);
+
+        if couplings_modified.contains(&entity) {
+            sync_dof_couplings(
+                &mut context.multibody_joints,
+                rigidbody_set,
+                entity,
+                handle.0,
+                couplings,
+            );
+        }
+
+        if let Some((mb, link_id)) = context.multibody_joints.get_mut(handle.0) {
+            write_multibody_joint_properties(
+                mb, link_id, kinematic, damping, friction, armature, springs,
+            );
+            wake_up_multibody(mb, &mut rigidbody_set.bodies);
+        }
+    }
+
+    // Rapier keeps the couplings across topology changes, but the ones that couldn't be resolved
+    // yet (e.g. joints in different multibodies) might be now.
+    for (entity, link, handle, couplings) in all_couplings.iter() {
+        if !topology_changed.contains(&link.0) {
+            continue;
+        }
+        let Ok((rigidbody_set, mut context)) = context.get_mut(link.0) else {
+            continue;
+        };
+        sync_dof_couplings(
+            &mut context.multibody_joints,
+            &rigidbody_set,
+            entity,
+            handle.0,
+            Some(couplings),
+        );
+    }
+
+    // Enable self-contacts again when the marker is removed. If another link still has the
+    // marker, the multibody is disabled again right after.
+    let mut any_marker_removed = false;
+    for entity in removed_self_contacts_disabled.read() {
+        if !self_contacts_disabled.contains(entity) {
+            set_multibody_self_contacts(&mut context, entity, true);
+            any_marker_removed = true;
+        }
+    }
+    // Rapier keeps self-contacts disabled when multibodies merge, but a marker added before its
+    // rigid-body joined a multibody has to be applied once it does.
+    for (entity, link, marker) in self_contacts_disabled.iter() {
+        if any_marker_removed || marker.is_changed() || topology_changed.contains(&link.0) {
+            set_multibody_self_contacts(&mut context, entity, false);
+        }
+    }
+}
+
+/// System responsible for writing the impulses applied by impulse joints back into the
+/// [`ImpulseJointImpulses`] component.
+pub fn writeback_impulse_joint_impulses(
+    context: Query<&RapierContextJoints>,
+    mut impulse_joints: Query<(
+        &RapierContextEntityLink,
+        &RapierImpulseJointHandle,
+        &mut ImpulseJointImpulses,
+    )>,
+) {
+    for (link, handle, mut impulses) in impulse_joints.iter_mut() {
+        let Some(joint) = context
+            .get(link.0)
+            .ok()
+            .and_then(|joints| joints.impulse_joints.get(handle.0))
+        else {
+            continue;
+        };
+
+        // A disabled joint isn't solved, so its last impulses are stale.
+        let new_impulses = if joint.data.is_enabled() {
+            ImpulseJointImpulses::from_rapier(joint)
+        } else {
+            ImpulseJointImpulses::default()
+        };
+        // NOTE: only write actual changes to avoid triggering bevy's change detection.
+        impulses.set_if_neq(new_impulses);
+    }
+}
+
+/// Enables or disables the self-contacts of the multibody containing the rigid-body of `entity`.
+fn set_multibody_self_contacts(
+    contexts: &mut Query<(&mut RapierRigidBodySet, &mut RapierContextJoints)>,
+    entity: Entity,
+    enabled: bool,
+) {
+    for (rigidbody_set, mut context) in contexts.iter_mut() {
+        let Some(body) = rigidbody_set.entity2body.get(&entity) else {
+            continue;
+        };
+        let Some(link) = context.multibody_joints.rigid_body_link(*body).copied() else {
+            return;
+        };
+        let needs_change = context
+            .multibody_joints
+            .get_multibody(link.multibody)
+            .is_some_and(|mb| mb.self_contacts_enabled() != enabled);
+        if needs_change {
+            if let Some(mb) = context.multibody_joints.get_multibody_mut(link.multibody) {
+                mb.set_self_contacts_enabled(enabled);
+            }
+        }
+        return;
+    }
+}
+
+/// System responsible for writing the state of multibody joints back into the
+/// [`MultibodyJointState`] component.
+pub fn writeback_multibody_joint_states(
+    context: Query<&RapierContextJoints>,
+    mut multibody_joints: Query<(
+        &RapierContextEntityLink,
+        &RapierMultibodyJointHandle,
+        &mut MultibodyJointState,
+    )>,
+) {
+    for (link, handle, mut state) in multibody_joints.iter_mut() {
+        let Some(new_state) = context
+            .get(link.0)
+            .ok()
+            .and_then(|joints| joints.multibody_joint_state_from_handle(handle.0))
+        else {
+            continue;
+        };
+        // NOTE: only write actual changes to avoid triggering bevy's change detection.
+        state.set_if_neq(new_state);
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+    use crate::prelude::*;
+    use bevy::time::{TimePlugin, TimeUpdateStrategy};
+
+    fn test_app() -> App {
+        let mut app = App::new();
+        app.add_plugins((
+            TransformPlugin,
+            TimePlugin,
+            RapierPhysicsPlugin::<NoUserData>::default(),
+        ))
+        .insert_resource(TimeUpdateStrategy::ManualDuration(
+            std::time::Duration::from_secs_f32(1.0 / 60.0),
+        ));
+        app.finish();
+        app.update();
+        app
+    }
+
+    fn run(app: &mut App, frames: usize) {
+        for _ in 0..frames {
+            app.update();
+        }
+    }
+
+    fn spawn_body(app: &mut App, body: RigidBody, x: f32, y: f32) -> Entity {
+        app.world_mut()
+            .spawn((Transform::from_xyz(x, y, 0.0), body, Collider::ball(0.1)))
+            .id()
+    }
+
+    fn translation(app: &App, entity: Entity) -> Vec3 {
+        app.world().get::<Transform>(entity).unwrap().translation
+    }
+
+    fn with_joints<R>(
+        app: &mut App,
+        f: impl FnOnce(&RapierRigidBodySet, &RapierContextJoints) -> R,
+    ) -> R {
+        let world = app.world_mut();
+        let (bodies, joints) = world
+            .query::<(&RapierRigidBodySet, &RapierContextJoints)>()
+            .single(world)
+            .unwrap();
+        f(bodies, joints)
+    }
+
+    fn raw_joint<R>(
+        app: &mut App,
+        entity: Entity,
+        f: impl FnOnce(&RapierRigidBodySet, &rapier::dynamics::ImpulseJoint) -> R,
+    ) -> R {
+        with_joints(app, |bodies, joints| {
+            let handle = joints.entity2impulse_joint()[&entity];
+            f(bodies, joints.impulse_joints.get(handle).unwrap())
+        })
+    }
+
+    #[cfg(feature = "dim2")]
+    #[test]
+    fn pin_slot_joint_constrains_motion() {
+        let mut app = test_app();
+        let ground = spawn_body(&mut app, RigidBody::Fixed, 0.0, 0.0);
+        let body = spawn_body(&mut app, RigidBody::Dynamic, 0.0, 0.0);
+        app.world_mut().entity_mut(body).insert((
+            Velocity {
+                linear: Vect::new(1.0, 0.0),
+                angular: 2.0,
+            },
+            ImpulseJoint::new(
+                ground,
+                PinSlotJointBuilder::new(Vect::X).contacts_enabled(false),
+            ),
+        ));
+        run(&mut app, 60);
+
+        let pos = translation(&app, body);
+        assert!(pos.x > 0.5, "the body should slide along the slot: {pos}");
+        assert!(pos.y.abs() < 1.0e-2, "the body should not fall: {pos}");
+        let angvel = app.world().get::<Velocity>(body).unwrap().angular;
+        assert!(angvel.abs() > 1.0, "rotations should be free: {angvel}");
+
+        let joint = app.world().get::<ImpulseJoint>(body).unwrap();
+        assert!(matches!(joint.data, TypedJoint::PinSlotJoint(_)));
+        assert!(joint.data.as_ref().as_pin_slot().is_some());
+        assert!(joint.data.as_ref().as_prismatic().is_none());
+    }
+
+    #[test]
+    fn disabled_impulse_joint_lets_bodies_separate() {
+        let mut app = test_app();
+        let ground = spawn_body(&mut app, RigidBody::Fixed, 0.0, 0.0);
+        let body = spawn_body(&mut app, RigidBody::Dynamic, 0.0, 0.0);
+        let joint = FixedJointBuilder::new().contacts_enabled(false);
+        app.world_mut()
+            .entity_mut(body)
+            .insert((ImpulseJoint::new(ground, joint), ImpulseJointDisabled));
+        run(&mut app, 30);
+
+        assert!(translation(&app, body).y < -0.5, "the body should fall");
+        raw_joint(&mut app, body, |_, j| assert!(!j.data.is_enabled()));
+        with_joints(&mut app, |bodies, joints| {
+            assert_eq!(joints.attached_impulse_joints(bodies, ground).count(), 1);
+            assert_eq!(
+                joints
+                    .attached_enabled_impulse_joints(bodies, ground)
+                    .count(),
+                0
+            );
+        });
+        assert_eq!(
+            *app.world().get::<ImpulseJointImpulses>(body).unwrap(),
+            ImpulseJointImpulses::default()
+        );
+
+        app.world_mut()
+            .entity_mut(body)
+            .remove::<ImpulseJointDisabled>();
+        run(&mut app, 120);
+
+        raw_joint(&mut app, body, |_, j| assert!(j.data.is_enabled()));
+        let pos = translation(&app, body);
+        assert!(
+            pos.length() < 0.1,
+            "the joint should pull the body back: {pos}"
+        );
+
+        app.world_mut()
+            .entity_mut(body)
+            .insert(ImpulseJointDisabled);
+        run(&mut app, 30);
+        raw_joint(&mut app, body, |_, j| assert!(!j.data.is_enabled()));
+        assert!(
+            translation(&app, body).y < -0.5,
+            "the body should fall again"
+        );
+    }
+
+    #[test]
+    fn disabled_impulse_joint_splits_islands() {
+        let mut app = test_app();
+        let body1 = spawn_body(&mut app, RigidBody::Dynamic, 0.0, 0.0);
+        let body2 = spawn_body(&mut app, RigidBody::Dynamic, 2.0, 0.0);
+        app.world_mut()
+            .entity_mut(body1)
+            .insert((GravityScale(0.0), Sleeping::default()));
+        app.world_mut().entity_mut(body2).insert((
+            GravityScale(0.0),
+            Sleeping::default(),
+            ImpulseJoint::new(body1, FixedJointBuilder::new().local_anchor1(Vect::X * 2.0)),
+        ));
+        run(&mut app, 2);
+
+        // With the joint disabled, the resting body falls asleep while the other keeps moving.
+        app.world_mut()
+            .entity_mut(body2)
+            .insert((ImpulseJointDisabled, Velocity::linear(Vect::X)));
+        run(&mut app, 240);
+        let sleeping = |app: &App, entity| app.world().get::<Sleeping>(entity).unwrap().sleeping;
+        assert!(sleeping(&app, body1));
+        assert!(!sleeping(&app, body2));
+
+        // Re-enabling the joint merges the islands again, waking the resting body up.
+        app.world_mut()
+            .entity_mut(body2)
+            .remove::<ImpulseJointDisabled>();
+        run(&mut app, 2);
+        assert!(!sleeping(&app, body1));
+    }
+
+    #[test]
+    fn impulses_are_written_back() {
+        let mut app = test_app();
+        let ground = spawn_body(&mut app, RigidBody::Fixed, 0.0, 0.0);
+        let body = spawn_body(&mut app, RigidBody::Dynamic, 1.0, 0.0);
+        app.world_mut().entity_mut(body).insert((
+            AdditionalMassProperties::Mass(10.0),
+            ImpulseJoint::new(
+                ground,
+                FixedJointBuilder::new()
+                    .local_anchor1(Vect::X)
+                    .contacts_enabled(false),
+            ),
+        ));
+        run(&mut app, 10);
+
+        let impulses = *app.world().get::<ImpulseJointImpulses>(body).unwrap();
+        assert!(
+            impulses.linear.length() > 1.0e-2,
+            "the joint should hold the body against gravity: {impulses:?}"
+        );
+        let from_context = with_joints(&mut app, |_, joints| {
+            joints.impulse_joint_impulses(body).unwrap()
+        });
+        assert_eq!(impulses, from_context);
+    }
+
+    #[test]
+    fn reparenting_moves_the_joint() {
+        let mut app = test_app();
+        let ground1 = spawn_body(&mut app, RigidBody::Fixed, 0.0, 0.0);
+        let ground2 = spawn_body(&mut app, RigidBody::Fixed, 5.0, 0.0);
+        let body = spawn_body(&mut app, RigidBody::Dynamic, 0.0, -1.0);
+        app.world_mut().entity_mut(body).insert(ImpulseJoint::new(
+            ground1,
+            FixedJointBuilder::new().local_anchor1(-Vect::Y),
+        ));
+        run(&mut app, 2);
+
+        let handle = app.world().get::<RapierImpulseJointHandle>(body).unwrap().0;
+        with_joints(&mut app, |bodies, joints| {
+            let between: Vec<_> = joints
+                .impulse_joints_between(bodies, ground1, body)
+                .collect();
+            assert_eq!(between, vec![body]);
+            let between: Vec<_> = joints
+                .impulse_joints_between(bodies, body, ground1)
+                .collect();
+            assert_eq!(between, vec![body]);
+            assert_eq!(
+                joints.impulse_joints_between(bodies, ground2, body).count(),
+                0
+            );
+            assert_eq!(joints.impulse_joint_entity(handle), Some(body));
+        });
+
+        app.world_mut()
+            .get_mut::<ImpulseJoint>(body)
+            .unwrap()
+            .parent = ground2;
+        run(&mut app, 120);
+
+        assert_eq!(
+            app.world().get::<RapierImpulseJointHandle>(body).unwrap().0,
+            handle
+        );
+        with_joints(&mut app, |bodies, joints| {
+            assert_eq!(
+                joints.impulse_joints_between(bodies, ground1, body).count(),
+                0
+            );
+            let between: Vec<_> = joints
+                .impulse_joints_between(bodies, ground2, body)
+                .collect();
+            assert_eq!(between, vec![body]);
+            let raw = joints.impulse_joints.get(handle).unwrap();
+            assert_eq!(raw.body1(), bodies.entity2body()[&ground2]);
+        });
+        let pos = translation(&app, body);
+        assert!((pos.x - 5.0).abs() < 0.1, "the body should follow: {pos}");
+
+        // Re-parenting to an entity without rigid-body detaches the joint until it gets one.
+        let pending = app
+            .world_mut()
+            .spawn(Transform::from_xyz(-5.0, 0.0, 0.0))
+            .id();
+        app.world_mut()
+            .get_mut::<ImpulseJoint>(body)
+            .unwrap()
+            .parent = pending;
+        run(&mut app, 2);
+        assert!(app.world().get::<RapierImpulseJointHandle>(body).is_none());
+        with_joints(&mut app, |_, joints| {
+            assert!(joints.impulse_joints.is_empty())
+        });
+
+        app.world_mut().entity_mut(pending).insert(RigidBody::Fixed);
+        run(&mut app, 2);
+        raw_joint(&mut app, body, |bodies, raw| {
+            assert_eq!(raw.body1(), bodies.entity2body()[&pending]);
+        });
+    }
+
+    #[test]
+    fn softness_round_trip() {
+        let softness = SpringCoefficients::new(10.0, 0.5);
+        let mut joint = PrismaticJointBuilder::new(Vect::X)
+            .softness(softness)
+            .build();
+        assert_eq!(joint.softness(), softness);
+        let other = SpringCoefficients::new(20.0, 1.0);
+        joint.set_softness(other);
+        assert_eq!(joint.softness(), other);
+        assert_eq!(joint.data.softness(), other);
+        assert_eq!(
+            GenericJointBuilder::new(JointAxesMask::LOCKED_FIXED_AXES)
+                .softness(softness)
+                .build()
+                .softness(),
+            softness
+        );
+
+        let mut app = test_app();
+        let ground = spawn_body(&mut app, RigidBody::Fixed, 0.0, 0.0);
+        let body = spawn_body(&mut app, RigidBody::Dynamic, 0.0, 0.0);
+        app.world_mut()
+            .entity_mut(body)
+            .insert(ImpulseJoint::new(ground, joint));
+        run(&mut app, 1);
+        raw_joint(&mut app, body, |_, j| assert_eq!(j.data.softness, other));
+
+        app.world_mut()
+            .get_mut::<ImpulseJoint>(body)
+            .unwrap()
+            .data
+            .as_mut()
+            .set_softness(softness);
+        run(&mut app, 1);
+        raw_joint(&mut app, body, |_, j| assert_eq!(j.data.softness, softness));
+    }
+
+    #[cfg(feature = "dim3")]
+    #[test]
+    fn spherical_joint_frames() {
+        let basis1 = Quat::from_rotation_z(0.5);
+        let basis2 = Quat::from_rotation_x(-0.3);
+        let joint = SphericalJointBuilder::new()
+            .local_anchor1(Vect::X)
+            .local_basis1(basis1)
+            .local_basis2(basis2)
+            .contacts_enabled(false)
+            .build();
+        assert!(joint.local_basis1().abs_diff_eq(basis1, 1.0e-6));
+        assert!(joint.local_basis2().abs_diff_eq(basis2, 1.0e-6));
+        assert_eq!(joint.local_frame1().translation, Vect::X);
+        assert!(!joint.contacts_enabled());
+
+        let mut other = SphericalJoint::new();
+        other.set_local_frame1(joint.local_frame1());
+        assert_eq!(other.local_frame1(), joint.local_frame1());
+        assert_eq!(other.local_anchor1(), Vect::X);
+    }
+
+    #[test]
+    fn changing_a_joint_wakes_up_its_bodies() {
+        let mut app = test_app();
+        let body1 = spawn_body(&mut app, RigidBody::Dynamic, 0.0, 0.0);
+        let body2 = spawn_body(&mut app, RigidBody::Dynamic, 2.0, 0.0);
+        app.world_mut()
+            .entity_mut(body1)
+            .insert((GravityScale(0.0), Sleeping::default()));
+        app.world_mut().entity_mut(body2).insert((
+            GravityScale(0.0),
+            Sleeping::default(),
+            ImpulseJoint::new(body1, FixedJointBuilder::new().local_anchor1(Vect::X * 2.0)),
+        ));
+        run(&mut app, 120);
+        assert!(app.world().get::<Sleeping>(body1).unwrap().sleeping);
+        assert!(app.world().get::<Sleeping>(body2).unwrap().sleeping);
+
+        app.world_mut()
+            .get_mut::<ImpulseJoint>(body2)
+            .unwrap()
+            .data
+            .as_mut()
+            .set_contacts_enabled(false);
+        app.update();
+
+        with_joints(&mut app, |bodies, _| {
+            for entity in [body1, body2] {
+                let rb = &bodies.bodies[bodies.entity2body()[&entity]];
+                assert!(!rb.is_sleeping());
+            }
+        });
+    }
+
+    fn with_joints_mut<R>(
+        app: &mut App,
+        f: impl FnOnce(&mut RapierRigidBodySet, &mut RapierContextJoints) -> R,
+    ) -> R {
+        let world = app.world_mut();
+        let (mut bodies, mut joints) = world
+            .query::<(&mut RapierRigidBodySet, &mut RapierContextJoints)>()
+            .single_mut(world)
+            .unwrap();
+        f(&mut bodies, &mut joints)
+    }
+
+    fn vect(x: f32, y: f32) -> Vect {
+        #[cfg(feature = "dim2")]
+        return Vect::new(x, y);
+        #[cfg(feature = "dim3")]
+        return Vect::new(x, y, 0.0);
+    }
+
+    /// The rotational axis of the joints returned by [`revolute`], in the joint frame.
+    const ROT_AXIS: JointAxis = JointAxis::AngX;
+
+    /// A revolute joint rotating in the XY plane, with its second anchor one unit behind the
+    /// second body along X, and its first anchor at `anchor1`.
+    fn revolute(anchor1: Vect) -> TypedJoint {
+        #[cfg(feature = "dim2")]
+        let builder = RevoluteJointBuilder::new();
+        #[cfg(feature = "dim3")]
+        let builder = RevoluteJointBuilder::new(Vect::Z);
+        builder
+            .local_anchor1(anchor1)
+            .local_anchor2(-Vect::X)
+            .build()
+            .into()
+    }
+
+    /// A prismatic joint sliding along X, with its first anchor at `anchor1`.
+    fn prismatic(anchor1: Vect) -> TypedJoint {
+        PrismaticJointBuilder::new(Vect::X)
+            .local_anchor1(anchor1)
+            .build()
+            .into()
+    }
+
+    /// Spawns a dynamic body with unit mass attached to `parent` by a multibody joint.
+    fn spawn_link(app: &mut App, parent: Entity, pos: Vect, joint: TypedJoint) -> Entity {
+        let entity = spawn_body(app, RigidBody::Dynamic, pos.x, pos.y);
+        app.world_mut().entity_mut(entity).insert((
+            ColliderMassProperties::Mass(1.0),
+            MultibodyJoint::new(parent, joint),
+        ));
+        entity
+    }
+
+    fn joint_state(app: &App, entity: Entity) -> MultibodyJointState {
+        *app.world().get::<MultibodyJointState>(entity).unwrap()
+    }
+
+    #[test]
+    fn kinematic_multibody_joint_ignores_gravity() {
+        let mut app = test_app();
+        let ground = spawn_body(&mut app, RigidBody::Fixed, 0.0, 0.0);
+        let arm = spawn_link(&mut app, ground, Vect::X, revolute(Vect::ZERO));
+        app.world_mut()
+            .entity_mut(arm)
+            .insert(KinematicMultibodyJoint);
+        run(&mut app, 60);
+
+        let pos = translation(&app, arm);
+        assert!(
+            (pos.x - 1.0).abs() < 1.0e-3 && pos.y.abs() < 1.0e-3,
+            "the kinematic arm should not fall: {pos}"
+        );
+        with_joints(&mut app, |bodies, joints| {
+            let (mb, link_id) = joints.multibody(bodies, arm).unwrap();
+            assert!(mb.link(link_id).unwrap().joint().kinematic);
+        });
+
+        // A kinematic joint follows the velocities set by the user.
+        with_joints_mut(&mut app, |bodies, joints| {
+            joints.multibody_joint_velocity_mut(bodies, arm).unwrap()[0] = 1.0;
+        });
+        run(&mut app, 30);
+        let angle = joint_state(&app, arm).coords[ROT_AXIS as usize];
+        assert!((angle - 0.5).abs() < 0.05, "the arm should rotate: {angle}");
+
+        app.world_mut()
+            .entity_mut(arm)
+            .remove::<KinematicMultibodyJoint>();
+        with_joints_mut(&mut app, |bodies, joints| {
+            joints.multibody_joint_velocity_mut(bodies, arm).unwrap()[0] = 0.0;
+        });
+        run(&mut app, 30);
+        with_joints(&mut app, |bodies, joints| {
+            let (mb, link_id) = joints.multibody(bodies, arm).unwrap();
+            assert!(!mb.link(link_id).unwrap().joint().kinematic);
+        });
+        let angle = joint_state(&app, arm).coords[ROT_AXIS as usize];
+        assert!(angle < 0.3, "the arm should fall once dynamic: {angle}");
+    }
+
+    #[test]
+    fn multibody_joint_friction_and_damping_slow_down_the_joint() {
+        let mut app = test_app();
+        let mut links = vec![];
+        for (i, y) in [0.0, 5.0, 10.0].into_iter().enumerate() {
+            let ground = spawn_body(&mut app, RigidBody::Fixed, 0.0, y);
+            let link = spawn_link(&mut app, ground, vect(0.0, y), prismatic(Vect::ZERO));
+            match i {
+                1 => {
+                    let friction = MultibodyJointFriction::default().with(JointAxis::LinX, 1.0);
+                    app.world_mut().entity_mut(link).insert(friction);
+                }
+                2 => {
+                    let damping = MultibodyJointDamping::default().with(JointAxis::LinX, 1.0);
+                    app.world_mut().entity_mut(link).insert(damping);
+                }
+                _ => {}
+            }
+            links.push(link);
+        }
+        run(&mut app, 1);
+        with_joints_mut(&mut app, |bodies, joints| {
+            for link in &links {
+                joints.multibody_joint_velocity_mut(bodies, *link).unwrap()[0] = 2.0;
+            }
+        });
+        run(&mut app, 30);
+
+        let [free, friction, damping] =
+            std::array::from_fn(|i| joint_state(&app, links[i]).velocities[0]);
+        assert!(free > 1.95, "the free joint should keep moving: {free}");
+        assert!(
+            friction < 1.8 && friction > 0.0,
+            "friction should slow down the joint: {friction}"
+        );
+        assert!(
+            damping < 1.8 && damping > 0.0,
+            "damping should slow down the joint: {damping}"
+        );
+
+        // Removing the friction lets the joint move freely again.
+        app.world_mut()
+            .entity_mut(links[1])
+            .remove::<MultibodyJointFriction>();
+        run(&mut app, 1);
+        with_joints(&mut app, |bodies, joints| {
+            let (mb, _) = joints.multibody(bodies, links[1]).unwrap();
+            let dofs = joints.multibody_link_dofs(bodies, links[1]).unwrap();
+            assert_eq!(dofs.len(), 1);
+            assert_eq!(mb.frictions()[dofs.start], 0.0);
+        });
+    }
+
+    #[test]
+    fn multibody_joint_spring_pulls_towards_rest() {
+        let mut app = test_app();
+        let ground = spawn_body(&mut app, RigidBody::Fixed, 0.0, 0.0);
+        let link = spawn_link(&mut app, ground, Vect::ZERO, prismatic(Vect::ZERO));
+        app.world_mut().entity_mut(link).insert((
+            MultibodyJointSprings::default().with(JointAxis::LinX, 50.0, 1.0),
+            MultibodyJointDamping::splat(5.0),
+        ));
+        run(&mut app, 300);
+
+        let coord = joint_state(&app, link).coords[0];
+        assert!(
+            (coord - 1.0).abs() < 0.05,
+            "the spring should reach its rest position: {coord}"
+        );
+        assert!((translation(&app, link).x - 1.0).abs() < 0.05);
+        with_joints(&mut app, |bodies, joints| {
+            let (mb, link_id) = joints.multibody(bodies, link).unwrap();
+            let joint = mb.link(link_id).unwrap().joint();
+            assert_eq!(joint.spring(0), (50.0, 1.0));
+        });
+
+        app.world_mut()
+            .entity_mut(link)
+            .remove::<MultibodyJointSprings>();
+        run(&mut app, 1);
+        with_joints(&mut app, |bodies, joints| {
+            let (mb, link_id) = joints.multibody(bodies, link).unwrap();
+            assert_eq!(mb.link(link_id).unwrap().joint().spring(0), (0.0, 0.0));
+        });
+    }
+
+    #[test]
+    fn multibody_inverse_kinematics_reaches_target() {
+        let mut app = test_app();
+        let ground = spawn_body(&mut app, RigidBody::Fixed, 0.0, 0.0);
+        let link1 = spawn_link(&mut app, ground, Vect::X, revolute(Vect::ZERO));
+        let link2 = spawn_link(&mut app, link1, Vect::X * 2.0, revolute(Vect::ZERO));
+        run(&mut app, 1);
+
+        let target = Transform::from_xyz(1.0, 1.0, 0.0);
+        let options = InverseKinematicsOption {
+            constrained_axes: JointAxesMask::LIN_X | JointAxesMask::LIN_Y,
+            max_iters: 50,
+            ..Default::default()
+        };
+        let distance = |bodies: &RapierRigidBodySet| {
+            let body = &bodies.bodies[bodies.entity2body()[&link2]];
+            let pos = body.translation();
+            (vect(pos.x, pos.y) - vect(1.0, 1.0)).length()
+        };
+
+        with_joints_mut(&mut app, |bodies, joints| {
+            let before = distance(bodies);
+            let mut displacements = vec![];
+            assert!(joints.multibody_inverse_kinematics(
+                bodies,
+                link2,
+                target,
+                &options,
+                |_| true,
+                &mut displacements,
+            ));
+            assert_eq!(displacements.len(), 2);
+            // A reused buffer is reset before solving: its previous content doesn't matter.
+            let mut reused = vec![10.0, -3.0, 7.0];
+            assert!(joints.multibody_inverse_kinematics(
+                bodies,
+                link2,
+                target,
+                &options,
+                |_| true,
+                &mut reused,
+            ));
+            assert_eq!(reused, displacements);
+            assert!(!joints.multibody_apply_displacements(bodies, link2, &[0.0]));
+            assert!(joints.multibody_apply_displacements(bodies, link2, &displacements));
+            assert!(joints.multibody_forward_kinematics(bodies, link2, false));
+            let after = distance(bodies);
+            assert!(
+                after < before && after < 0.05,
+                "IK should move the end effector to the target: {before} -> {after}"
+            );
+
+            // Locking every joint prevents any motion.
+            joints.multibody_inverse_kinematics(
+                bodies,
+                link2,
+                Transform::from_xyz(-1.0, 1.0, 0.0),
+                &options,
+                |_| false,
+                &mut displacements,
+            );
+            assert!(displacements.iter().all(|d| *d == 0.0));
+            assert!(joints.multibody_body_jacobian(bodies, link2).is_some());
+        });
+    }
+
+    #[test]
+    fn multibody_joint_state_is_written_back() {
+        let mut app = test_app();
+        let ground = spawn_body(&mut app, RigidBody::Fixed, 0.0, 0.0);
+        let arm = spawn_link(&mut app, ground, Vect::X, revolute(Vect::ZERO));
+        run(&mut app, 20);
+
+        let state = joint_state(&app, arm);
+        let angle = state.coords[ROT_AXIS as usize];
+        assert!(angle < -0.1, "the arm should swing down: {state:?}");
+        assert!(state.velocities[ROT_AXIS as usize] < 0.0);
+        assert_eq!(state.coords[0], 0.0);
+
+        let rotation = app.world().get::<Transform>(arm).unwrap().rotation;
+        let (_, _, body_angle) = rotation.to_euler(EulerRot::XYZ);
+        assert!(
+            (body_angle - angle).abs() < 1.0e-3,
+            "{body_angle} vs {angle}"
+        );
+        #[cfg(feature = "dim2")]
+        assert!((state.rotation - angle).abs() < 1.0e-3);
+        #[cfg(feature = "dim3")]
+        assert!(state
+            .rotation
+            .abs_diff_eq(Quat::from_rotation_x(angle), 1.0e-3));
+
+        let from_context = with_joints(&mut app, |_, joints| {
+            joints.multibody_joint_state(arm).unwrap()
+        });
+        assert_eq!(state, from_context);
+        with_joints(&mut app, |bodies, joints| {
+            let velocities = joints.multibody_generalized_velocity(bodies, arm).unwrap();
+            assert_eq!(velocities, &[state.velocities[ROT_AXIS as usize]]);
+            let raw = joints
+                .multibody_joints
+                .get(joints.entity2multibody_joint()[&arm]);
+            let (mb, link_id) = raw.unwrap();
+            assert_eq!(
+                RapierContextJoints::entity_from_multibody_joint(mb.link(link_id).unwrap().joint()),
+                arm
+            );
+        });
+    }
+
+    #[test]
+    fn multibody_topology_helpers() {
+        let mut app = test_app();
+        let ground = spawn_body(&mut app, RigidBody::Fixed, 0.0, 0.0);
+        let other_ground = spawn_body(&mut app, RigidBody::Fixed, 0.0, 5.0);
+        let b1 = spawn_link(&mut app, ground, Vect::X, revolute(Vect::ZERO));
+        let b2 = spawn_link(&mut app, b1, Vect::X * 2.0, revolute(Vect::ZERO));
+        let b3 = spawn_link(&mut app, b1, vect(2.0, -1.0), revolute(-Vect::Y));
+        run(&mut app, 1);
+
+        with_joints(&mut app, |bodies, joints| {
+            for entity in [ground, b1, b2, b3] {
+                assert_eq!(joints.multibody_root(bodies, entity), Some(ground));
+            }
+            assert_eq!(joints.multibody_root(bodies, other_ground), None);
+
+            let links: Vec<_> = joints.multibody_links(bodies, b2).collect();
+            assert_eq!(links.len(), 4);
+            assert_eq!(links[0], ground);
+            for entity in [b1, b2, b3] {
+                assert!(links.contains(&entity));
+            }
+
+            assert_eq!(joints.multibody_parent_link(bodies, ground), None);
+            assert_eq!(joints.multibody_parent_link(bodies, b1), Some(ground));
+            assert_eq!(joints.multibody_parent_link(bodies, b2), Some(b1));
+            assert_eq!(joints.multibody_parent_link(bodies, b3), Some(b1));
+
+            assert_eq!(joints.multibody_joint_between(bodies, b1, b2), Some(b2));
+            assert_eq!(joints.multibody_joint_between(bodies, b2, b1), Some(b2));
+            assert_eq!(joints.multibody_joint_between(bodies, ground, b2), None);
+
+            let mut attached: Vec<_> = joints.attached_multibody_joints(bodies, b1).collect();
+            attached.sort();
+            let mut expected = vec![b1, b2, b3];
+            expected.sort();
+            assert_eq!(attached, expected);
+        });
+
+        // Re-parenting moves the joint (and its descendants) to the new parent.
+        app.world_mut()
+            .get_mut::<MultibodyJoint>(b1)
+            .unwrap()
+            .parent = other_ground;
+        run(&mut app, 1);
+        with_joints(&mut app, |bodies, joints| {
+            assert_eq!(joints.multibody_parent_link(bodies, b1), Some(other_ground));
+            assert_eq!(joints.multibody_root(bodies, b2), Some(other_ground));
+            assert_eq!(joints.multibody_root(bodies, ground), None);
+        });
+
+        // Removing all the joints of a multibody.
+        let joint_entities: Vec<_> = with_joints(&mut app, |bodies, joints| {
+            joints.multibody_links(bodies, b1).skip(1).collect()
+        });
+        for entity in joint_entities {
+            app.world_mut()
+                .entity_mut(entity)
+                .remove::<MultibodyJoint>();
+        }
+        run(&mut app, 1);
+        with_joints(&mut app, |bodies, joints| {
+            assert_eq!(joints.multibody_joints.multibodies().count(), 0);
+            assert_eq!(joints.multibody_root(bodies, b1), None);
+        });
+    }
+
+    #[test]
+    fn multibody_dof_couplings() {
+        let mut app = test_app();
+        let ground = spawn_body(&mut app, RigidBody::Fixed, 0.0, 0.0);
+        let b1 = spawn_link(&mut app, ground, Vect::Y, prismatic(Vect::Y));
+        let b2 = spawn_link(&mut app, ground, -Vect::Y, prismatic(-Vect::Y));
+        app.world_mut()
+            .entity_mut(b2)
+            .insert(MultibodyJointCouplings(vec![MultibodyJointCoupling::new(
+                JointAxis::LinX,
+                b1,
+                JointAxis::LinX,
+                -1.0,
+                0.0,
+            )]));
+        run(&mut app, 1);
+        with_joints_mut(&mut app, |bodies, joints| {
+            joints.multibody_joint_velocity_mut(bodies, b1).unwrap()[0] = 1.0;
+        });
+        run(&mut app, 30);
+
+        let x1 = joint_state(&app, b1).coords[0];
+        let x2 = joint_state(&app, b2).coords[0];
+        assert!(x1 > 0.1, "the first joint should move: {x1}");
+        assert!(
+            (x1 + x2).abs() < 1.0e-2,
+            "the joints should be coupled: {x1} {x2}"
+        );
+        let num_couplings = |app: &mut App| {
+            with_joints(app, |bodies, joints| {
+                joints.multibody(bodies, b1).unwrap().0.couplings().len()
+            })
+        };
+        assert_eq!(num_couplings(&mut app), 1);
+
+        // Removing the coupling keeps the joint state.
+        app.world_mut()
+            .entity_mut(b2)
+            .remove::<MultibodyJointCouplings>();
+        run(&mut app, 1);
+        assert_eq!(num_couplings(&mut app), 0);
+        let new_x2 = joint_state(&app, b2).coords[0];
+        assert!((new_x2 - x2).abs() < 0.1, "{x2} -> {new_x2}");
+        assert_eq!(
+            with_joints(&mut app, |bodies, joints| joints.multibody_root(bodies, b2)),
+            Some(ground)
+        );
+    }
+
+    #[test]
+    fn multibody_couplings_and_self_contacts_follow_topology_changes() {
+        let mut app = test_app();
+        let ground = spawn_body(&mut app, RigidBody::Fixed, 0.0, 0.0);
+        let b1 = spawn_link(&mut app, ground, Vect::Y, prismatic(Vect::Y));
+        // `b2` declares its coupling and disabled self-contacts before being attached.
+        let b2 = spawn_body(&mut app, RigidBody::Dynamic, 0.0, -1.0);
+        let coupling = |coeff| {
+            MultibodyJointCouplings(vec![MultibodyJointCoupling::new(
+                JointAxis::LinX,
+                b1,
+                JointAxis::LinX,
+                coeff,
+                0.0,
+            )])
+        };
+        app.world_mut().entity_mut(b2).insert((
+            ColliderMassProperties::Mass(1.0),
+            MultibodySelfContactsDisabled,
+            coupling(-1.0),
+        ));
+        run(&mut app, 1);
+
+        let read = |app: &mut App| {
+            with_joints(app, |bodies, joints| {
+                let (mb, _) = joints.multibody(bodies, b1).unwrap();
+                let coeffs: Vec<_> = mb.couplings().iter().map(|c| c.coeff).collect();
+                (coeffs, mb.self_contacts_enabled())
+            })
+        };
+        assert_eq!(read(&mut app), (vec![], true));
+
+        app.world_mut()
+            .entity_mut(b2)
+            .insert(MultibodyJoint::new(ground, prismatic(-Vect::Y)));
+        run(&mut app, 1);
+        assert_eq!(read(&mut app), (vec![-1.0], false));
+
+        // Editing the coupling replaces it.
+        app.world_mut().entity_mut(b2).insert(coupling(2.0));
+        run(&mut app, 1);
+        assert_eq!(read(&mut app), (vec![2.0], false));
+
+        // Attaching another link keeps the coupling and the disabled self-contacts.
+        let b3 = spawn_link(&mut app, b1, Vect::Y * 2.0, prismatic(Vect::Y));
+        run(&mut app, 1);
+        assert_eq!(read(&mut app), (vec![2.0], false));
+        assert_eq!(
+            with_joints(&mut app, |bodies, joints| joints.multibody_root(bodies, b3)),
+            Some(ground)
+        );
+
+        // Re-attaching the coupling source drops its coupling, which is then declared again.
+        app.world_mut()
+            .get_mut::<MultibodyJoint>(b1)
+            .unwrap()
+            .parent = b2;
+        run(&mut app, 1);
+        assert_eq!(read(&mut app), (vec![2.0], false));
+        with_joints(&mut app, |bodies, joints| {
+            let parent = |entity| {
+                let (mb, link_id) = joints.multibody(bodies, entity).unwrap();
+                let parent_id = mb.link(link_id).unwrap().parent_id().unwrap();
+                mb.link(parent_id).unwrap().rigid_body_handle()
+            };
+            assert_eq!(parent(b1), bodies.entity2body()[&b2]);
+        });
+    }
+
+    #[test]
+    fn multibody_self_contacts_armature_and_damping() {
+        let mut app = test_app();
+        let ground = spawn_body(&mut app, RigidBody::Fixed, 0.0, 0.0);
+        let arm = spawn_link(&mut app, ground, Vect::X, revolute(Vect::ZERO));
+        app.world_mut()
+            .entity_mut(ground)
+            .insert(MultibodySelfContactsDisabled);
+        app.world_mut().entity_mut(arm).insert((
+            MultibodyJointArmature::splat(0.5),
+            MultibodyJointDamping::splat(2.0),
+        ));
+        run(&mut app, 1);
+
+        let read = |app: &mut App| {
+            with_joints(app, |bodies, joints| {
+                let (mb, _) = joints.multibody(bodies, arm).unwrap();
+                let dof = joints.multibody_link_dofs(bodies, arm).unwrap().start;
+                (
+                    mb.self_contacts_enabled(),
+                    mb.armature()[dof],
+                    mb.damping()[dof],
+                )
+            })
+        };
+        assert_eq!(read(&mut app), (false, 0.5, 2.0));
+
+        app.world_mut()
+            .entity_mut(ground)
+            .remove::<MultibodySelfContactsDisabled>();
+        app.world_mut()
+            .entity_mut(arm)
+            .remove::<(MultibodyJointArmature, MultibodyJointDamping)>();
+        run(&mut app, 1);
+        let default_damping = MultibodyJointDamping::default().0[ROT_AXIS as usize];
+        assert_eq!(read(&mut app), (true, 0.0, default_damping));
+    }
+
+    #[test]
+    fn multibody_joint_properties_apply_to_late_joints() {
+        let mut app = test_app();
+        let ground = app
+            .world_mut()
+            .spawn(Transform::from_xyz(0.0, 0.0, 0.0))
+            .id();
+        let link = spawn_link(&mut app, ground, Vect::ZERO, prismatic(Vect::ZERO));
+        app.world_mut().entity_mut(link).insert((
+            KinematicMultibodyJoint,
+            MultibodyJointSprings::default().with(JointAxis::LinX, 10.0, 2.0),
+        ));
+        run(&mut app, 2);
+        assert!(app
+            .world()
+            .get::<RapierMultibodyJointHandle>(link)
+            .is_none());
+
+        // The joint is only created once its parent gets a rigid-body.
+        app.world_mut().entity_mut(ground).insert(RigidBody::Fixed);
+        run(&mut app, 1);
+        with_joints(&mut app, |bodies, joints| {
+            let (mb, link_id) = joints.multibody(bodies, link).unwrap();
+            let joint = mb.link(link_id).unwrap().joint();
+            assert!(joint.kinematic);
+            assert_eq!(joint.spring(0), (10.0, 2.0));
+        });
+    }
+}
diff --git a/bindings/bevy_rapier/src/plugin/systems/mod.rs b/bindings/bevy_rapier/src/plugin/systems/mod.rs
new file mode 100644
index 000000000..7a3b14005
--- /dev/null
+++ b/bindings/bevy_rapier/src/plugin/systems/mod.rs
@@ -0,0 +1,370 @@
+//! Systems responsible for interfacing our Bevy components with the Rapier physics engine.
+
+mod character_controller;
+mod collider;
+mod joint;
+mod multiple_rapier_contexts;
+mod pid_controller;
+mod remove;
+mod rigid_body;
+mod soft_body;
+#[cfg(feature = "dim3")]
+mod vehicle_controller;
+mod writeback;
+
+pub use character_controller::*;
+pub use collider::*;
+pub use joint::*;
+pub use multiple_rapier_contexts::*;
+pub use pid_controller::*;
+pub use remove::*;
+pub use rigid_body::*;
+pub use soft_body::*;
+#[cfg(feature = "dim3")]
+pub use vehicle_controller::*;
+pub use writeback::*;
+
+use crate::dynamics::{
+    RapierRigidBodyHandle, RigidBodyDisabled, SoftBodyDisabled, TransformInterpolation,
+};
+use crate::geometry::ColliderDisabled;
+use crate::pipeline::{CollisionEvent, ContactForceEvent, PhysicsQuarantineEvent};
+use crate::plugin::context::SimulationToRenderTime;
+use crate::plugin::{RapierConfiguration, TimestepMode};
+use crate::prelude::{BevyPhysicsHooks, BevyPhysicsHooksAdapter};
+use bevy::ecs::system::{StaticSystemParam, SystemParamItem};
+use bevy::prelude::*;
+
+use super::context::{
+    RapierContextColliders, RapierContextJoints, RapierContextSimulation, RapierRigidBodySet,
+};
+
+/// System responsible for advancing the physics simulation, and updating the internal state
+/// for scene queries.
+pub fn step_simulation<Hooks>(
+    mut commands: Commands,
+    mut context: Query<(
+        Entity,
+        &mut RapierContextSimulation,
+        &mut RapierContextColliders,
+        &mut RapierContextJoints,
+        &mut RapierRigidBodySet,
+        &RapierConfiguration,
+        &mut SimulationToRenderTime,
+    )>,
+    timestep_mode: Res<TimestepMode>,
+    hooks: StaticSystemParam<Hooks>,
+    time: Res<Time>,
+    mut collision_events: MessageWriter<CollisionEvent>,
+    mut contact_force_events: MessageWriter<ContactForceEvent>,
+    mut quarantine_events: MessageWriter<PhysicsQuarantineEvent>,
+    mut interpolation_query: Query<(&RapierRigidBodyHandle, &mut TransformInterpolation)>,
+) where
+    Hooks: 'static + BevyPhysicsHooks,
+    for<'w, 's> SystemParamItem<'w, 's, Hooks>: BevyPhysicsHooks,
+{
+    let hooks_adapter = BevyPhysicsHooksAdapter::new(hooks.into_inner());
+
+    for (
+        context_entity,
+        mut context,
+        mut context_colliders,
+        mut joints,
+        mut rigidbody_set,
+        config,
+        mut sim_to_render_time,
+    ) in context.iter_mut()
+    {
+        let context = &mut *context;
+        let context_colliders = &mut *context_colliders;
+
+        if config.physics_pipeline_active {
+            context.set_num_threads(config.num_threads);
+            context.step_simulation(
+                context_colliders,
+                &mut joints,
+                &mut rigidbody_set,
+                config.gravity,
+                config.simulation_mode,
+                *timestep_mode,
+                Some((&collision_events, &contact_force_events)),
+                &hooks_adapter,
+                &time,
+                &mut sim_to_render_time,
+                Some(&mut interpolation_query),
+            );
+        } else {
+            rigidbody_set.propagate_modified_body_positions_to_colliders(context_colliders);
+        }
+        context.send_bevy_events(&mut collision_events, &mut contact_force_events);
+        // Mirror the quarantine on the entities so that removing the component re-enables them.
+        for entity in &context.quarantined_bodies {
+            commands.entity(*entity).try_insert(RigidBodyDisabled);
+        }
+        for entity in &context.quarantined_colliders {
+            commands.entity(*entity).try_insert(ColliderDisabled);
+        }
+        for entity in &context.quarantined_soft_bodies {
+            commands.entity(*entity).try_insert(SoftBodyDisabled);
+        }
+        context.send_quarantine_events(context_entity, &mut quarantine_events);
+    }
+}
+
+#[cfg(test)]
+#[allow(missing_docs)]
+pub mod tests {
+    use bevy::time::TimePlugin;
+    use rapier::geometry::CollisionEventFlags;
+    use std::f32::consts::PI;
+
+    use super::*;
+    use crate::{
+        plugin::{NoUserData, RapierPhysicsPlugin},
+        prelude::{Collider, CollidingEntities, RigidBody},
+        utils,
+    };
+
+    #[test]
+    fn colliding_entities_updates() {
+        let mut app = App::new();
+        app.add_message::<CollisionEvent>()
+            .add_systems(Update, update_colliding_entities);
+
+        let entity1 = app.world_mut().spawn(CollidingEntities::default()).id();
+        let entity2 = app.world_mut().spawn(CollidingEntities::default()).id();
+
+        let mut collision_events = app
+            .world_mut()
+            .get_resource_mut::<Messages<CollisionEvent>>()
+            .unwrap();
+        collision_events.write(CollisionEvent::Started(
+            entity1,
+            entity2,
+            CollisionEventFlags::SENSOR,
+        ));
+
+        app.update();
+
+        let colliding_entities1 = app
+            .world()
+            .entity(entity1)
+            .get::<CollidingEntities>()
+            .unwrap();
+        assert_eq!(
+            colliding_entities1.len(),
+            1,
+            "There should be one colliding entity"
+        );
+        assert_eq!(
+            colliding_entities1.iter().next().unwrap(),
+            entity2,
+            "Colliding entity should be equal to the second entity"
+        );
+
+        let colliding_entities2 = app
+            .world()
+            .entity(entity2)
+            .get::<CollidingEntities>()
+            .unwrap();
+        assert_eq!(
+            colliding_entities2.len(),
+            1,
+            "There should be one colliding entity"
+        );
+        assert_eq!(
+            colliding_entities2.iter().next().unwrap(),
+            entity1,
+            "Colliding entity should be equal to the first entity"
+        );
+
+        let mut collision_events = app
+            .world_mut()
+            .get_resource_mut::<Messages<CollisionEvent>>()
+            .unwrap();
+        collision_events.write(CollisionEvent::Stopped(
+            entity1,
+            entity2,
+            CollisionEventFlags::SENSOR,
+        ));
+
+        app.update();
+
+        let colliding_entities1 = app
+            .world()
+            .entity(entity1)
+            .get::<CollidingEntities>()
+            .unwrap();
+        assert!(
+            colliding_entities1.is_empty(),
+            "Colliding entity should be removed from the CollidingEntities component when the collision ends"
+        );
+
+        let colliding_entities2 = app
+            .world()
+            .entity(entity2)
+            .get::<CollidingEntities>()
+            .unwrap();
+        assert!(
+            colliding_entities2.is_empty(),
+            "Colliding entity should be removed from the CollidingEntities component when the collision ends"
+        );
+    }
+
+    #[test]
+    fn transform_propagation() {
+        let mut app = App::new();
+        app.add_plugins((
+            TransformPlugin,
+            TimePlugin,
+            RapierPhysicsPlugin::<NoUserData>::default(),
+        ));
+        app.finish();
+
+        let zero = (Transform::default(), Transform::default());
+
+        let different = (
+            Transform {
+                translation: Vec3::X * 10.0,
+                rotation: Quat::from_rotation_x(PI),
+                ..Default::default()
+            },
+            Transform {
+                translation: Vec3::Y * 10.0,
+                rotation: Quat::from_rotation_x(PI),
+                ..Default::default()
+            },
+        );
+
+        let same = (different.0, different.0);
+
+        for (child_transform, parent_transform) in [zero, same, different] {
+            let child = app
+                .world_mut()
+                .spawn((child_transform, RigidBody::Fixed, Collider::ball(1.0)))
+                .id();
+
+            app.world_mut()
+                .spawn(parent_transform)
+                .add_children(&[child]);
+
+            app.update();
+
+            let world = app.world_mut();
+            let rigidbody_set = world
+                .query::<&RapierRigidBodySet>()
+                .iter(world)
+                .next()
+                .unwrap();
+            let child_transform = world.entity(child).get::<GlobalTransform>().unwrap();
+            let child_handle = rigidbody_set.entity2body[&child];
+            let child_body = rigidbody_set.bodies.get(child_handle).unwrap();
+            let body_transform = utils::iso_to_transform(child_body.position());
+
+            fn transforms_approx_equal(
+                a: &GlobalTransform,
+                b: &GlobalTransform,
+                epsilon: f32,
+            ) -> bool {
+                a.translation().abs_diff_eq(b.translation(), epsilon)
+                    && a.scale().abs_diff_eq(b.scale(), epsilon)
+                    && a.rotation().abs_diff_eq(b.rotation(), epsilon)
+            }
+            assert!(
+                transforms_approx_equal(
+                    &GlobalTransform::from(body_transform),
+                    child_transform,
+                    1.0e-5,
+                ),
+                "Collider transforms should have have equal global rotation and translation"
+            );
+        }
+    }
+
+    #[test]
+    fn transform_propagation2() {
+        let mut app = App::new();
+        app.add_plugins((
+            TransformPlugin,
+            TimePlugin,
+            RapierPhysicsPlugin::<NoUserData>::default(),
+        ));
+        app.finish();
+
+        let zero = (Transform::default(), Transform::default());
+
+        let different = (
+            Transform {
+                translation: Vec3::X * 10.0,
+                // NOTE: in 2D the test will fail if the rotation is wrt. an axis
+                //       other than Z because 2D physics objects can’t rotate wrt.
+                //       other axes.
+                rotation: Quat::from_rotation_z(PI),
+                ..Default::default()
+            },
+            Transform {
+                translation: Vec3::Y * 10.0,
+                rotation: Quat::from_rotation_z(PI),
+                ..Default::default()
+            },
+        );
+
+        let same = (different.0, different.0);
+
+        for (child_transform, parent_transform) in [zero, same, different] {
+            let child = app
+                .world_mut()
+                .spawn((child_transform, Collider::ball(1.0)))
+                .id();
+
+            let parent = app
+                .world_mut()
+                .spawn((parent_transform, RigidBody::Fixed))
+                .add_children(&[child])
+                .id();
+
+            app.update();
+
+            let child_transform = app
+                .world()
+                .entity(child)
+                .get::<GlobalTransform>()
+                .unwrap()
+                .compute_transform();
+            let world = app.world_mut();
+            let (rigidbody_set, context_colliders) = world
+                .query::<(&RapierRigidBodySet, &RapierContextColliders)>()
+                .iter(world)
+                .next()
+                .unwrap();
+            let parent_handle = rigidbody_set.entity2body[&parent];
+            let parent_body = rigidbody_set.bodies.get(parent_handle).unwrap();
+            let child_collider_handle = parent_body.colliders()[0];
+            let child_collider = context_colliders
+                .colliders
+                .get(child_collider_handle)
+                .unwrap();
+            let body_transform = utils::iso_to_transform(child_collider.position());
+            approx::assert_relative_eq!(
+                body_transform.translation,
+                child_transform.translation,
+                epsilon = 1.0e-5
+            );
+
+            // Adjust signs to account for the quaternion’s double covering.
+            let comparison_child_rotation =
+                if body_transform.rotation.w * child_transform.rotation.w < 0.0 {
+                    -child_transform.rotation
+                } else {
+                    child_transform.rotation
+                };
+
+            approx::assert_relative_eq!(
+                body_transform.rotation,
+                comparison_child_rotation,
+                epsilon = 1.0e-5
+            );
+            approx::assert_relative_eq!(body_transform.scale, child_transform.scale,);
+        }
+    }
+}
diff --git a/bindings/bevy_rapier/src/plugin/systems/multiple_rapier_contexts.rs b/bindings/bevy_rapier/src/plugin/systems/multiple_rapier_contexts.rs
new file mode 100644
index 000000000..23c1c3ec9
--- /dev/null
+++ b/bindings/bevy_rapier/src/plugin/systems/multiple_rapier_contexts.rs
@@ -0,0 +1,338 @@
+//! systems to support multiple physics contexts, and changes between them.
+
+use crate::dynamics::{
+    RapierImpulseJointHandle, RapierMultibodyJointHandle, RapierRigidBodyHandle,
+    RapierSoftBodyHandle,
+};
+use crate::geometry::RapierColliderHandle;
+use crate::plugin::context::RapierRigidBodySet;
+use crate::plugin::context::{
+    DefaultRapierContext, RapierContextColliders, RapierContextEntityLink, RapierContextJoints,
+};
+use bevy::ecs::system::SystemParam;
+use bevy::prelude::*;
+
+/// Finds the Rapier context of the entities being initialized without a
+/// [`RapierContextEntityLink`].
+///
+/// Such an entity joins the context of its closest ancestor with a [`RapierContextEntityLink`],
+/// or the [`DefaultRapierContext`] if it has none.
+#[derive(SystemParam)]
+pub struct RapierContextLinkResolver<'w, 's> {
+    default_context: Query<'w, 's, Entity, With<DefaultRapierContext>>,
+    child_of: Query<'w, 's, &'static ChildOf>,
+    links: Query<'w, 's, &'static RapierContextEntityLink>,
+}
+
+impl RapierContextLinkResolver<'_, '_> {
+    /// The context of `entity`, given its current `link`.
+    ///
+    /// If `link` is `None`, the resolved context is inserted as the entity's
+    /// [`RapierContextEntityLink`]. Returns `None` if no context was found.
+    pub fn resolve(
+        &self,
+        entity: Entity,
+        link: Option<&RapierContextEntityLink>,
+        commands: &mut Commands,
+    ) -> Option<Entity> {
+        if let Some(link) = link {
+            return Some(link.0);
+        }
+
+        let context = self
+            .child_of
+            .iter_ancestors(entity)
+            .find_map(|ancestor| self.links.get(ancestor).ok().map(|link| link.0))
+            .or_else(|| self.default_context.single().ok())?;
+        commands
+            .entity(entity)
+            .insert(RapierContextEntityLink(context));
+        Some(context)
+    }
+}
+
+/// If an entity is turned into the child of something with a physics context link,
+/// the child should become a part of that physics context
+///
+/// If this fails to happen, weirdness will ensue.
+pub fn on_add_entity_with_parent(
+    q_add_entity_without_parent: Query<
+        (Entity, &ChildOf),
+        (
+            With<RapierContextEntityLink>,
+            Or<(Changed<RapierContextEntityLink>, Changed<ChildOf>)>,
+        ),
+    >,
+    q_child_of: Query<&ChildOf>,
+    q_physics_world: Query<&RapierContextEntityLink>,
+    mut commands: Commands,
+) {
+    for (ent, child_of) in &q_add_entity_without_parent {
+        let mut parent = Some(child_of.parent());
+        while let Some(parent_entity) = parent {
+            if let Ok(pw) = q_physics_world.get(parent_entity) {
+                // Change rapier context link only if the existing link isn't the correct one.
+                if q_physics_world.get(ent).map(|x| x != pw).unwrap_or(true) {
+                    remove_old_physics(ent, &mut commands);
+                    commands.entity(ent).insert(*pw);
+                }
+                break;
+            }
+            parent = q_child_of.get(parent_entity).ok().map(|x| x.parent());
+        }
+    }
+}
+
+/// Flags the entity to have its old physics removed
+fn remove_old_physics(entity: Entity, commands: &mut Commands) {
+    commands
+        .entity(entity)
+        .remove::<RapierColliderHandle>()
+        .remove::<RapierRigidBodyHandle>()
+        .remove::<RapierMultibodyJointHandle>()
+        .remove::<RapierImpulseJointHandle>()
+        .remove::<RapierSoftBodyHandle>();
+}
+
+/// Reacts to modifications to [`RapierContextEntityLink`]
+/// to move an entity's physics data from a context to another.
+///
+/// Also recursively bubbles down context changes to children & flags them to apply any needed physics changes
+pub fn on_change_context(
+    q_changed_contexts: Query<
+        (Entity, Ref<RapierContextEntityLink>),
+        Changed<RapierContextEntityLink>,
+    >,
+    q_children: Query<&Children>,
+    q_physics_context: Query<&RapierContextEntityLink>,
+    q_context: Query<(
+        &RapierContextColliders,
+        &RapierContextJoints,
+        &RapierRigidBodySet,
+    )>,
+    mut commands: Commands,
+) {
+    for (entity, new_physics_context) in &q_changed_contexts {
+        let context = q_context.get(new_physics_context.0);
+        // Ensure the context actually changed before removing them from the context
+        if !context
+            .map(|(colliders, joints, rigidbody_set)| {
+                // They are already apart of this context if any of these are true
+                colliders.entity2collider.contains_key(&entity)
+                    || rigidbody_set.entity2body.contains_key(&entity)
+                    || rigidbody_set.entity2soft_body.contains_key(&entity)
+                    || joints.entity2impulse_joint.contains_key(&entity)
+                    || joints.entity2multibody_joint.contains_key(&entity)
+            })
+            .unwrap_or(false)
+        {
+            remove_old_physics(entity, &mut commands);
+            bubble_down_context_change(
+                &mut commands,
+                entity,
+                &q_children,
+                *new_physics_context,
+                &q_physics_context,
+            );
+        }
+    }
+}
+
+fn bubble_down_context_change(
+    commands: &mut Commands,
+    entity: Entity,
+    q_children: &Query<&Children>,
+    new_physics_context: RapierContextEntityLink,
+    q_physics_context: &Query<&RapierContextEntityLink>,
+) {
+    let Ok(children) = q_children.get(entity) else {
+        return;
+    };
+
+    children.iter().for_each(|child| {
+        if q_physics_context
+            .get(child)
+            .map(|x| *x == new_physics_context)
+            .unwrap_or(false)
+        {
+            return;
+        }
+
+        remove_old_physics(child, commands);
+        commands.entity(child).insert(new_physics_context);
+
+        bubble_down_context_change(
+            commands,
+            child,
+            q_children,
+            new_physics_context,
+            q_physics_context,
+        );
+    });
+}
+
+#[cfg(test)]
+mod test {
+    use crate::plugin::{
+        context::{
+            RapierContextColliders, RapierContextEntityLink, RapierContextSimulation,
+            RapierRigidBodySet,
+        },
+        NoUserData, PhysicsSet, RapierPhysicsPlugin,
+    };
+    use crate::prelude::{ActiveEvents, Collider, ContactForceEventThreshold, RigidBody, Sensor};
+    use bevy::prelude::*;
+    use bevy::time::{TimePlugin, TimeUpdateStrategy};
+    use rapier::math::Real;
+
+    #[test]
+    pub fn multi_context_hierarchy_update() {
+        let mut app = App::new();
+        app.add_plugins((
+            TransformPlugin,
+            TimePlugin,
+            RapierPhysicsPlugin::<NoUserData>::default(),
+        ))
+        .add_systems(
+            PostUpdate,
+            setup_physics
+                .run_if(run_once)
+                .before(PhysicsSet::SyncBackend),
+        );
+        // Simulates 60 updates per seconds
+        app.insert_resource(TimeUpdateStrategy::ManualDuration(
+            std::time::Duration::from_secs_f32(1f32 / 60f32),
+        ));
+        app.finish();
+        app.update();
+        // Verify all rapier entities have a `RapierContextEntityLink`.
+        let world = app.world_mut();
+        let mut query = world.query_filtered::<Entity, With<Marker<'R'>>>();
+        for entity in query.iter(world) {
+            world
+                .get::<RapierContextEntityLink>(entity)
+                .unwrap_or_else(|| panic!("no link to rapier context entity from {entity}."));
+        }
+        // Verify link is correctly updated for children.
+        let new_rapier_context = world.spawn((RapierContextSimulation::default(),)).id();
+        // FIXME: We need to wait 1 frame when creating a context.
+        // Ideally we should be able to order the systems so that we don't have to wait.
+        app.update();
+        let world = app.world_mut();
+        let mut query = world.query_filtered::<&mut RapierContextEntityLink, With<Marker<'P'>>>();
+        let mut link_parent = query.single_mut(world).unwrap();
+        link_parent.0 = new_rapier_context;
+        app.update();
+        let world = app.world_mut();
+        let mut query = world.query_filtered::<&RapierContextEntityLink, With<Marker<'C'>>>();
+        let link_child = query.single_mut(world).unwrap();
+        assert_eq!(link_child.0, new_rapier_context);
+        return;
+
+        #[derive(Component)]
+        pub struct Marker<const MARKER: char>;
+
+        #[cfg(feature = "dim3")]
+        fn cuboid(hx: Real, hy: Real, hz: Real) -> Collider {
+            Collider::cuboid(hx, hy, hz)
+        }
+        #[cfg(feature = "dim2")]
+        fn cuboid(hx: Real, hy: Real, _hz: Real) -> Collider {
+            Collider::cuboid(hx, hy)
+        }
+        pub fn setup_physics(mut commands: Commands) {
+            commands.spawn((
+                Transform::from_xyz(0.0, -1.2, 0.0),
+                cuboid(4.0, 1.0, 1.0),
+                Marker::<'R'>,
+            ));
+
+            commands.spawn((
+                Transform::from_xyz(0.0, 5.0, 0.0),
+                cuboid(4.0, 1.5, 1.0),
+                Sensor,
+                Marker::<'R'>,
+            ));
+
+            commands
+                .spawn((
+                    Transform::from_xyz(0.0, 13.0, 0.0),
+                    RigidBody::Dynamic,
+                    cuboid(0.5, 0.5, 0.5),
+                    ActiveEvents::COLLISION_EVENTS,
+                    ContactForceEventThreshold(30.0),
+                    Marker::<'P'>,
+                    Marker::<'R'>,
+                ))
+                .with_children(|child_builder| {
+                    child_builder.spawn((
+                        Transform::from_xyz(0.0, -1.2, 0.0),
+                        cuboid(4.0, 1.0, 1.0),
+                        Marker::<'C'>,
+                        Marker::<'R'>,
+                    ));
+                });
+        }
+    }
+
+    #[test]
+    pub fn children_inherit_the_parent_context_at_initialization() {
+        let mut app = App::new();
+        app.add_plugins((
+            TransformPlugin,
+            TimePlugin,
+            RapierPhysicsPlugin::<NoUserData>::default(),
+        ));
+        app.insert_resource(TimeUpdateStrategy::ManualDuration(
+            std::time::Duration::from_secs_f32(1f32 / 60f32),
+        ));
+        app.finish();
+        app.update();
+
+        let other_context = app
+            .world_mut()
+            .spawn(RapierContextSimulation::default())
+            .id();
+        app.update();
+
+        let mut child = Entity::PLACEHOLDER;
+        let mut grandchild = Entity::PLACEHOLDER;
+        let parent = app
+            .world_mut()
+            .spawn((
+                Transform::default(),
+                RigidBody::Dynamic,
+                RapierContextEntityLink(other_context),
+            ))
+            .with_children(|builder| {
+                child = builder
+                    .spawn((Transform::default(), Collider::ball(0.5)))
+                    .with_children(|builder| {
+                        grandchild = builder
+                            .spawn((Transform::default(), Collider::ball(0.5)))
+                            .id();
+                    })
+                    .id();
+            })
+            .id();
+        app.update();
+
+        let world = app.world();
+        for entity in [child, grandchild] {
+            assert_eq!(
+                world.get::<RapierContextEntityLink>(entity).unwrap().0,
+                other_context
+            );
+        }
+        let colliders = world.get::<RapierContextColliders>(other_context).unwrap();
+        assert!(colliders.entity2collider().contains_key(&child));
+        assert!(colliders.entity2collider().contains_key(&grandchild));
+        assert_eq!(
+            colliders.collider_parent(
+                world.get::<RapierRigidBodySet>(other_context).unwrap(),
+                child
+            ),
+            Some(parent)
+        );
+    }
+}
diff --git a/bindings/bevy_rapier/src/plugin/systems/pid_controller.rs b/bindings/bevy_rapier/src/plugin/systems/pid_controller.rs
new file mode 100644
index 000000000..8b09906ab
--- /dev/null
+++ b/bindings/bevy_rapier/src/plugin/systems/pid_controller.rs
@@ -0,0 +1,153 @@
+use crate::control::{PdController, PidController};
+use crate::dynamics::RapierRigidBodyHandle;
+use crate::plugin::context::{
+    RapierContextEntityLink, RapierContextSimulation, RapierRigidBodySet,
+};
+use crate::plugin::RapierConfiguration;
+use bevy::prelude::*;
+use rapier::dynamics::{RigidBody as RapierRigidBody, RigidBodyVelocity};
+
+fn apply_correction(
+    body: &mut RapierRigidBody,
+    linvel: crate::math::Vect,
+    angvel: crate::math::AngVector,
+) {
+    let correction = RigidBodyVelocity { linvel, angvel };
+    if correction != RigidBodyVelocity::zero() {
+        let vels = *body.vels() + correction;
+        body.set_vels(vels, true);
+    }
+}
+
+/// System responsible for driving rigid-bodies with a [`PdController`] or a [`PidController`]
+/// toward their target, by adding the controllers' corrections to their velocities.
+pub fn update_pid_controllers(
+    config: Query<&RapierConfiguration>,
+    mut context_access: Query<(&RapierContextSimulation, &mut RapierRigidBodySet)>,
+    pd_controllers: Query<(
+        &RapierContextEntityLink,
+        &RapierRigidBodyHandle,
+        &PdController,
+    )>,
+    mut pid_controllers: Query<(
+        &RapierContextEntityLink,
+        &RapierRigidBodyHandle,
+        &mut PidController,
+    )>,
+) {
+    let is_active = |link: &RapierContextEntityLink| {
+        config
+            .get(link.0)
+            .is_ok_and(|config| config.physics_pipeline_active)
+    };
+
+    for (link, handle, controller) in pd_controllers.iter() {
+        if !is_active(link) {
+            continue;
+        }
+        let Ok((_, mut rigidbody_set)) = context_access.get_mut(link.0) else {
+            continue;
+        };
+        let Some(body) = rigidbody_set.bodies.get_mut(handle.0) else {
+            continue;
+        };
+        if body.is_fixed() || !body.is_enabled() {
+            continue;
+        }
+        let correction = controller.rigid_body_correction(body);
+        apply_correction(body, correction.linear, correction.angular);
+    }
+
+    for (link, handle, mut controller) in pid_controllers.iter_mut() {
+        if !is_active(link) {
+            continue;
+        }
+        let Ok((context, mut rigidbody_set)) = context_access.get_mut(link.0) else {
+            continue;
+        };
+        let dt = context.integration_parameters.dt;
+        let Some(body) = rigidbody_set.bodies.get_mut(handle.0) else {
+            continue;
+        };
+        if body.is_fixed() || !body.is_enabled() {
+            continue;
+        }
+        let correction = controller.rigid_body_correction(dt, body);
+        apply_correction(body, correction.linear, correction.angular);
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+    use crate::control::{AxesMask, PidTarget};
+    use crate::geometry::Collider;
+    use crate::math::Vect;
+    use crate::plugin::{NoUserData, RapierPhysicsPlugin};
+    use crate::prelude::RigidBody;
+    use bevy::time::{TimePlugin, TimeUpdateStrategy};
+
+    #[test]
+    fn pid_controller_drives_body_toward_target() {
+        let mut app = App::new();
+        app.add_plugins((
+            TransformPlugin,
+            TimePlugin,
+            RapierPhysicsPlugin::<NoUserData>::default(),
+        ))
+        .insert_resource(TimeUpdateStrategy::ManualDuration(
+            std::time::Duration::from_secs_f32(1.0 / 60.0),
+        ));
+        app.finish();
+
+        let target = Vect::splat(3.0);
+        let controlled = app
+            .world_mut()
+            .spawn((
+                Transform::default(),
+                RigidBody::Dynamic,
+                Collider::ball(0.5),
+                PidController::new(10.0, 1.0, 0.5, AxesMask::LIN_AXES)
+                    .with_target(PidTarget::from_translation(target)),
+            ))
+            .id();
+        let pd_controlled = app
+            .world_mut()
+            .spawn((
+                Transform::from_xyz(10.0, 0.0, 0.0),
+                RigidBody::Dynamic,
+                Collider::ball(0.5),
+                PdController::new(10.0, 0.5, AxesMask::LIN_AXES)
+                    .with_target(PidTarget::from_translation(Vect::X * 10.0 + target)),
+            ))
+            .id();
+
+        for _ in 0..300 {
+            app.update();
+        }
+
+        let translation = |entity: Entity| {
+            let t = app.world().get::<Transform>(entity).unwrap().translation;
+            #[cfg(feature = "dim2")]
+            return t.truncate();
+            #[cfg(feature = "dim3")]
+            return t;
+        };
+        let pid_error = (translation(controlled) - target).length();
+        let pd_error = (translation(pd_controlled) - Vect::X * 10.0 - target).length();
+        // Both bodies start about 5.2 units away from their target and fight gravity.
+        assert!(
+            pid_error < 0.05,
+            "PID controller error too large: {pid_error}"
+        );
+        assert!(pd_error < 0.05, "PD controller error too large: {pd_error}");
+        assert_ne!(
+            app.world()
+                .get::<PidController>(controlled)
+                .unwrap()
+                .lin_integral,
+            Vect::ZERO,
+            "The integral error should be written back"
+        );
+    }
+}
diff --git a/bindings/bevy_rapier/src/plugin/systems/remove.rs b/bindings/bevy_rapier/src/plugin/systems/remove.rs
new file mode 100644
index 000000000..a7972cd73
--- /dev/null
+++ b/bindings/bevy_rapier/src/plugin/systems/remove.rs
@@ -0,0 +1,566 @@
+use crate::dynamics::ImpulseJoint;
+use crate::dynamics::ImpulseJointDisabled;
+use crate::dynamics::MultibodyJoint;
+use crate::dynamics::RapierImpulseJointHandle;
+use crate::dynamics::RapierMultibodyJointHandle;
+use crate::dynamics::RapierRigidBodyHandle;
+use crate::dynamics::RigidBody;
+use crate::dynamics::SoftBody;
+use crate::dynamics::SoftBodyCluster;
+use crate::geometry::Collider;
+use crate::geometry::ColliderDisabled;
+use crate::geometry::RapierColliderHandle;
+use crate::plugin::context::{
+    RapierContextColliders, RapierContextJoints, RapierContextSimulation, RapierRigidBodySet,
+};
+#[cfg(feature = "dim3")]
+use crate::prelude::GyroscopicForces;
+use crate::prelude::{
+    ActiveCollisionTypes, ActiveEvents, ActiveHooks, AdditionalMassProperties,
+    AdditionalPgsIterations, AdditionalSolverIterations, AllowFastRotation, Ccd,
+    ColliderMassProperties, CollisionGroups, ContactForceEventThreshold, ContactSkin, Damping,
+    Dominance, ExternalForce, Friction, GravityScale, LockedAxes, MassModifiedEvent,
+    MassProperties, ReadColliderMassProperties, Restitution, RigidBodyDisabled, Sensor, Sleeping,
+    SoftCcd, SolverGroups,
+};
+use bevy::ecs::query::IterQueryData;
+use bevy::prelude::*;
+
+/// System responsible for removing from Rapier the rigid-bodies/colliders/joints which had
+/// their related `bevy_rapier` components removed by the user (through component removal or
+/// despawn).
+pub fn sync_removals(
+    mut commands: Commands,
+    mut context_writer: Query<(
+        &mut RapierContextSimulation,
+        &mut RapierContextColliders,
+        &mut RapierContextJoints,
+        &mut RapierRigidBodySet,
+    )>,
+    // Sometimes a Remove immediately followed by Add happens. These `q_has_*` queries prevent that immediate Add
+    // from being removed by this system by verifying it's still removed.
+    (
+        q_has_rigidbody_handle,
+        q_has_collider_handle,
+        q_has_multibody_joint_handle,
+        q_has_impulse_joint_handle,
+    ): (
+        Query<(), With<RapierRigidBodyHandle>>,
+        Query<(), With<RapierColliderHandle>>,
+        Query<(), With<RapierMultibodyJointHandle>>,
+        Query<(), With<RapierImpulseJointHandle>>,
+    ),
+    mut removed_bodies: RemovedComponents<RapierRigidBodyHandle>,
+    mut removed_colliders: RemovedComponents<RapierColliderHandle>,
+    mut removed_impulse_joints: RemovedComponents<RapierImpulseJointHandle>,
+    mut removed_multibody_joints: RemovedComponents<RapierMultibodyJointHandle>,
+    orphan_bodies: Query<
+        Entity,
+        (
+            With<RapierRigidBodyHandle>,
+            Without<RigidBody>,
+            Without<SoftBodyCluster>,
+        ),
+    >,
+    orphan_colliders: Query<Entity, (With<RapierColliderHandle>, Without<Collider>)>,
+    orphan_impulse_joints: Query<Entity, (With<RapierImpulseJointHandle>, Without<ImpulseJoint>)>,
+    orphan_multibody_joints: Query<
+        Entity,
+        (With<RapierMultibodyJointHandle>, Without<MultibodyJoint>),
+    >,
+
+    mut removed_sensors: RemovedComponents<Sensor>,
+    mut removed_rigid_body_disabled: RemovedComponents<RigidBodyDisabled>,
+    mut removed_colliders_disabled: RemovedComponents<ColliderDisabled>,
+    (mut removed_impulse_joints_disabled, mut impulse_joints): (
+        RemovedComponents<ImpulseJointDisabled>,
+        Query<&mut ImpulseJoint, Without<ImpulseJointDisabled>>,
+    ),
+
+    mut mass_modified: MessageWriter<MassModifiedEvent>,
+) {
+    /*
+     * Rigid-bodies removal detection.
+     */
+    for entity in removed_bodies
+        .read()
+        .filter(|e| !q_has_rigidbody_handle.contains(*e))
+    {
+        let Some(((mut context, mut context_colliders, mut joints, mut rigidbody_set), handle)) =
+            find_context(&mut context_writer, |res| res.3.entity2body.remove(&entity))
+        else {
+            continue;
+        };
+        let context = &mut *context;
+        let joints = &mut *joints;
+        let rigidbody_set = &mut *rigidbody_set;
+
+        let _ = rigidbody_set.last_body_transform_set.remove(&handle);
+        rigidbody_set.bodies.remove(
+            handle,
+            &mut context.islands,
+            &mut context_colliders.colliders,
+            &mut joints.impulse_joints,
+            &mut joints.multibody_joints,
+            &mut rigidbody_set.soft_bodies,
+            false,
+        );
+    }
+
+    for entity in orphan_bodies.iter() {
+        if let Some(((mut context, mut context_colliders, mut joints, mut rigidbody_set), handle)) =
+            find_context(&mut context_writer, |res| res.3.entity2body.remove(&entity))
+        {
+            let context = &mut *context;
+            let joints = &mut *joints;
+            let rigidbody_set = &mut *rigidbody_set;
+            let _ = rigidbody_set.last_body_transform_set.remove(&handle);
+            rigidbody_set.bodies.remove(
+                handle,
+                &mut context.islands,
+                &mut context_colliders.colliders,
+                &mut joints.impulse_joints,
+                &mut joints.multibody_joints,
+                &mut rigidbody_set.soft_bodies,
+                false,
+            );
+        }
+        commands.entity(entity).remove::<RapierRigidBodyHandle>();
+    }
+
+    /*
+     * Collider removal detection.
+     */
+    for entity in removed_colliders
+        .read()
+        .filter(|e| !q_has_collider_handle.contains(*e))
+    {
+        let Some(((mut context, mut context_colliders, _, mut rigidbody_set), handle)) =
+            find_context(&mut context_writer, |res| {
+                res.1.entity2collider.remove(&entity)
+            })
+        else {
+            continue;
+        };
+        let context = &mut *context;
+        let rigidbody_set = &mut *rigidbody_set;
+        if let Some(parent) = context_colliders.collider_parent(rigidbody_set, entity) {
+            mass_modified.write(parent.into());
+        }
+
+        context_colliders.colliders.remove(
+            handle,
+            &mut context.islands,
+            &mut rigidbody_set.bodies,
+            &mut rigidbody_set.soft_bodies,
+            true,
+        );
+        context.deleted_colliders.insert(handle, entity);
+    }
+
+    for entity in orphan_colliders.iter() {
+        if let Some(((mut context, mut context_colliders, _, mut rigidbody_set), handle)) =
+            find_context(&mut context_writer, |res| {
+                res.1.entity2collider.remove(&entity)
+            })
+        {
+            let context = &mut *context;
+            let context_colliders = &mut *context_colliders;
+            let rigidbody_set = &mut *rigidbody_set;
+            if let Some(parent) = context_colliders.collider_parent(rigidbody_set, entity) {
+                mass_modified.write(parent.into());
+            }
+
+            context_colliders.colliders.remove(
+                handle,
+                &mut context.islands,
+                &mut rigidbody_set.bodies,
+                &mut rigidbody_set.soft_bodies,
+                true,
+            );
+            context.deleted_colliders.insert(handle, entity);
+        }
+        commands.entity(entity).remove::<RapierColliderHandle>();
+    }
+
+    /*
+     * Impulse joint removal detection.
+     */
+    for entity in removed_impulse_joints
+        .read()
+        .filter(|e| !q_has_impulse_joint_handle.contains(*e))
+    {
+        let Some(((_, _, mut joints, _), handle)) = find_context(&mut context_writer, |res| {
+            res.2.entity2impulse_joint.remove(&entity)
+        }) else {
+            continue;
+        };
+        joints.impulse_joints.remove(handle, true);
+    }
+
+    for entity in orphan_impulse_joints.iter() {
+        if let Some(((_, _, mut joints, _), handle)) = find_context(&mut context_writer, |res| {
+            res.2.entity2impulse_joint.remove(&entity)
+        }) {
+            joints.impulse_joints.remove(handle, true);
+        }
+        commands.entity(entity).remove::<RapierImpulseJointHandle>();
+    }
+
+    /*
+     * Multibody joint removal detection.
+     */
+    for entity in removed_multibody_joints
+        .read()
+        .filter(|e| !q_has_multibody_joint_handle.contains(*e))
+    {
+        let Some(((_, _, mut joints, _), handle)) = find_context(&mut context_writer, |res| {
+            res.2.entity2multibody_joint.remove(&entity)
+        }) else {
+            continue;
+        };
+        joints.multibody_joints.remove(handle, true);
+    }
+
+    for entity in orphan_multibody_joints.iter() {
+        if let Some(((_, _, mut joints, _), handle)) = find_context(&mut context_writer, |res| {
+            res.2.entity2multibody_joint.remove(&entity)
+        }) {
+            joints.multibody_joints.remove(handle, true);
+        }
+        commands
+            .entity(entity)
+            .remove::<RapierMultibodyJointHandle>();
+    }
+
+    /*
+     * Marker components removal detection.
+     */
+    for entity in removed_sensors.read() {
+        for (_, mut colliders, _, rigidbody_set) in context_writer.iter_mut() {
+            // A soft body entity stands for all its surface colliders.
+            let handles = rigidbody_set
+                .soft_body_colliders(&colliders.colliders, entity)
+                .or_else(|| colliders.entity2collider.get(&entity).map(|h| vec![*h]));
+            if let Some(handles) = handles {
+                for handle in handles {
+                    if let Some(co) = colliders.colliders.get_mut(handle) {
+                        co.set_sensor(false);
+                    }
+                }
+                break;
+            }
+        }
+    }
+
+    for entity in removed_colliders_disabled.read() {
+        if let Some((mut context, handle)) = find_context(&mut context_writer, |context| {
+            context.1.entity2collider.get(&entity).copied()
+        }) {
+            if let Some(co) = context.1.colliders.get_mut(handle) {
+                co.set_enabled(true);
+            }
+        }
+    }
+
+    // Flag the joint as changed so `apply_joint_user_changes` enables it again.
+    for entity in removed_impulse_joints_disabled.read() {
+        if let Ok(mut joint) = impulse_joints.get_mut(entity) {
+            joint.set_changed();
+        }
+    }
+
+    for entity in removed_rigid_body_disabled.read() {
+        if let Some(((_, _, _, mut rigidbody_set), handle)) =
+            find_context(&mut context_writer, |res| {
+                res.3.entity2body.get(&entity).copied()
+            })
+        {
+            if let Some(rb) = rigidbody_set.bodies.get_mut(handle) {
+                rb.set_enabled(true);
+            }
+        }
+    }
+}
+
+/// Removal detection for a single component: the entities it was removed from, paired with a
+/// query checking if it was re-inserted since.
+type RemovedComponent<'w, 's, T> = (RemovedComponents<'w, 's, T>, Query<'w, 's, (), With<T>>);
+
+/// System responsible for resetting the Rapier rigid-body properties to their default values
+/// when the corresponding `bevy_rapier` component is removed by the user.
+pub fn reset_removed_rigid_body_components(
+    mut rigid_body_sets: Query<&mut RapierRigidBodySet>,
+    (mut removed_forces, mut removed_damping, mut removed_gravity_scale, mut removed_dominance): (
+        RemovedComponent<ExternalForce>,
+        RemovedComponent<Damping>,
+        RemovedComponent<GravityScale>,
+        RemovedComponent<Dominance>,
+    ),
+    (mut removed_ccd, mut removed_soft_ccd, mut removed_fast_rotation): (
+        RemovedComponent<Ccd>,
+        RemovedComponent<SoftCcd>,
+        RemovedComponent<AllowFastRotation>,
+    ),
+    (mut removed_locked_axes, mut removed_mass_props, mut removed_sleeping): (
+        RemovedComponent<LockedAxes>,
+        RemovedComponent<AdditionalMassProperties>,
+        RemovedComponent<Sleeping>,
+    ),
+    (mut removed_solver_iters, mut removed_pgs_iters): (
+        RemovedComponent<AdditionalSolverIterations>,
+        RemovedComponent<AdditionalPgsIterations>,
+    ),
+    #[cfg(feature = "dim3")] mut removed_gyroscopic_forces: RemovedComponent<GyroscopicForces>,
+    mut mass_modified: MessageWriter<MassModifiedEvent>,
+) {
+    let sets = &mut rigid_body_sets;
+    reset_removed(&mut removed_forces, sets, |_, rb| {
+        rb.reset_forces(true);
+        rb.reset_torques(true);
+    });
+    reset_removed(&mut removed_damping, sets, |_, rb| {
+        let default = Damping::default();
+        rb.set_linear_damping(default.linear_damping);
+        rb.set_angular_damping(default.angular_damping);
+    });
+    reset_removed(&mut removed_gravity_scale, sets, |_, rb| {
+        rb.set_gravity_scale(GravityScale::default().0, true);
+    });
+    reset_removed(&mut removed_dominance, sets, |_, rb| {
+        rb.set_dominance_group(Dominance::default().groups);
+    });
+    reset_removed(&mut removed_ccd, sets, |_, rb| {
+        rb.enable_ccd(Ccd::default().enabled);
+    });
+    reset_removed(&mut removed_soft_ccd, sets, |_, rb| {
+        rb.set_soft_ccd_prediction(SoftCcd::default().prediction);
+    });
+    reset_removed(&mut removed_fast_rotation, sets, |_, rb| {
+        rb.set_allow_fast_rotation(false);
+    });
+    reset_removed(&mut removed_locked_axes, sets, |_, rb| {
+        rb.set_locked_axes(LockedAxes::default().into(), true);
+    });
+    reset_removed(&mut removed_mass_props, sets, |entity, rb| {
+        rb.set_additional_mass_properties(MassProperties::default().into_rapier(), true);
+        mass_modified.write(entity.into());
+    });
+    reset_removed(&mut removed_sleeping, sets, |_, rb| {
+        let default = Sleeping::default();
+        let activation = rb.activation_mut();
+        activation.normalized_linear_threshold = default.normalized_linear_threshold;
+        activation.angular_threshold = default.angular_threshold;
+        activation.time_until_sleep = default.time_until_sleep;
+    });
+    reset_removed(&mut removed_solver_iters, sets, |_, rb| {
+        rb.set_additional_solver_iterations(AdditionalSolverIterations::default().0);
+    });
+    reset_removed(&mut removed_pgs_iters, sets, |_, rb| {
+        rb.set_additional_pgs_iterations(AdditionalPgsIterations::default().0);
+    });
+    #[cfg(feature = "dim3")]
+    reset_removed(&mut removed_gyroscopic_forces, sets, |_, rb| {
+        rb.enable_gyroscopic_forces(GyroscopicForces::default().enabled);
+    });
+}
+
+/// Calls `reset` on the Rapier rigid-body of each entity `T` was removed from, unless `T` was
+/// inserted back since.
+fn reset_removed<T: Component>(
+    (removed, still_present): &mut RemovedComponent<T>,
+    rigid_body_sets: &mut Query<&mut RapierRigidBodySet>,
+    mut reset: impl FnMut(Entity, &mut rapier::dynamics::RigidBody),
+) {
+    for entity in removed.read() {
+        if still_present.contains(entity) {
+            continue;
+        }
+
+        for mut rigid_body_set in rigid_body_sets.iter_mut() {
+            if let Some(handle) = rigid_body_set.entity2body.get(&entity).copied() {
+                if let Some(rb) = rigid_body_set.bodies.get_mut(handle) {
+                    reset(entity, rb);
+                }
+                break;
+            }
+        }
+    }
+}
+
+/// System responsible for resetting the Rapier collider properties to their default values when
+/// the corresponding `bevy_rapier` component is removed by the user.
+///
+/// The default values are the ones a collider gets when inserted without that component.
+pub fn reset_removed_collider_components(
+    mut contexts: Query<(&mut RapierContextColliders, &RapierRigidBodySet)>,
+    soft_bodies: Query<&SoftBody>,
+    (mut removed_friction, mut removed_restitution, mut removed_contact_skin): (
+        RemovedComponent<Friction>,
+        RemovedComponent<Restitution>,
+        RemovedComponent<ContactSkin>,
+    ),
+    (mut removed_collision_groups, mut removed_solver_groups): (
+        RemovedComponent<CollisionGroups>,
+        RemovedComponent<SolverGroups>,
+    ),
+    (mut removed_events, mut removed_hooks, mut removed_collision_types): (
+        RemovedComponent<ActiveEvents>,
+        RemovedComponent<ActiveHooks>,
+        RemovedComponent<ActiveCollisionTypes>,
+    ),
+    (mut removed_force_threshold, mut removed_mass_props): (
+        RemovedComponent<ContactForceEventThreshold>,
+        RemovedComponent<ColliderMassProperties>,
+    ),
+    mut read_mass_props: Query<&mut ReadColliderMassProperties>,
+    mut mass_modified: MessageWriter<MassModifiedEvent>,
+) {
+    let ctxts = &mut contexts;
+    let sbs = &soft_bodies;
+    reset_removed_collider(&mut removed_friction, ctxts, sbs, |_, co, _, defaults| {
+        co.set_friction(defaults.friction);
+        co.set_friction_combine_rule(defaults.friction_combine_rule);
+    });
+    reset_removed_collider(
+        &mut removed_restitution,
+        ctxts,
+        sbs,
+        |_, co, _, defaults| {
+            co.set_restitution(defaults.restitution);
+            co.set_restitution_combine_rule(defaults.restitution_combine_rule);
+        },
+    );
+    reset_removed_collider(
+        &mut removed_contact_skin,
+        ctxts,
+        sbs,
+        |entity, co, rigid_body_set, defaults| {
+            // The surface colliders of a soft body are as thick as its particles.
+            let skin = rigid_body_set
+                .soft_body(entity)
+                .map_or(defaults.contact_skin, |sb| sb.particle_radius());
+            co.set_contact_skin(skin);
+        },
+    );
+    reset_removed_collider(
+        &mut removed_collision_groups,
+        ctxts,
+        sbs,
+        |_, co, _, defaults| {
+            co.set_collision_groups(defaults.collision_groups);
+        },
+    );
+    reset_removed_collider(
+        &mut removed_solver_groups,
+        ctxts,
+        sbs,
+        |_, co, _, defaults| {
+            co.set_solver_groups(defaults.solver_groups);
+        },
+    );
+    reset_removed_collider(&mut removed_events, ctxts, sbs, |_, co, _, defaults| {
+        co.set_active_events(defaults.active_events);
+    });
+    reset_removed_collider(&mut removed_hooks, ctxts, sbs, |_, co, _, defaults| {
+        co.set_active_hooks(defaults.active_hooks);
+    });
+    reset_removed_collider(
+        &mut removed_collision_types,
+        ctxts,
+        sbs,
+        |_, co, _, defaults| {
+            co.set_active_collision_types(defaults.active_collision_types);
+        },
+    );
+    reset_removed_collider(
+        &mut removed_force_threshold,
+        ctxts,
+        sbs,
+        |_, co, _, defaults| {
+            co.set_contact_force_event_threshold(defaults.contact_force_event_threshold);
+        },
+    );
+    reset_removed_collider(
+        &mut removed_mass_props,
+        ctxts,
+        sbs,
+        |entity, co, rigid_body_set, _| {
+            // The surface colliders of a soft body have no mass.
+            if rigid_body_set.soft_body(entity).is_some() {
+                return;
+            }
+            co.set_density(rapier::geometry::ColliderBuilder::default_density());
+
+            if let Ok(mut read_mass_props) = read_mass_props.get_mut(entity) {
+                read_mass_props.set_if_neq(ReadColliderMassProperties::from_rapier(co));
+            }
+
+            if let Some(body_entity) = co
+                .parent()
+                .and_then(|h| rigid_body_set.rigid_body_entity(h))
+            {
+                mass_modified.write(body_entity.into());
+            }
+        },
+    );
+}
+
+/// Calls `reset` on the Rapier collider of each entity `T` was removed from, unless `T` was
+/// inserted back since.
+///
+/// For a soft body entity, `reset` is called on each of its surface colliders (see
+/// [`RapierRigidBodySet::soft_body_colliders`]), with the collider template of its builder as
+/// defaults.
+fn reset_removed_collider<T: Component>(
+    (removed, still_present): &mut RemovedComponent<T>,
+    contexts: &mut Query<(&mut RapierContextColliders, &RapierRigidBodySet)>,
+    soft_bodies: &Query<&SoftBody>,
+    mut reset: impl FnMut(
+        Entity,
+        &mut rapier::geometry::Collider,
+        &RapierRigidBodySet,
+        &rapier::geometry::ColliderBuilder,
+    ),
+) {
+    let defaults = rapier::geometry::ColliderBuilder::default();
+    for entity in removed.read() {
+        if still_present.contains(entity) {
+            continue;
+        }
+
+        for (mut context_colliders, rigid_body_set) in contexts.iter_mut() {
+            if let Some(handles) =
+                rigid_body_set.soft_body_colliders(&context_colliders.colliders, entity)
+            {
+                let template = soft_bodies
+                    .get(entity)
+                    .ok()
+                    .and_then(|sb| sb.builder.collider_template.as_ref())
+                    .unwrap_or(&defaults);
+                for handle in handles {
+                    if let Some(co) = context_colliders.colliders.get_mut(handle) {
+                        reset(entity, co, rigid_body_set, template);
+                    }
+                }
+                break;
+            }
+            if let Some(handle) = context_colliders.entity2collider.get(&entity).copied() {
+                if let Some(co) = context_colliders.colliders.get_mut(handle) {
+                    reset(entity, co, rigid_body_set, &defaults);
+                }
+                break;
+            }
+        }
+    }
+}
+
+fn find_context<'a, TReturn, TQueryParams: IterQueryData>(
+    context_writer: &'a mut Query<TQueryParams>,
+    item_finder: impl Fn(&mut TQueryParams::Item<'_, '_>) -> Option<TReturn>,
+) -> Option<(TQueryParams::Item<'a, 'a>, TReturn)> {
+    let ret: Option<(TQueryParams::Item<'_, '_>, TReturn)> = context_writer
+        .iter_mut()
+        .find_map(|mut context| item_finder(&mut context).map(|handle| (context, handle)));
+    ret
+}
diff --git a/bindings/bevy_rapier/src/plugin/systems/rigid_body.rs b/bindings/bevy_rapier/src/plugin/systems/rigid_body.rs
new file mode 100644
index 000000000..e11fe2972
--- /dev/null
+++ b/bindings/bevy_rapier/src/plugin/systems/rigid_body.rs
@@ -0,0 +1,1074 @@
+use crate::dynamics::RapierRigidBodyHandle;
+use crate::plugin::context::systemparams::RAPIER_CONTEXT_EXPECT_ERROR;
+use crate::plugin::context::{
+    RapierContextColliders, RapierContextEntityLink, RapierContextSimulation, RapierRigidBodySet,
+};
+use crate::plugin::{configuration::TimestepMode, RapierConfiguration};
+use crate::{dynamics::RigidBody, plugin::context::SimulationToRenderTime};
+use crate::{prelude::*, utils};
+use bevy::prelude::*;
+
+use super::RapierContextLinkResolver;
+use rapier::dynamics::{RigidBodyBuilder, RigidBodyHandle, RigidBodyType};
+use std::collections::HashMap;
+
+/// Components that will be updated after a physics step.
+pub type RigidBodyWritebackComponents<'a> = (
+    &'a RapierRigidBodyHandle,
+    &'a RapierContextEntityLink,
+    Option<&'a ChildOf>,
+    Option<&'a mut Transform>,
+    Option<&'a mut TransformInterpolation>,
+    Option<&'a mut Velocity>,
+    Option<&'a mut Sleeping>,
+    Option<&'a mut ReadWorldMassProperties>,
+);
+
+/// Components related to rigid-bodies.
+pub type RigidBodyComponents<'a> = (
+    (Entity, Option<&'a RapierContextEntityLink>),
+    &'a RigidBody,
+    Option<&'a GlobalTransform>,
+    Option<&'a Velocity>,
+    Option<&'a AdditionalMassProperties>,
+    Option<&'a ReadMassProperties>,
+    Option<&'a LockedAxes>,
+    Option<&'a ExternalForce>,
+    Option<&'a GravityScale>,
+    (Option<&'a Ccd>, Option<&'a SoftCcd>),
+    Option<&'a Dominance>,
+    Option<&'a Sleeping>,
+    Option<&'a Damping>,
+    Option<&'a RigidBodyDisabled>,
+    (
+        Option<&'a AdditionalSolverIterations>,
+        Option<&'a AdditionalPgsIterations>,
+        Option<&'a AllowFastRotation>,
+    ),
+);
+
+/// System responsible for applying changes the user made to a rigid-body-related component.
+pub fn apply_rigid_body_user_changes(
+    (mut rigid_body_sets, mut context_simulations): (
+        Query<&mut RapierRigidBodySet>,
+        Query<&mut RapierContextSimulation>,
+    ),
+    config: Query<&RapierConfiguration>,
+    changed_rb_types: Query<
+        (&RapierRigidBodyHandle, &RapierContextEntityLink, &RigidBody),
+        Changed<RigidBody>,
+    >,
+    mut changed_transforms: Query<
+        (
+            &RapierRigidBodyHandle,
+            &RapierContextEntityLink,
+            &GlobalTransform,
+            Option<&mut TransformInterpolation>,
+        ),
+        Changed<GlobalTransform>,
+    >,
+    changed_velocities: Query<
+        (&RapierRigidBodyHandle, &RapierContextEntityLink, &Velocity),
+        Changed<Velocity>,
+    >,
+    changed_additional_mass_props: Query<
+        (
+            Entity,
+            &RapierContextEntityLink,
+            &RapierRigidBodyHandle,
+            &AdditionalMassProperties,
+        ),
+        Changed<AdditionalMassProperties>,
+    >,
+    changed_locked_axes: Query<
+        (
+            &RapierRigidBodyHandle,
+            &RapierContextEntityLink,
+            &LockedAxes,
+        ),
+        Changed<LockedAxes>,
+    >,
+    changed_forces: Query<
+        (
+            &RapierRigidBodyHandle,
+            &RapierContextEntityLink,
+            &ExternalForce,
+        ),
+        Changed<ExternalForce>,
+    >,
+    mut changed_impulses: Query<
+        (
+            &RapierRigidBodyHandle,
+            &RapierContextEntityLink,
+            &mut ExternalImpulse,
+        ),
+        Changed<ExternalImpulse>,
+    >,
+    changed_gravity_scale: Query<
+        (
+            &RapierRigidBodyHandle,
+            &RapierContextEntityLink,
+            &GravityScale,
+        ),
+        Changed<GravityScale>,
+    >,
+    (changed_ccd, changed_soft_ccd): (
+        Query<(&RapierRigidBodyHandle, &RapierContextEntityLink, &Ccd), Changed<Ccd>>,
+        Query<(&RapierRigidBodyHandle, &RapierContextEntityLink, &SoftCcd), Changed<SoftCcd>>,
+    ),
+    (changed_dominance, changed_damping): (
+        Query<(&RapierRigidBodyHandle, &RapierContextEntityLink, &Dominance), Changed<Dominance>>,
+        Query<(&RapierRigidBodyHandle, &RapierContextEntityLink, &Damping), Changed<Damping>>,
+    ),
+    changed_sleeping: Query<
+        (&RapierRigidBodyHandle, &RapierContextEntityLink, &Sleeping),
+        Changed<Sleeping>,
+    >,
+    (
+        changed_disabled,
+        changed_additional_solver_iterations,
+        changed_additional_pgs_iterations,
+        changed_fast_rotation,
+    ): (
+        Query<
+            (
+                &RapierRigidBodyHandle,
+                &RapierContextEntityLink,
+                &RigidBodyDisabled,
+            ),
+            Changed<RigidBodyDisabled>,
+        >,
+        Query<
+            (
+                &RapierRigidBodyHandle,
+                &RapierContextEntityLink,
+                &AdditionalSolverIterations,
+            ),
+            Changed<AdditionalSolverIterations>,
+        >,
+        Query<
+            (
+                &RapierRigidBodyHandle,
+                &RapierContextEntityLink,
+                &AdditionalPgsIterations,
+            ),
+            Changed<AdditionalPgsIterations>,
+        >,
+        Query<(&RapierRigidBodyHandle, &RapierContextEntityLink), Changed<AllowFastRotation>>,
+    ),
+    #[cfg(feature = "dim3")] changed_gyroscopic_forces: Query<
+        (
+            &RapierRigidBodyHandle,
+            &RapierContextEntityLink,
+            &GyroscopicForces,
+        ),
+        Changed<GyroscopicForces>,
+    >,
+    mut mass_modified: MessageWriter<MassModifiedEvent>,
+) {
+    // Deal with sleeping first, because other changes may then wake-up the
+    // rigid-body again.
+    for (handle, link, sleeping) in changed_sleeping.iter() {
+        let rigidbody_set = rigid_body_sets
+            .get_mut(link.0)
+            .expect(RAPIER_CONTEXT_EXPECT_ERROR)
+            .into_inner();
+
+        let mut wake_up_island = false;
+        if let Some(rb) = rigidbody_set.bodies.get_mut(handle.0) {
+            let activation = rb.activation_mut();
+            activation.normalized_linear_threshold = sleeping.normalized_linear_threshold;
+            activation.angular_threshold = sleeping.angular_threshold;
+            activation.time_until_sleep = sleeping.time_until_sleep;
+
+            if !sleeping.sleeping && activation.sleeping {
+                rb.wake_up(true);
+                wake_up_island = true;
+            } else if sleeping.sleeping && !activation.sleeping {
+                rb.sleep();
+            }
+        }
+
+        if wake_up_island {
+            // Wake up the whole island, not only this body.
+            let mut context = context_simulations
+                .get_mut(link.0)
+                .expect(RAPIER_CONTEXT_EXPECT_ERROR);
+            context
+                .islands
+                .wake_up(&mut rigidbody_set.bodies, handle.0, true);
+        }
+    }
+
+    // NOTE: we must change the rigid-body type before updating the
+    //       transform or velocity. Otherwise, if the rigid-body was fixed
+    //       and changed to anything else, the velocity change wouldn’t have any effect.
+    //       Similarly, if the rigid-body was kinematic position-based before and
+    //       changed to anything else, a transform change would modify the next
+    //       position instead of the current one.
+    for (handle, link, rb_type) in changed_rb_types.iter() {
+        let context = rigid_body_sets
+            .get_mut(link.0)
+            .expect(RAPIER_CONTEXT_EXPECT_ERROR)
+            .into_inner();
+        if let Some(rb) = context.bodies.get_mut(handle.0) {
+            // The type of a soft-body cluster proxy is managed by Rapier.
+            if !rb.is_soft_frame() {
+                rb.set_body_type((*rb_type).into(), true);
+            }
+        }
+    }
+
+    // Manually checks if the transform changed.
+    // This is needed for detecting if the user actually changed the rigid-body
+    // transform, or if it was just the change we made in our `writeback_rigid_bodies`
+    // system.
+    let transform_changed_fn =
+        |handle: &RigidBodyHandle,
+         config: &RapierConfiguration,
+         transform: &GlobalTransform,
+         last_transform_set: &HashMap<RigidBodyHandle, GlobalTransform>| {
+            if config.force_update_from_transform_changes {
+                true
+            } else if let Some(prev) = last_transform_set.get(handle) {
+                *prev != *transform
+            } else {
+                true
+            }
+        };
+
+    for (handle, link, global_transform, mut interpolation) in changed_transforms.iter_mut() {
+        let rigidbody_set = rigid_body_sets
+            .get_mut(link.0)
+            .expect(RAPIER_CONTEXT_EXPECT_ERROR)
+            .into_inner();
+        let config = config
+            .get(link.0)
+            .expect("Could not get `RapierConfiguration`");
+        // Use an Option<bool> to avoid running the check twice.
+        let mut transform_changed = None;
+
+        if let Some(interpolation) = interpolation.as_deref_mut() {
+            transform_changed = transform_changed.or_else(|| {
+                Some(transform_changed_fn(
+                    &handle.0,
+                    config,
+                    global_transform,
+                    &rigidbody_set.last_body_transform_set,
+                ))
+            });
+
+            if transform_changed == Some(true) {
+                // Reset the interpolation so we don’t overwrite
+                // the user’s input.
+                interpolation.start = None;
+                interpolation.end = None;
+            }
+        }
+        // TODO: avoid to run multiple times the mutable deref ?
+        if let Some(rb) = rigidbody_set.bodies.get_mut(handle.0) {
+            // The pose of a soft-body cluster proxy follows its particles: it is written back
+            // to the transform, but never read from it.
+            if rb.is_soft_frame() {
+                continue;
+            }
+            transform_changed = transform_changed.or_else(|| {
+                Some(transform_changed_fn(
+                    &handle.0,
+                    config,
+                    global_transform,
+                    &rigidbody_set.last_body_transform_set,
+                ))
+            });
+
+            match rb.body_type() {
+                RigidBodyType::KinematicPositionBased => {
+                    if transform_changed == Some(true) {
+                        rb.set_next_kinematic_position(utils::transform_to_iso(
+                            &global_transform.compute_transform(),
+                        ));
+                        rigidbody_set
+                            .last_body_transform_set
+                            .insert(handle.0, *global_transform);
+                    }
+                }
+                _ => {
+                    if transform_changed == Some(true) {
+                        rb.set_position(
+                            utils::transform_to_iso(&global_transform.compute_transform()),
+                            true,
+                        );
+                        rigidbody_set
+                            .last_body_transform_set
+                            .insert(handle.0, *global_transform);
+                    }
+                }
+            }
+        }
+    }
+
+    for (handle, link, velocity) in changed_velocities.iter() {
+        let rigidbody_set = rigid_body_sets
+            .get_mut(link.0)
+            .expect(RAPIER_CONTEXT_EXPECT_ERROR)
+            .into_inner();
+        if let Some(rb) = rigidbody_set.bodies.get_mut(handle.0) {
+            // The velocity of a soft-body cluster proxy follows its particles.
+            if rb.is_soft_frame() {
+                continue;
+            }
+            rb.set_linvel(velocity.linear, true);
+            #[allow(clippy::useless_conversion)] // Need to convert if dim3 enabled
+            rb.set_angvel(velocity.angular.into(), true);
+        }
+    }
+
+    for (entity, link, handle, mprops) in changed_additional_mass_props.iter() {
+        let rigidbody_set = rigid_body_sets
+            .get_mut(link.0)
+            .expect(RAPIER_CONTEXT_EXPECT_ERROR)
+            .into_inner();
+        if let Some(rb) = rigidbody_set.bodies.get_mut(handle.0) {
+            match mprops {
+                AdditionalMassProperties::MassProperties(mprops) => {
+                    rb.set_additional_mass_properties(mprops.into_rapier(), true);
+                }
+                AdditionalMassProperties::Mass(mass) => {
+                    rb.set_additional_mass(*mass, true);
+                }
+            }
+
+            mass_modified.write(entity.into());
+        }
+    }
+
+    for (handle, link, additional_solver_iters) in changed_additional_solver_iterations.iter() {
+        let rigidbody_set = rigid_body_sets
+            .get_mut(link.0)
+            .expect(RAPIER_CONTEXT_EXPECT_ERROR)
+            .into_inner();
+        if let Some(rb) = rigidbody_set.bodies.get_mut(handle.0) {
+            rb.set_additional_solver_iterations(additional_solver_iters.0);
+        }
+    }
+
+    for (handle, link, additional_pgs_iters) in changed_additional_pgs_iterations.iter() {
+        let rigidbody_set = rigid_body_sets
+            .get_mut(link.0)
+            .expect(RAPIER_CONTEXT_EXPECT_ERROR)
+            .into_inner();
+        if let Some(rb) = rigidbody_set.bodies.get_mut(handle.0) {
+            rb.set_additional_pgs_iterations(additional_pgs_iters.0);
+        }
+    }
+
+    for (handle, link) in changed_fast_rotation.iter() {
+        let rigidbody_set = rigid_body_sets
+            .get_mut(link.0)
+            .expect(RAPIER_CONTEXT_EXPECT_ERROR)
+            .into_inner();
+        if let Some(rb) = rigidbody_set.bodies.get_mut(handle.0) {
+            rb.set_allow_fast_rotation(true);
+        }
+    }
+
+    #[cfg(feature = "dim3")]
+    for (handle, link, gyroscopic_forces) in changed_gyroscopic_forces.iter() {
+        let rigidbody_set = rigid_body_sets
+            .get_mut(link.0)
+            .expect(RAPIER_CONTEXT_EXPECT_ERROR)
+            .into_inner();
+        if let Some(rb) = rigidbody_set.bodies.get_mut(handle.0) {
+            rb.enable_gyroscopic_forces(gyroscopic_forces.enabled);
+        }
+    }
+
+    for (handle, link, locked_axes) in changed_locked_axes.iter() {
+        let rigidbody_set = rigid_body_sets
+            .get_mut(link.0)
+            .expect(RAPIER_CONTEXT_EXPECT_ERROR)
+            .into_inner();
+        if let Some(rb) = rigidbody_set.bodies.get_mut(handle.0) {
+            rb.set_locked_axes((*locked_axes).into(), true);
+        }
+    }
+
+    for (handle, link, forces) in changed_forces.iter() {
+        let rigidbody_set = rigid_body_sets
+            .get_mut(link.0)
+            .expect(RAPIER_CONTEXT_EXPECT_ERROR)
+            .into_inner();
+        if let Some(rb) = rigidbody_set.bodies.get_mut(handle.0) {
+            rb.reset_forces(true);
+            rb.reset_torques(true);
+            rb.add_force(forces.force, true);
+            #[allow(clippy::useless_conversion)] // Need to convert if dim3 enabled
+            rb.add_torque(forces.torque.into(), true);
+        }
+    }
+
+    for (handle, link, mut impulses) in changed_impulses.iter_mut() {
+        let rigidbody_set = rigid_body_sets
+            .get_mut(link.0)
+            .expect(RAPIER_CONTEXT_EXPECT_ERROR)
+            .into_inner();
+        if let Some(rb) = rigidbody_set.bodies.get_mut(handle.0) {
+            rb.apply_impulse(impulses.impulse, true);
+            #[allow(clippy::useless_conversion)] // Need to convert if dim3 enabled
+            rb.apply_torque_impulse(impulses.torque_impulse.into(), true);
+            impulses.reset();
+        }
+    }
+
+    for (handle, link, gravity_scale) in changed_gravity_scale.iter() {
+        let rigidbody_set = rigid_body_sets
+            .get_mut(link.0)
+            .expect(RAPIER_CONTEXT_EXPECT_ERROR)
+            .into_inner();
+        if let Some(rb) = rigidbody_set.bodies.get_mut(handle.0) {
+            rb.set_gravity_scale(gravity_scale.0, true);
+        }
+    }
+
+    for (handle, link, ccd) in changed_ccd.iter() {
+        let rigidbody_set = rigid_body_sets
+            .get_mut(link.0)
+            .expect(RAPIER_CONTEXT_EXPECT_ERROR)
+            .into_inner();
+        if let Some(rb) = rigidbody_set.bodies.get_mut(handle.0) {
+            rb.enable_ccd(ccd.enabled);
+        }
+    }
+
+    for (handle, link, soft_ccd) in changed_soft_ccd.iter() {
+        let rigidbody_set = rigid_body_sets
+            .get_mut(link.0)
+            .expect(RAPIER_CONTEXT_EXPECT_ERROR)
+            .into_inner();
+        if let Some(rb) = rigidbody_set.bodies.get_mut(handle.0) {
+            rb.set_soft_ccd_prediction(soft_ccd.prediction);
+        }
+    }
+
+    for (handle, link, dominance) in changed_dominance.iter() {
+        let rigidbody_set = rigid_body_sets
+            .get_mut(link.0)
+            .expect(RAPIER_CONTEXT_EXPECT_ERROR)
+            .into_inner();
+        if let Some(rb) = rigidbody_set.bodies.get_mut(handle.0) {
+            rb.set_dominance_group(dominance.groups);
+        }
+    }
+
+    for (handle, link, damping) in changed_damping.iter() {
+        let rigidbody_set = rigid_body_sets
+            .get_mut(link.0)
+            .expect(RAPIER_CONTEXT_EXPECT_ERROR)
+            .into_inner();
+        if let Some(rb) = rigidbody_set.bodies.get_mut(handle.0) {
+            rb.set_linear_damping(damping.linear_damping);
+            rb.set_angular_damping(damping.angular_damping);
+        }
+    }
+
+    for (handle, link, _) in changed_disabled.iter() {
+        let rigidbody_set = rigid_body_sets
+            .get_mut(link.0)
+            .expect(RAPIER_CONTEXT_EXPECT_ERROR)
+            .into_inner();
+        if let Some(co) = rigidbody_set.bodies.get_mut(handle.0) {
+            co.set_enabled(false);
+        }
+    }
+}
+
+/// System responsible for writing the result of the last simulation step into our `bevy_rapier`
+/// components and the [`GlobalTransform`] component.
+pub fn writeback_rigid_bodies(
+    mut rigid_body_sets: Query<&mut RapierRigidBodySet>,
+    timestep_mode: Res<TimestepMode>,
+    config: Query<&RapierConfiguration>,
+    sim_to_render_time: Query<&SimulationToRenderTime>,
+    global_transforms: Query<&GlobalTransform>,
+    mut writeback: Query<
+        RigidBodyWritebackComponents,
+        (With<RigidBody>, Without<RigidBodyDisabled>),
+    >,
+) {
+    for (
+        handle,
+        link,
+        child_of,
+        transform,
+        mut interpolation,
+        mut velocity,
+        mut sleeping,
+        mut world_mass_props,
+    ) in writeback.iter_mut()
+    {
+        let config = config
+            .get(link.0)
+            .expect("Could not get `RapierConfiguration`");
+        if !config.physics_pipeline_active {
+            continue;
+        }
+        let handle = handle.0;
+
+        let rigid_body_set = rigid_body_sets
+            .get_mut(link.0)
+            .expect(RAPIER_CONTEXT_EXPECT_ERROR)
+            .into_inner();
+        let sim_to_render_time = sim_to_render_time
+            .get(link.0)
+            .expect("Could not get `SimulationToRenderTime`");
+        // TODO: do this the other way round: iterate through Rapier’s RigidBodySet on the active bodies,
+        // and update the components accordingly. That way, we don’t have to iterate through the entities that weren’t changed
+        // by physics (for example because they are sleeping).
+        if let Some(rb) = rigid_body_set.bodies.get(handle) {
+            let mut interpolated_pos = utils::iso_to_transform(rb.position());
+
+            if let TimestepMode::Interpolated { dt, .. } = *timestep_mode {
+                if let Some(interpolation) = interpolation.as_deref_mut() {
+                    if interpolation.end.is_none() {
+                        interpolation.end = Some(*rb.position());
+                    }
+
+                    if let Some(interpolated) =
+                        interpolation.lerp_slerp((dt + sim_to_render_time.diff) / dt)
+                    {
+                        interpolated_pos = utils::iso_to_transform(&interpolated);
+                    }
+                }
+            }
+
+            if let Some(mut transform) = transform {
+                // NOTE: Rapier's `RigidBody` doesn't know its own scale as it is encoded
+                //       directly within its collider, so we have to retrieve it from
+                //       the scale of its bevy transform.
+                interpolated_pos = interpolated_pos.with_scale(transform.scale);
+
+                // NOTE: we query the parent’s global transform here, which is a bit
+                //       unfortunate (performance-wise). An alternative would be to
+                //       deduce the parent’s global transform from the current entity’s
+                //       global transform. However, this makes it nearly impossible
+                //       (because of rounding errors) to predict the exact next value this
+                //       entity’s global transform will get after the next transform
+                //       propagation, which breaks our transform modification detection
+                //       that we do to detect if the user’s transform has to be written
+                //       into the rigid-body.
+                if let Some(parent_global_transform) =
+                    child_of.and_then(|c| global_transforms.get(c.parent()).ok())
+                {
+                    // We need to compute the new local transform such that:
+                    // curr_parent_global_transform * new_transform = interpolated_pos
+                    // new_transform = curr_parent_global_transform.inverse() * interpolated_pos
+                    let (inverse_parent_scale, inverse_parent_rotation, inverse_parent_translation) =
+                        parent_global_transform
+                            .affine()
+                            .inverse()
+                            .to_scale_rotation_translation();
+                    let new_rotation = inverse_parent_rotation * interpolated_pos.rotation;
+
+                    #[allow(unused_mut)] // mut is needed in 2D but not in 3D.
+                    let mut new_translation = inverse_parent_rotation
+                        * inverse_parent_scale
+                        * interpolated_pos.translation
+                        + inverse_parent_translation;
+
+                    // In 2D, preserve the transform `z` component that may have been set by the user
+                    #[cfg(feature = "dim2")]
+                    {
+                        new_translation.z = transform.translation.z;
+                    }
+
+                    if transform.rotation != new_rotation
+                        || transform.translation != new_translation
+                    {
+                        // NOTE: we write the new value only if there was an
+                        //       actual change, in order to not trigger bevy’s
+                        //       change tracking when the values didn’t change.
+                        transform.rotation = new_rotation;
+                        transform.translation = new_translation;
+                    }
+
+                    // NOTE: we need to compute the result of the next transform propagation
+                    //       to make sure that our change detection for transforms is exact
+                    //       despite rounding errors.
+                    let new_global_transform = parent_global_transform.mul_transform(*transform);
+
+                    rigid_body_set
+                        .last_body_transform_set
+                        .insert(handle, new_global_transform);
+                } else {
+                    // In 2D, preserve the transform `z` component that may have been set by the user
+                    #[cfg(feature = "dim2")]
+                    {
+                        interpolated_pos.translation.z = transform.translation.z;
+                    }
+
+                    if transform.rotation != interpolated_pos.rotation
+                        || transform.translation != interpolated_pos.translation
+                    {
+                        // NOTE: we write the new value only if there was an
+                        //       actual change, in order to not trigger bevy’s
+                        //       change tracking when the values didn’t change.
+                        transform.rotation = interpolated_pos.rotation;
+                        transform.translation = interpolated_pos.translation;
+                    }
+
+                    rigid_body_set
+                        .last_body_transform_set
+                        .insert(handle, GlobalTransform::from(interpolated_pos));
+                }
+            }
+
+            if let Some(velocity) = &mut velocity {
+                let new_vel = Velocity {
+                    linear: rb.linvel(),
+                    #[cfg(feature = "dim3")]
+                    angular: rb.angvel(),
+                    #[cfg(feature = "dim2")]
+                    angular: rb.angvel(),
+                };
+
+                // NOTE: we write the new value only if there was an
+                //       actual change, in order to not trigger bevy’s
+                //       change tracking when the values didn’t change.
+                if **velocity != new_vel {
+                    **velocity = new_vel;
+                }
+            }
+
+            if let Some(sleeping) = &mut sleeping {
+                // NOTE: we write the new value only if there was an
+                //       actual change, in order to not trigger bevy’s
+                //       change tracking when the values didn’t change.
+                if sleeping.sleeping != rb.is_sleeping() {
+                    sleeping.sleeping = rb.is_sleeping();
+                }
+            }
+
+            if let Some(world_mass_props) = &mut world_mass_props {
+                let new_props = ReadWorldMassProperties::from_rapier(rb.mass_properties());
+
+                // NOTE: we write the new value only if there was an
+                //       actual change, in order to not trigger bevy’s
+                //       change tracking when the values didn’t change.
+                if **world_mass_props != new_props {
+                    **world_mass_props = new_props;
+                }
+            }
+        }
+    }
+}
+
+/// System responsible for creating new Rapier rigid-bodies from the related `bevy_rapier` components.
+pub fn init_rigid_bodies(
+    mut commands: Commands,
+    context_links: RapierContextLinkResolver,
+    mut rigidbody_sets: Query<(Entity, &mut RapierRigidBodySet)>,
+    rigid_bodies: Query<RigidBodyComponents, Without<RapierRigidBodyHandle>>,
+    #[cfg(feature = "dim3")] gyroscopic_forces: Query<&GyroscopicForces>,
+) {
+    for (
+        (entity, entity_context_link),
+        rb,
+        transform,
+        vel,
+        additional_mass_props,
+        _mass_props,
+        locked_axes,
+        force,
+        gravity_scale,
+        (ccd, soft_ccd),
+        dominance,
+        sleep,
+        damping,
+        disabled,
+        (additional_solver_iters, additional_pgs_iters, fast_rotation),
+    ) in rigid_bodies.iter()
+    {
+        let mut builder = RigidBodyBuilder::new((*rb).into());
+        builder = builder.enabled(disabled.is_none());
+
+        if let Some(transform) = transform {
+            builder = builder.pose(utils::transform_to_iso(&transform.compute_transform()));
+        }
+
+        #[allow(clippy::useless_conversion)] // Need to convert if dim3 enabled
+        if let Some(vel) = vel {
+            builder = builder.linvel(vel.linear.into()).angvel(vel.angular.into());
+        }
+
+        if let Some(locked_axes) = locked_axes {
+            builder = builder.locked_axes((*locked_axes).into())
+        }
+
+        if let Some(gravity_scale) = gravity_scale {
+            builder = builder.gravity_scale(gravity_scale.0);
+        }
+
+        if let Some(ccd) = ccd {
+            builder = builder.ccd_enabled(ccd.enabled)
+        }
+
+        if let Some(soft_ccd) = soft_ccd {
+            builder = builder.soft_ccd_prediction(soft_ccd.prediction)
+        }
+
+        if let Some(dominance) = dominance {
+            builder = builder.dominance_group(dominance.groups)
+        }
+
+        if let Some(sleep) = sleep {
+            builder = builder.sleeping(sleep.sleeping);
+        }
+
+        if let Some(damping) = damping {
+            builder = builder
+                .linear_damping(damping.linear_damping)
+                .angular_damping(damping.angular_damping);
+        }
+
+        if let Some(mprops) = additional_mass_props {
+            builder = match mprops {
+                AdditionalMassProperties::MassProperties(mprops) => {
+                    builder.additional_mass_properties(mprops.into_rapier())
+                }
+                AdditionalMassProperties::Mass(mass) => builder.additional_mass(*mass),
+            };
+        }
+
+        if let Some(added_iters) = additional_solver_iters {
+            builder = builder.additional_solver_iterations(added_iters.0);
+        }
+
+        if let Some(added_iters) = additional_pgs_iters {
+            builder = builder.additional_pgs_iterations(added_iters.0);
+        }
+
+        if fast_rotation.is_some() {
+            builder = builder.allow_fast_rotation(true);
+        }
+
+        #[cfg(feature = "dim3")]
+        if let Ok(gyroscopic_forces) = gyroscopic_forces.get(entity) {
+            builder = builder.gyroscopic_forces_enabled(gyroscopic_forces.enabled);
+        }
+
+        builder = builder.user_data(entity.to_bits() as u128);
+
+        let mut rb = builder.build();
+
+        #[allow(clippy::useless_conversion)] // Need to convert if dim3 enabled
+        if let Some(force) = force {
+            rb.add_force(force.force.into(), false);
+            rb.add_torque(force.torque.into(), false);
+        }
+
+        // NOTE: we can’t apply impulses yet at this point because
+        //       the rigid-body’s mass isn’t up-to-date yet (its
+        //       attached colliders, if any, haven’t been created yet).
+
+        if let Some(sleep) = sleep {
+            let activation = rb.activation_mut();
+            activation.normalized_linear_threshold = sleep.normalized_linear_threshold;
+            activation.angular_threshold = sleep.angular_threshold;
+            activation.time_until_sleep = sleep.time_until_sleep;
+        }
+        // Use the RapierContextEntityLink, or insert the context of an ancestor or the default one.
+        let context_entity = context_links.resolve(entity, entity_context_link, &mut commands);
+        let Some(context_entity) = context_entity else {
+            continue;
+        };
+
+        let Ok((_, mut rigidbody_set)) = rigidbody_sets.get_mut(context_entity) else {
+            log::error!("Could not find entity {context_entity} with rapier context while initializing {entity}");
+            continue;
+        };
+        let handle = rigidbody_set.bodies.insert(rb);
+        commands
+            .entity(entity)
+            .insert(RapierRigidBodyHandle(handle));
+        rigidbody_set.entity2body.insert(entity, handle);
+
+        if let Some(transform) = transform {
+            rigidbody_set
+                .last_body_transform_set
+                .insert(handle, *transform);
+        }
+    }
+}
+
+/// This applies the initial impulse given to a rigid-body when it is created.
+///
+/// This cannot be done inside `init_rigid_bodies` because impulses require the rigid-body
+/// mass to be available, which it was not because colliders were not created yet. As a
+/// result, we run this system after the collider creation.
+pub fn apply_initial_rigid_body_impulses(
+    mut context: Query<(&mut RapierRigidBodySet, &RapierContextColliders)>,
+    // We can’t use RapierRigidBodyHandle yet because its creation command hasn’t been
+    // executed yet.
+    mut init_impulses: Query<
+        (Entity, &RapierContextEntityLink, &mut ExternalImpulse),
+        Without<RapierRigidBodyHandle>,
+    >,
+) {
+    for (entity, link, mut impulse) in init_impulses.iter_mut() {
+        let (mut rigidbody_set, context_colliders) =
+            context.get_mut(link.0).expect(RAPIER_CONTEXT_EXPECT_ERROR);
+        let rigidbody_set = &mut *rigidbody_set;
+
+        let bodies = &mut rigidbody_set.bodies;
+        if let Some(rb) = rigidbody_set
+            .entity2body
+            .get(&entity)
+            .and_then(|h| bodies.get_mut(*h))
+        {
+            // Make sure the mass-properties are computed.
+            rb.recompute_mass_properties_from_colliders(&context_colliders.colliders);
+            // Apply the impulse.
+            rb.apply_impulse(impulse.impulse, false);
+
+            #[allow(clippy::useless_conversion)] // Need to convert if dim3 enabled
+            rb.apply_torque_impulse(impulse.torque_impulse.into(), false);
+
+            impulse.reset();
+        }
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+    use crate::plugin::{NoUserData, RapierPhysicsPlugin};
+    use bevy::time::{TimePlugin, TimeUpdateStrategy};
+    use rapier::dynamics::LockedAxes as RapierLockedAxes;
+
+    fn test_app() -> App {
+        let mut app = App::new();
+        app.add_plugins((
+            TransformPlugin,
+            TimePlugin,
+            RapierPhysicsPlugin::<NoUserData>::default(),
+        ))
+        .insert_resource(TimeUpdateStrategy::ManualDuration(
+            std::time::Duration::from_secs_f32(1.0 / 60.0),
+        ));
+        app.finish();
+        app
+    }
+
+    fn with_body<R>(
+        app: &mut App,
+        entity: Entity,
+        f: impl FnOnce(&RapierRigidBodySet, &rapier::dynamics::RigidBody) -> R,
+    ) -> R {
+        let world = app.world_mut();
+        let set = world.query::<&RapierRigidBodySet>().single(world).unwrap();
+        let rb = set.bodies.get(set.entity2body()[&entity]).unwrap();
+        f(set, rb)
+    }
+
+    #[test]
+    fn rigid_body_components_are_reset_on_removal() {
+        let mut app = test_app();
+        app.update();
+
+        let entity = app
+            .world_mut()
+            .spawn((
+                Transform::default(),
+                RigidBody::Dynamic,
+                ExternalForce {
+                    force: Vect::X,
+                    ..default()
+                },
+                Damping {
+                    linear_damping: 1.0,
+                    angular_damping: 2.0,
+                },
+                GravityScale(3.0),
+                (Ccd::enabled(), SoftCcd { prediction: 4.0 }),
+                Dominance::group(5),
+                LockedAxes::ROTATION_LOCKED,
+                AdditionalMassProperties::Mass(6.0),
+                (AdditionalSolverIterations(7), AdditionalPgsIterations(8)),
+                AllowFastRotation,
+                Sleeping {
+                    time_until_sleep: 9.0,
+                    ..Sleeping::disabled()
+                },
+            ))
+            .id();
+        #[cfg(feature = "dim3")]
+        app.world_mut()
+            .entity_mut(entity)
+            .insert(GyroscopicForces::disabled());
+        app.update();
+
+        with_body(&mut app, entity, |_, rb| {
+            assert_eq!(rb.user_force(), Vect::X);
+            assert_eq!(rb.linear_damping(), 1.0);
+            assert_eq!(rb.angular_damping(), 2.0);
+            assert_eq!(rb.gravity_scale(), 3.0);
+            assert!(rb.is_ccd_enabled());
+            assert_eq!(rb.soft_ccd_prediction(), 4.0);
+            assert_eq!(rb.dominance_group(), 5);
+            assert_eq!(rb.locked_axes(), RapierLockedAxes::ROTATION_LOCKED);
+            assert!(rb.mass_properties().additional_local_mprops.is_some());
+            assert_eq!(rb.additional_solver_iterations(), 7);
+            assert_eq!(rb.additional_pgs_iterations(), 8);
+            assert!(rb.is_fast_rotation_allowed());
+            assert_eq!(rb.activation().normalized_linear_threshold, -1.0);
+            assert_eq!(rb.activation().time_until_sleep, 9.0);
+            #[cfg(feature = "dim3")]
+            assert!(!rb.gyroscopic_forces_enabled());
+        });
+
+        app.world_mut().entity_mut(entity).remove::<(
+            ExternalForce,
+            Damping,
+            GravityScale,
+            Ccd,
+            SoftCcd,
+            Dominance,
+            LockedAxes,
+            AdditionalMassProperties,
+            AdditionalSolverIterations,
+            AdditionalPgsIterations,
+            AllowFastRotation,
+            Sleeping,
+        )>();
+        #[cfg(feature = "dim3")]
+        app.world_mut()
+            .entity_mut(entity)
+            .remove::<GyroscopicForces>();
+        app.update();
+
+        let default_sleeping = Sleeping::default();
+        with_body(&mut app, entity, |_, rb| {
+            assert_eq!(rb.user_force(), Vect::ZERO);
+            assert_eq!(rb.linear_damping(), 0.0);
+            assert_eq!(rb.angular_damping(), 0.0);
+            assert_eq!(rb.gravity_scale(), 1.0);
+            assert!(!rb.is_ccd_enabled());
+            assert_eq!(rb.soft_ccd_prediction(), 0.0);
+            assert_eq!(rb.dominance_group(), 0);
+            assert_eq!(rb.locked_axes(), RapierLockedAxes::empty());
+            assert_eq!(rb.mass(), 0.0);
+            assert_eq!(rb.additional_solver_iterations(), 0);
+            assert_eq!(rb.additional_pgs_iterations(), 0);
+            assert!(!rb.is_fast_rotation_allowed());
+            assert_eq!(
+                rb.activation().normalized_linear_threshold,
+                default_sleeping.normalized_linear_threshold
+            );
+            assert_eq!(
+                rb.activation().angular_threshold,
+                default_sleeping.angular_threshold
+            );
+            assert_eq!(
+                rb.activation().time_until_sleep,
+                default_sleeping.time_until_sleep
+            );
+            #[cfg(feature = "dim3")]
+            assert!(rb.gyroscopic_forces_enabled());
+        });
+    }
+
+    #[test]
+    fn component_reinserted_in_same_frame_is_not_reset() {
+        let mut app = test_app();
+        app.update();
+
+        let entity = app
+            .world_mut()
+            .spawn((Transform::default(), RigidBody::Dynamic, GravityScale(2.0)))
+            .id();
+        app.update();
+
+        app.world_mut()
+            .entity_mut(entity)
+            .remove::<GravityScale>()
+            .insert(GravityScale(3.0));
+        app.update();
+
+        with_body(&mut app, entity, |_, rb| {
+            assert_eq!(rb.gravity_scale(), 3.0)
+        });
+    }
+
+    #[test]
+    fn world_mass_properties_are_written_back() {
+        let mut app = test_app();
+        app.update();
+
+        let translation = Vec3::new(1.0, 2.0, 0.0);
+        let entity = app
+            .world_mut()
+            .spawn((
+                Transform::from_translation(translation),
+                RigidBody::Dynamic,
+                Collider::ball(0.5),
+                LockedAxes::TRANSLATION_LOCKED_X,
+                GravityScale(0.0),
+                ReadWorldMassProperties::default(),
+            ))
+            .id();
+        app.update();
+
+        let props = *app.world().get::<ReadWorldMassProperties>(entity).unwrap();
+        #[cfg(feature = "dim2")]
+        let expected_com = translation.truncate();
+        #[cfg(feature = "dim3")]
+        let expected_com = translation;
+        approx::assert_relative_eq!(props.center_of_mass, expected_com, epsilon = 1.0e-5);
+        assert_eq!(props.effective_inv_mass.x, 0.0);
+        assert!(props.effective_inv_mass.y > 0.0);
+
+        with_body(&mut app, entity, |set, rb| {
+            assert_eq!(set.center_of_mass(entity), Some(props.center_of_mass));
+            assert_eq!(set.mass(entity), Some(rb.mass()));
+            assert_eq!(set.is_moving(entity), Some(false));
+            assert_eq!(set.effective_dominance_group(entity), Some(0));
+            assert_eq!(set.center_of_mass(Entity::PLACEHOLDER), None);
+        });
+    }
+
+    #[test]
+    fn waking_up_a_body_wakes_up_its_island() {
+        let mut app = test_app();
+        app.update();
+
+        let spawn_body = |app: &mut App, x: f32| {
+            app.world_mut()
+                .spawn((
+                    Transform::from_xyz(x, 0.0, 0.0),
+                    RigidBody::Dynamic,
+                    Collider::ball(0.5),
+                    GravityScale(0.0),
+                    Sleeping::default(),
+                ))
+                .id()
+        };
+        let body1 = spawn_body(&mut app, 0.0);
+        let body2 = spawn_body(&mut app, 2.0);
+        app.world_mut().entity_mut(body2).insert(ImpulseJoint::new(
+            body1,
+            FixedJointBuilder::new().local_anchor1(Vect::X * 2.0),
+        ));
+
+        for _ in 0..120 {
+            app.update();
+        }
+        assert!(app.world().get::<Sleeping>(body1).unwrap().sleeping);
+        assert!(app.world().get::<Sleeping>(body2).unwrap().sleeping);
+
+        app.world_mut().get_mut::<Sleeping>(body2).unwrap().sleeping = false;
+        app.update();
+
+        with_body(&mut app, body1, |_, rb| assert!(!rb.is_sleeping()));
+        with_body(&mut app, body2, |_, rb| assert!(!rb.is_sleeping()));
+    }
+}
diff --git a/bindings/bevy_rapier/src/plugin/systems/soft_body.rs b/bindings/bevy_rapier/src/plugin/systems/soft_body.rs
new file mode 100644
index 000000000..cd8d0a92d
--- /dev/null
+++ b/bindings/bevy_rapier/src/plugin/systems/soft_body.rs
@@ -0,0 +1,1545 @@
+//! Systems synchronizing the soft-body components with Rapier.
+
+#[cfg(feature = "fem")]
+use crate::dynamics::SoftBodyElasticitySolver;
+use crate::dynamics::{
+    RapierRigidBodyHandle, RapierSoftBody, RapierSoftBodyHandle, RapierSoftBodyTearEvent, SoftBody,
+    SoftBodyAttachment, SoftBodyAttachments, SoftBodyBuilder, SoftBodyCluster,
+    SoftBodyClusterKinematicTarget, SoftBodyClusterMaterial, SoftBodyClusterPinned,
+    SoftBodyClusterShapeMatching, SoftBodyDisabled, SoftBodyExternalForce, SoftBodyExternalImpulse,
+    SoftBodyKinematicTargets, SoftBodyMaterial, SoftBodyPinnedParticles, SoftBodyState,
+    SoftBodyVolumeFactor,
+};
+use crate::geometry::{
+    ActiveCollisionTypes, ActiveEvents, ActiveHooks, CollisionGroups, ContactForceEventThreshold,
+    ContactSkin, Friction, RapierColliderHandle, Restitution, Sensor, SolverGroups,
+};
+use crate::pipeline::{
+    SoftBodyClusterSplit, SoftBodyJointMove, SoftBodyTearEvent, SoftBodyTearPiece,
+};
+use crate::plugin::context::{
+    RapierContextColliders, RapierContextEntityLink, RapierContextJoints, RapierContextSimulation,
+    RapierRigidBodySet,
+};
+use crate::utils;
+use bevy::ecs::query::QueryItem;
+use bevy::prelude::*;
+
+use super::RapierContextLinkResolver;
+use rapier::dynamics::{RigidBodyHandle, RigidBodySet, SoftBodyHandle};
+use rapier::geometry::Collider as RapierCollider;
+use std::collections::HashMap;
+
+/// The collider components of a soft body entity, applied to its surface colliders.
+pub type SoftBodyColliderComponents<'a> = (
+    Option<&'a Friction>,
+    Option<&'a Restitution>,
+    Option<&'a CollisionGroups>,
+    Option<&'a SolverGroups>,
+    Option<&'a ActiveEvents>,
+    Option<&'a ActiveHooks>,
+    Option<&'a ActiveCollisionTypes>,
+    Option<&'a ContactForceEventThreshold>,
+    Option<&'a ContactSkin>,
+    Has<Sensor>,
+);
+
+/// The filter matching the soft bodies whose [`SoftBodyColliderComponents`] must be applied.
+type SoftBodyColliderChanges = (
+    With<RapierSoftBodyHandle>,
+    Or<(
+        Changed<Friction>,
+        Changed<Restitution>,
+        Changed<CollisionGroups>,
+        Changed<SolverGroups>,
+        Changed<ActiveEvents>,
+        Changed<ActiveHooks>,
+        Changed<ActiveCollisionTypes>,
+        Changed<ContactForceEventThreshold>,
+        Changed<ContactSkin>,
+        Changed<Sensor>,
+        Added<RapierSoftBodyHandle>,
+    )>,
+);
+
+/// The components of a soft body entity read when the soft body is created.
+pub type SoftBodyComponents<'a> = (
+    (Entity, Option<&'a RapierContextEntityLink>),
+    &'a SoftBody,
+    Option<&'a GlobalTransform>,
+    Option<&'a SoftBodyMaterial>,
+    Option<&'a SoftBodyVolumeFactor>,
+    Option<&'a SoftBodyPinnedParticles>,
+    Option<&'a SoftBodyDisabled>,
+);
+
+/// The state written back into [`SoftBodyState`].
+fn soft_body_state(sb: &RapierSoftBody) -> SoftBodyState {
+    SoftBodyState {
+        center_of_mass: sb.center_of_mass(),
+        is_sleeping: sb.is_sleeping(),
+        is_enabled: sb.is_enabled(),
+        topology_version: sb.topology_version(),
+        num_particles: sb.num_particles(),
+    }
+}
+
+/// Applies the collider components of a soft body entity to one of its surface colliders.
+fn apply_collider_components(
+    co: &mut RapierCollider,
+    (
+        friction,
+        restitution,
+        collision_groups,
+        solver_groups,
+        active_events,
+        active_hooks,
+        active_collision_types,
+        force_threshold,
+        contact_skin,
+        sensor,
+    ): QueryItem<SoftBodyColliderComponents>,
+) {
+    if let Some(friction) = friction {
+        co.set_friction(friction.coefficient);
+        co.set_friction_combine_rule(friction.combine_rule.into());
+    }
+    if let Some(restitution) = restitution {
+        co.set_restitution(restitution.coefficient);
+        co.set_restitution_combine_rule(restitution.combine_rule.into());
+    }
+    if let Some(groups) = collision_groups {
+        co.set_collision_groups((*groups).into());
+    }
+    if let Some(groups) = solver_groups {
+        co.set_solver_groups((*groups).into());
+    }
+    if let Some(events) = active_events {
+        co.set_active_events((*events).into());
+    }
+    if let Some(hooks) = active_hooks {
+        co.set_active_hooks((*hooks).into());
+    }
+    if let Some(types) = active_collision_types {
+        co.set_active_collision_types((*types).into());
+    }
+    if let Some(threshold) = force_threshold {
+        co.set_contact_force_event_threshold(threshold.0);
+    }
+    if let Some(skin) = contact_skin {
+        co.set_contact_skin(skin.0);
+    }
+    if sensor {
+        co.set_sensor(true);
+    }
+}
+
+/// Transforms the world-space data of a soft-body builder by `transform`.
+fn transform_builder(builder: &mut SoftBodyBuilder, transform: &GlobalTransform) {
+    let affine = transform.affine();
+    let apply = |p: &mut crate::math::Vect| {
+        #[cfg(feature = "dim2")]
+        {
+            *p = affine.transform_point3(p.extend(0.0)).truncate();
+        }
+        #[cfg(feature = "dim3")]
+        {
+            *p = affine.transform_point3(*p);
+        }
+    };
+    builder.positions.iter_mut().for_each(apply);
+    if let Some((vertices, _)) = &mut builder.skin {
+        vertices.iter_mut().for_each(apply);
+    }
+}
+
+/// Pins exactly the particles listed in `pinned` (invalid indices are ignored).
+fn set_pinned_particles(sb: &mut RapierSoftBody, pinned: &[u32]) {
+    let mut target = vec![false; sb.num_particles()];
+    for &i in pinned {
+        if let Some(pin) = target.get_mut(i as usize) {
+            *pin = true;
+        }
+    }
+    for (i, pin) in target.into_iter().enumerate() {
+        if sb.particles()[i].is_pinned() != pin {
+            sb.set_particle_pinned(i, pin);
+        }
+    }
+}
+
+/// The particles of the clusters of `sb` with a [`SoftBodyClusterPinned`] component.
+fn pinned_cluster_particles(
+    sb: &RapierSoftBody,
+    entity2body: &HashMap<Entity, RigidBodyHandle>,
+    pinned_clusters: &Query<Entity, With<SoftBodyClusterPinned>>,
+) -> Vec<u32> {
+    let mut particles = vec![];
+    for entity in pinned_clusters {
+        let Some(proxy) = entity2body.get(&entity) else {
+            continue;
+        };
+        if let Some((_, cluster)) = sb.live_clusters().find(|(_, c)| c.proxy() == *proxy) {
+            particles.extend_from_slice(cluster.particles());
+        }
+    }
+    particles
+}
+
+/// Makes the particle attachments of `sb` match `attachments`.
+///
+/// Only the particles whose set of attached bodies changed are detached and attached again, so
+/// the other attachments keep their anchor. Returns `false` if some bodies don't exist yet.
+fn update_attachments(
+    sb: &mut RapierSoftBody,
+    attachments: &[SoftBodyAttachment],
+    bodies: &RigidBodySet,
+    entity2body: &HashMap<Entity, RigidBodyHandle>,
+) -> bool {
+    let mut complete = true;
+    let mut desired: HashMap<u32, Vec<RigidBodyHandle>> = HashMap::new();
+    for attachment in attachments {
+        let Some(body) = entity2body.get(&attachment.body) else {
+            // The rigid-body may not be created yet: try again next frame.
+            complete = false;
+            continue;
+        };
+        if (attachment.particle as usize) < sb.num_particles() {
+            desired.entry(attachment.particle).or_default().push(*body);
+        }
+    }
+    let mut current: HashMap<u32, Vec<RigidBodyHandle>> = HashMap::new();
+    for attachment in sb.particle_attachments() {
+        current
+            .entry(attachment.particle)
+            .or_default()
+            .push(attachment.body);
+    }
+    let sorted = |mut bodies: Vec<RigidBodyHandle>| {
+        bodies.sort_by_key(|h| h.into_raw_parts());
+        bodies
+    };
+    let mut particles: Vec<u32> = desired.keys().chain(current.keys()).copied().collect();
+    particles.sort_unstable();
+    particles.dedup();
+    for particle in particles {
+        let wanted = sorted(desired.remove(&particle).unwrap_or_default());
+        let existing = sorted(current.remove(&particle).unwrap_or_default());
+        if wanted != existing {
+            sb.detach_particle(particle as usize);
+            for body in wanted {
+                sb.attach_particle(particle as usize, body, bodies);
+            }
+        }
+    }
+    complete
+}
+
+/// Detaches every particle attached to a rigid-body.
+fn detach_all_particles(sb: &mut RapierSoftBody) {
+    let mut attached: Vec<u32> = sb
+        .particle_attachments()
+        .iter()
+        .map(|a| a.particle)
+        .collect();
+    attached.dedup();
+    for particle in attached {
+        sb.detach_particle(particle as usize);
+    }
+}
+
+/// System responsible for creating the Rapier soft bodies of new [`SoftBody`] components.
+pub fn init_soft_bodies(
+    mut commands: Commands,
+    context_links: RapierContextLinkResolver,
+    mut context_access: Query<(&mut RapierRigidBodySet, &mut RapierContextColliders)>,
+    soft_bodies: Query<SoftBodyComponents, Without<RapierSoftBodyHandle>>,
+) {
+    for (
+        (entity, entity_context_link),
+        soft_body,
+        transform,
+        material,
+        volume_factor,
+        pinned,
+        disabled,
+    ) in soft_bodies.iter()
+    {
+        // Use the RapierContextEntityLink, or insert the context of an ancestor or the default one.
+        let context_entity = context_links.resolve(entity, entity_context_link, &mut commands);
+        let Some(context_entity) = context_entity else {
+            continue;
+        };
+        let Ok((mut rigidbody_set, mut context_colliders)) = context_access.get_mut(context_entity)
+        else {
+            log::error!("Could not find entity {context_entity} with rapier context while initializing {entity}");
+            continue;
+        };
+        let rigidbody_set = &mut *rigidbody_set;
+
+        let mut builder = soft_body.builder.clone();
+        if let Some(transform) = transform {
+            transform_builder(&mut builder, transform);
+        }
+        if let Some(material) = material {
+            builder.material = material.0;
+        }
+        if let Some(volume_factor) = volume_factor {
+            builder.volume_factor = volume_factor.0;
+        }
+        if let Some(pinned) = pinned {
+            builder.pinned = pinned.0.clone();
+        }
+        let user_data = entity.to_bits() as u128;
+        builder.user_data = user_data;
+        // The collider components are applied by `apply_soft_body_user_changes`.
+        builder.collider_template = builder
+            .collider_template
+            .take()
+            .map(|template| template.user_data(user_data));
+
+        let handle = rigidbody_set.soft_bodies.insert(
+            builder,
+            &mut rigidbody_set.bodies,
+            &mut context_colliders.colliders,
+        );
+        let sb = &mut rigidbody_set.soft_bodies[handle];
+        if disabled.is_some() {
+            sb.set_enabled(false);
+        }
+        let state = soft_body_state(sb);
+        rigidbody_set.map_soft_body_collision_mesh(&mut context_colliders, handle, entity);
+        rigidbody_set.entity2soft_body.insert(entity, handle);
+        rigidbody_set.map_soft_body_whole_proxy(entity, handle);
+        commands
+            .entity(entity)
+            .insert((RapierSoftBodyHandle(handle), state));
+    }
+}
+
+/// System responsible for creating the proxy rigid-bodies of new [`SoftBodyCluster`] components.
+pub fn init_soft_body_clusters(
+    mut commands: Commands,
+    mut context_access: Query<(&mut RapierRigidBodySet, &mut RapierContextColliders)>,
+    links: Query<&RapierContextEntityLink>,
+    clusters: Query<(Entity, &SoftBodyCluster), Without<RapierRigidBodyHandle>>,
+) {
+    for (entity, cluster) in clusters.iter() {
+        if entity == cluster.soft_body {
+            log::error!(
+                "The `SoftBodyCluster` of {entity} must be on another entity than its soft body."
+            );
+            commands.entity(entity).remove::<SoftBodyCluster>();
+            continue;
+        }
+        // The soft body may not be created yet: try again next frame.
+        let Ok(link) = links.get(cluster.soft_body) else {
+            continue;
+        };
+        let Ok((mut rigidbody_set, mut context_colliders)) = context_access.get_mut(link.0) else {
+            continue;
+        };
+        let rigidbody_set = &mut *rigidbody_set;
+        let Some(handle) = rigidbody_set
+            .entity2soft_body
+            .get(&cluster.soft_body)
+            .copied()
+        else {
+            continue;
+        };
+
+        let Some(index) = rigidbody_set.soft_bodies.add_cluster(
+            handle,
+            &cluster.particles,
+            &mut rigidbody_set.bodies,
+            &mut context_colliders.colliders,
+        ) else {
+            log::error!("The `SoftBodyCluster` of {entity} doesn't contain any valid particle.");
+            commands.entity(entity).remove::<SoftBodyCluster>();
+            continue;
+        };
+        let Some(proxy) = rigidbody_set.soft_bodies[handle].cluster_proxy(index) else {
+            continue;
+        };
+        if let Some(rb) = rigidbody_set.bodies.get_mut(proxy) {
+            rb.user_data = entity.to_bits() as u128;
+        }
+        rigidbody_set.entity2body.insert(entity, proxy);
+        commands
+            .entity(entity)
+            .insert((RapierRigidBodyHandle(proxy), *link));
+    }
+}
+
+/// System responsible for applying changes the user made to a soft-body-related component.
+pub fn apply_soft_body_user_changes(
+    mut rigid_body_sets: Query<&mut RapierRigidBodySet>,
+    (changed_materials, changed_volume_factors, changed_disabled): (
+        Query<
+            (
+                &RapierSoftBodyHandle,
+                &RapierContextEntityLink,
+                &SoftBodyMaterial,
+            ),
+            Or<(Changed<SoftBodyMaterial>, Added<RapierSoftBodyHandle>)>,
+        >,
+        Query<
+            (
+                &RapierSoftBodyHandle,
+                &RapierContextEntityLink,
+                &SoftBodyVolumeFactor,
+            ),
+            Or<(Changed<SoftBodyVolumeFactor>, Added<RapierSoftBodyHandle>)>,
+        >,
+        Query<
+            (&RapierSoftBodyHandle, &RapierContextEntityLink),
+            (
+                With<SoftBodyDisabled>,
+                Or<(Changed<SoftBodyDisabled>, Added<RapierSoftBodyHandle>)>,
+            ),
+        >,
+    ),
+    (changed_pinned, changed_targets): (
+        Query<
+            (
+                &RapierSoftBodyHandle,
+                &RapierContextEntityLink,
+                &SoftBodyPinnedParticles,
+            ),
+            Or<(
+                Changed<SoftBodyPinnedParticles>,
+                Added<RapierSoftBodyHandle>,
+            )>,
+        >,
+        Query<
+            (
+                &RapierSoftBodyHandle,
+                &RapierContextEntityLink,
+                &SoftBodyKinematicTargets,
+            ),
+            Or<(
+                Changed<SoftBodyKinematicTargets>,
+                Added<RapierSoftBodyHandle>,
+            )>,
+        >,
+    ),
+    mut changed_attachments: Query<
+        (
+            &RapierSoftBodyHandle,
+            &RapierContextEntityLink,
+            Mut<SoftBodyAttachments>,
+        ),
+        Or<(Changed<SoftBodyAttachments>, Added<RapierSoftBodyHandle>)>,
+    >,
+    (changed_forces, mut changed_impulses): (
+        Query<
+            (
+                &RapierSoftBodyHandle,
+                &RapierContextEntityLink,
+                &SoftBodyExternalForce,
+            ),
+            Or<(Changed<SoftBodyExternalForce>, Added<RapierSoftBodyHandle>)>,
+        >,
+        Query<
+            (
+                &RapierSoftBodyHandle,
+                &RapierContextEntityLink,
+                Mut<SoftBodyExternalImpulse>,
+            ),
+            Or<(
+                Changed<SoftBodyExternalImpulse>,
+                Added<RapierSoftBodyHandle>,
+            )>,
+        >,
+    ),
+    #[cfg(feature = "fem")] changed_solvers: Query<
+        (
+            &RapierSoftBodyHandle,
+            &RapierContextEntityLink,
+            &SoftBodyElasticitySolver,
+        ),
+        Or<(
+            Changed<SoftBodyElasticitySolver>,
+            Added<RapierSoftBodyHandle>,
+        )>,
+    >,
+    pinned_clusters: Query<Entity, With<SoftBodyClusterPinned>>,
+    (mut context_colliders, changed_colliders): (
+        Query<&mut RapierContextColliders>,
+        Query<
+            (Entity, &RapierContextEntityLink, SoftBodyColliderComponents),
+            SoftBodyColliderChanges,
+        >,
+    ),
+) {
+    for (entity, link, components) in changed_colliders.iter() {
+        let (Ok(rigidbody_set), Ok(mut colliders)) = (
+            rigid_body_sets.get(link.0),
+            context_colliders.get_mut(link.0),
+        ) else {
+            continue;
+        };
+        for handle in rigidbody_set
+            .soft_body_colliders(&colliders.colliders, entity)
+            .unwrap_or_default()
+        {
+            if let Some(co) = colliders.colliders.get_mut(handle) {
+                apply_collider_components(co, components);
+            }
+        }
+    }
+
+    let mut with_soft_body = |link: &RapierContextEntityLink,
+                              handle: &RapierSoftBodyHandle,
+                              f: &mut dyn FnMut(
+        &mut RapierSoftBody,
+        &RigidBodySet,
+        &HashMap<Entity, RigidBodyHandle>,
+    )| {
+        let Ok(mut rigidbody_set) = rigid_body_sets.get_mut(link.0) else {
+            return false;
+        };
+        let rigidbody_set = &mut *rigidbody_set;
+        let Some(sb) = rigidbody_set.soft_bodies.get_mut(handle.0) else {
+            return false;
+        };
+        f(sb, &rigidbody_set.bodies, &rigidbody_set.entity2body);
+        true
+    };
+
+    for (handle, link, material) in changed_materials.iter() {
+        with_soft_body(link, handle, &mut |sb, _, _| sb.set_material(material.0));
+    }
+
+    for (handle, link, factor) in changed_volume_factors.iter() {
+        with_soft_body(link, handle, &mut |sb, _, _| sb.set_volume_factor(factor.0));
+    }
+
+    for (handle, link) in changed_disabled.iter() {
+        with_soft_body(link, handle, &mut |sb, _, _| sb.set_enabled(false));
+    }
+
+    #[cfg(feature = "fem")]
+    for (handle, link, solver) in changed_solvers.iter() {
+        with_soft_body(link, handle, &mut |sb, _, _| {
+            if sb.solver() != solver.0 {
+                sb.set_solver(solver.0);
+            }
+        });
+    }
+
+    for (handle, link, pinned) in changed_pinned.iter() {
+        with_soft_body(link, handle, &mut |sb, _, entity2body| {
+            let mut all_pinned = pinned.0.clone();
+            all_pinned.extend(pinned_cluster_particles(sb, entity2body, &pinned_clusters));
+            set_pinned_particles(sb, &all_pinned)
+        });
+    }
+
+    for (handle, link, targets) in changed_targets.iter() {
+        with_soft_body(link, handle, &mut |sb, _, _| {
+            for (i, target) in &targets.0 {
+                if (*i as usize) < sb.num_particles() {
+                    sb.set_particle_kinematic_target(*i as usize, *target);
+                }
+            }
+        });
+    }
+
+    for (handle, link, mut attachments) in changed_attachments.iter_mut() {
+        let mut retry = false;
+        with_soft_body(link, handle, &mut |sb, bodies, entity2body| {
+            retry = !update_attachments(sb, &attachments.0, bodies, entity2body);
+        });
+        if retry {
+            attachments.set_changed();
+        }
+    }
+
+    for (handle, link, forces) in changed_forces.iter() {
+        with_soft_body(link, handle, &mut |sb, _, _| {
+            sb.reset_forces(false);
+            sb.add_force(forces.force, true);
+            for (i, force) in &forces.particle_forces {
+                if (*i as usize) < sb.num_particles() {
+                    sb.add_particle_force(*i as usize, *force, true);
+                }
+            }
+        });
+    }
+
+    for (handle, link, mut impulses) in changed_impulses.iter_mut() {
+        let applied = with_soft_body(link, handle, &mut |sb, _, _| {
+            if impulses.velocity_change != crate::math::Vect::ZERO {
+                sb.apply_impulse(impulses.velocity_change, true);
+            }
+            for (i, impulse) in &impulses.particle_impulses {
+                if (*i as usize) < sb.num_particles() {
+                    sb.apply_particle_impulse(*i as usize, *impulse, true);
+                }
+            }
+        });
+        if applied {
+            impulses.bypass_change_detection().reset();
+        }
+    }
+}
+
+/// System responsible for removing from Rapier the soft bodies whose [`SoftBody`] component was
+/// removed by the user (through component removal or despawn).
+pub fn sync_soft_body_removals(
+    mut commands: Commands,
+    mut contexts: Query<(
+        &mut RapierContextSimulation,
+        &mut RapierContextColliders,
+        &mut RapierContextJoints,
+        &mut RapierRigidBodySet,
+    )>,
+    has_handle: Query<(), With<RapierSoftBodyHandle>>,
+    mut removed_handles: RemovedComponents<RapierSoftBodyHandle>,
+    orphans: Query<Entity, (With<RapierSoftBodyHandle>, Without<SoftBody>)>,
+) {
+    let mut remove = |entity: Entity| {
+        for (mut simulation, mut colliders, mut joints, mut rigidbody_set) in contexts.iter_mut() {
+            if let Some(handle) = rigidbody_set.entity2soft_body.get(&entity).copied() {
+                simulation.remove_soft_body(
+                    &mut colliders,
+                    &mut joints,
+                    &mut rigidbody_set,
+                    handle,
+                );
+                break;
+            }
+        }
+    };
+
+    for entity in removed_handles.read() {
+        if !has_handle.contains(entity) {
+            remove(entity);
+        }
+    }
+
+    for entity in orphans.iter() {
+        remove(entity);
+        commands.entity(entity).remove::<RapierSoftBodyHandle>();
+    }
+}
+
+/// Removal detection for a single component: the entities it was removed from, paired with a
+/// query checking if it was re-inserted since.
+type RemovedComponent<'w, 's, T> = (RemovedComponents<'w, 's, T>, Query<'w, 's, (), With<T>>);
+
+/// System responsible for resetting the Rapier soft-body properties to the values of their
+/// [`SoftBody`] builder when the corresponding component is removed by the user.
+pub fn reset_removed_soft_body_components(
+    mut rigid_body_sets: Query<&mut RapierRigidBodySet>,
+    soft_bodies: Query<&SoftBody>,
+    (mut removed_materials, mut removed_volume_factors, mut removed_disabled): (
+        RemovedComponent<SoftBodyMaterial>,
+        RemovedComponent<SoftBodyVolumeFactor>,
+        RemovedComponent<SoftBodyDisabled>,
+    ),
+    (mut removed_pinned, mut removed_attachments, mut removed_forces): (
+        RemovedComponent<SoftBodyPinnedParticles>,
+        RemovedComponent<SoftBodyAttachments>,
+        RemovedComponent<SoftBodyExternalForce>,
+    ),
+    #[cfg(feature = "fem")] mut removed_solvers: RemovedComponent<SoftBodyElasticitySolver>,
+    pinned_clusters: Query<Entity, With<SoftBodyClusterPinned>>,
+) {
+    let sets = &mut rigid_body_sets;
+    let builders = &soft_bodies;
+    reset_removed(&mut removed_materials, sets, builders, |sb, builder| {
+        sb.set_material(builder.map(|b| b.material).unwrap_or_default());
+    });
+    reset_removed(
+        &mut removed_volume_factors,
+        sets,
+        builders,
+        |sb, builder| {
+            sb.set_volume_factor(builder.map(|b| b.volume_factor).unwrap_or(1.0));
+        },
+    );
+    reset_removed(&mut removed_disabled, sets, builders, |sb, _| {
+        sb.set_enabled(true);
+    });
+    let unpinned = reset_removed(&mut removed_pinned, sets, builders, |sb, builder| {
+        set_pinned_particles(sb, builder.map(|b| &b.pinned[..]).unwrap_or_default());
+    });
+    // Pin the pinned clusters again.
+    if unpinned {
+        for mut set in sets.iter_mut() {
+            let set = &mut *set;
+            for entity in &pinned_clusters {
+                if let Some((handle, index)) = set.soft_body_cluster_index(entity) {
+                    if let Some(sb) = set.soft_bodies.get_mut(handle) {
+                        sb.set_cluster_pinned(index, true);
+                    }
+                }
+            }
+        }
+    }
+    reset_removed(&mut removed_attachments, sets, builders, |sb, _| {
+        detach_all_particles(sb);
+    });
+    reset_removed(&mut removed_forces, sets, builders, |sb, _| {
+        sb.reset_forces(true);
+    });
+    #[cfg(feature = "fem")]
+    reset_removed(&mut removed_solvers, sets, builders, |sb, builder| {
+        sb.set_solver(builder.map(|b| b.solver).unwrap_or_default());
+    });
+}
+
+/// Calls `reset` on the Rapier soft body of each entity `T` was removed from, unless `T` was
+/// inserted back since. Returns `true` if `reset` was called.
+fn reset_removed<T: Component>(
+    (removed, still_present): &mut RemovedComponent<T>,
+    rigid_body_sets: &mut Query<&mut RapierRigidBodySet>,
+    soft_bodies: &Query<&SoftBody>,
+    mut reset: impl FnMut(&mut RapierSoftBody, Option<&SoftBodyBuilder>),
+) -> bool {
+    let mut any = false;
+    for entity in removed.read() {
+        if still_present.contains(entity) {
+            continue;
+        }
+
+        for mut rigid_body_set in rigid_body_sets.iter_mut() {
+            if let Some(sb) = rigid_body_set.soft_body_mut(entity) {
+                reset(sb, soft_bodies.get(entity).ok().map(|sb| &sb.builder));
+                any = true;
+                break;
+            }
+        }
+    }
+    any
+}
+
+/// Calls `f` with the soft body and the index of the cluster standing for `entity` (see
+/// [`RapierRigidBodySet::soft_body_cluster_index`]).
+fn with_cluster(
+    rigid_body_sets: &mut Query<&mut RapierRigidBodySet>,
+    link: &RapierContextEntityLink,
+    entity: Entity,
+    f: impl FnOnce(&mut RapierSoftBody, u32),
+) {
+    let Ok(mut set) = rigid_body_sets.get_mut(link.0) else {
+        return;
+    };
+    let Some((handle, index)) = set.soft_body_cluster_index(entity) else {
+        return;
+    };
+    if let Some(sb) = set.soft_bodies.get_mut(handle) {
+        f(sb, index);
+    }
+}
+
+/// Applies a [`SoftBodyClusterMaterial`] to the `index`-th cluster of `sb`.
+fn apply_cluster_material(sb: &mut RapierSoftBody, index: u32, material: &SoftBodyClusterMaterial) {
+    sb.set_cluster_stiffness_scale(index, material.stiffness_scale);
+    sb.set_cluster_edge_softness(index, material.edge_softness);
+    sb.set_cluster_tear_resistance(index, material.tear_resistance);
+}
+
+/// The entities whose cluster was just created: the cluster entities with a new proxy, and the
+/// soft body entities (for their whole-body cluster) with a new soft body.
+type NewCluster = Or<(Added<RapierRigidBodyHandle>, Added<RapierSoftBodyHandle>)>;
+
+/// System responsible for applying the changes the user made to the cluster components
+/// ([`SoftBodyClusterPinned`], [`SoftBodyClusterKinematicTarget`],
+/// [`SoftBodyClusterShapeMatching`] and [`SoftBodyClusterMaterial`]).
+pub fn apply_soft_body_cluster_changes(
+    mut rigid_body_sets: Query<&mut RapierRigidBodySet>,
+    pinned: Query<
+        (Entity, &RapierContextEntityLink),
+        (
+            With<SoftBodyClusterPinned>,
+            Or<(Changed<SoftBodyClusterPinned>, NewCluster)>,
+        ),
+    >,
+    targets: Query<
+        (
+            Entity,
+            &RapierContextEntityLink,
+            &SoftBodyClusterKinematicTarget,
+        ),
+        Or<(Changed<SoftBodyClusterKinematicTarget>, NewCluster)>,
+    >,
+    shape_matching: Query<
+        (
+            Entity,
+            &RapierContextEntityLink,
+            &SoftBodyClusterShapeMatching,
+        ),
+        Or<(Changed<SoftBodyClusterShapeMatching>, NewCluster)>,
+    >,
+    materials: Query<
+        (Entity, &RapierContextEntityLink, &SoftBodyClusterMaterial),
+        Or<(Changed<SoftBodyClusterMaterial>, NewCluster)>,
+    >,
+) {
+    let sets = &mut rigid_body_sets;
+    for (entity, link) in &pinned {
+        with_cluster(sets, link, entity, |sb, i| sb.set_cluster_pinned(i, true));
+    }
+    for (entity, link, target) in &targets {
+        let pose = utils::transform_to_iso(&target.0);
+        with_cluster(sets, link, entity, |sb, i| {
+            sb.set_cluster_kinematic_target(i, pose)
+        });
+    }
+    for (entity, link, shape_matching) in &shape_matching {
+        let target = shape_matching.target.as_ref().map(utils::transform_to_iso);
+        with_cluster(sets, link, entity, |sb, i| {
+            sb.enable_cluster_shape_matching(i, true);
+            if let Some(cluster) = sb.cluster_mut(i) {
+                cluster.set_shape_matching_target(target);
+            }
+        });
+    }
+    for (entity, link, material) in &materials {
+        with_cluster(sets, link, entity, |sb, i| {
+            apply_cluster_material(sb, i, material)
+        });
+    }
+}
+
+/// The context index, soft body and cluster index standing for each entity `T` was removed from,
+/// unless `T` was inserted back since.
+fn removed_clusters<T: Component>(
+    (removed, still_present): &mut RemovedComponent<T>,
+    rigid_body_sets: &Query<&mut RapierRigidBodySet>,
+) -> Vec<(usize, SoftBodyHandle, u32)> {
+    let mut result = vec![];
+    for entity in removed.read() {
+        if still_present.contains(entity) {
+            continue;
+        }
+        for (set_index, set) in rigid_body_sets.iter().enumerate() {
+            if let Some((handle, index)) = set.soft_body_cluster_index(entity) {
+                result.push((set_index, handle, index));
+                break;
+            }
+        }
+    }
+    result
+}
+
+/// System responsible for resetting the clusters whose [`SoftBodyClusterPinned`],
+/// [`SoftBodyClusterShapeMatching`] or [`SoftBodyClusterMaterial`] component was removed.
+///
+/// This must run before the removal of the clusters of despawned entities.
+pub fn reset_removed_soft_body_cluster_components(
+    mut rigid_body_sets: Query<&mut RapierRigidBodySet>,
+    soft_bodies: Query<(&SoftBody, Option<&SoftBodyPinnedParticles>)>,
+    pinned_clusters: Query<Entity, With<SoftBodyClusterPinned>>,
+    (mut removed_pinned, mut removed_shape_matching, mut removed_materials): (
+        RemovedComponent<SoftBodyClusterPinned>,
+        RemovedComponent<SoftBodyClusterShapeMatching>,
+        RemovedComponent<SoftBodyClusterMaterial>,
+    ),
+) {
+    let unpinned = removed_clusters(&mut removed_pinned, &rigid_body_sets);
+    let unmatched = removed_clusters(&mut removed_shape_matching, &rigid_body_sets);
+    let unmaterialized = removed_clusters(&mut removed_materials, &rigid_body_sets);
+
+    for (set_index, mut set) in rigid_body_sets.iter_mut().enumerate() {
+        let set = &mut *set;
+        for (_, handle, index) in unpinned.iter().filter(|(s, _, _)| *s == set_index) {
+            let Some(sb) = set.soft_bodies.get(*handle) else {
+                continue;
+            };
+            // The particles pinned without this cluster: by the soft body, or by other clusters.
+            let components = set
+                .soft_body_entity(*handle)
+                .and_then(|entity| soft_bodies.get(entity).ok());
+            let mut still_pinned = match components {
+                Some((_, Some(pinned))) => pinned.0.clone(),
+                Some((soft_body, None)) => soft_body.builder.pinned.clone(),
+                None => vec![],
+            };
+            still_pinned.extend(pinned_cluster_particles(
+                sb,
+                &set.entity2body,
+                &pinned_clusters,
+            ));
+            let particles = sb.cluster(*index).map(|c| c.particles().to_vec());
+            let Some(sb) = set.soft_bodies.get_mut(*handle) else {
+                continue;
+            };
+            for particle in particles.unwrap_or_default() {
+                if (particle as usize) < sb.num_particles() {
+                    sb.set_particle_pinned(particle as usize, still_pinned.contains(&particle));
+                }
+            }
+        }
+        for (_, handle, index) in unmatched.iter().filter(|(s, _, _)| *s == set_index) {
+            let builder_setting = set
+                .soft_body_entity(*handle)
+                .and_then(|entity| soft_bodies.get(entity).ok())
+                .is_some_and(|(soft_body, _)| soft_body.builder.shape_matching);
+            let Some(sb) = set.soft_bodies.get_mut(*handle) else {
+                continue;
+            };
+            // Only the whole-body cluster is shape-matched by the builder.
+            let enabled = *index == 0 && builder_setting;
+            sb.enable_cluster_shape_matching(*index, enabled);
+            if let Some(cluster) = sb.cluster_mut(*index) {
+                cluster.set_shape_matching_target(None);
+            }
+        }
+        for (_, handle, index) in unmaterialized.iter().filter(|(s, _, _)| *s == set_index) {
+            if let Some(sb) = set.soft_bodies.get_mut(*handle) {
+                apply_cluster_material(sb, *index, &SoftBodyClusterMaterial::default());
+            }
+        }
+    }
+}
+
+/// Writes `world` into `transform`, relative to the parent's global transform if any.
+fn set_world_transform(
+    transform: &mut Transform,
+    mut world: Transform,
+    parent: Option<&GlobalTransform>,
+) {
+    world.scale = transform.scale;
+    if let Some(parent) = parent {
+        world = GlobalTransform::from(world).reparented_to(parent);
+        world.scale = transform.scale;
+    }
+    // In 2D, preserve the `z` component set by the user.
+    #[cfg(feature = "dim2")]
+    {
+        world.translation.z = transform.translation.z;
+    }
+    if transform.translation != world.translation || transform.rotation != world.rotation {
+        transform.translation = world.translation;
+        transform.rotation = world.rotation;
+    }
+}
+
+/// System responsible for writing the state of the soft bodies and cluster proxies back into
+/// [`SoftBodyState`] and [`Transform`] components after a simulation step.
+pub fn writeback_soft_bodies(
+    rigid_body_sets: Query<&RapierRigidBodySet>,
+    global_transforms: Query<&GlobalTransform>,
+    mut soft_bodies: Query<(
+        Entity,
+        &RapierSoftBodyHandle,
+        &RapierContextEntityLink,
+        Option<&mut SoftBodyState>,
+        Option<&mut Transform>,
+        Option<&ChildOf>,
+    )>,
+    mut clusters: Query<
+        (
+            &RapierRigidBodyHandle,
+            &RapierContextEntityLink,
+            &mut Transform,
+            Option<&ChildOf>,
+        ),
+        (With<SoftBodyCluster>, Without<RapierSoftBodyHandle>),
+    >,
+) {
+    for (entity, handle, link, state, transform, child_of) in soft_bodies.iter_mut() {
+        let Some(set) = rigid_body_sets.get(link.0).ok() else {
+            continue;
+        };
+        let Some(sb) = set.soft_bodies.get(handle.0) else {
+            continue;
+        };
+        let new_state = soft_body_state(sb);
+        if let Some(mut state) = state {
+            state.set_if_neq(new_state);
+        }
+        if let Some(mut transform) = transform {
+            // Follow the whole-body proxy, so the colliders attached to it by children entities
+            // stay where their entity is.
+            let pose = set
+                .entity2body
+                .get(&entity)
+                .and_then(|proxy| set.bodies.get(*proxy))
+                .map(|rb| utils::iso_to_transform(rb.position()))
+                .unwrap_or_else(|| {
+                    #[cfg(feature = "dim2")]
+                    let translation = new_state.center_of_mass.extend(0.0);
+                    #[cfg(feature = "dim3")]
+                    let translation = new_state.center_of_mass;
+                    Transform::from_translation(translation)
+                });
+            let parent = child_of.and_then(|c| global_transforms.get(c.parent()).ok());
+            set_world_transform(&mut transform, pose, parent);
+        }
+    }
+
+    for (handle, link, mut transform, child_of) in clusters.iter_mut() {
+        let Some(rb) = rigid_body_sets
+            .get(link.0)
+            .ok()
+            .and_then(|set| set.bodies.get(handle.0))
+        else {
+            continue;
+        };
+        let parent = child_of.and_then(|c| global_transforms.get(c.parent()).ok());
+        set_world_transform(
+            &mut transform,
+            utils::iso_to_transform(rb.position()),
+            parent,
+        );
+    }
+}
+
+/// The components of a soft body entity referring to its particles by index.
+#[derive(Clone, Default)]
+struct IndexedComponents {
+    pinned: Option<SoftBodyPinnedParticles>,
+    targets: Option<SoftBodyKinematicTargets>,
+    attachments: Option<SoftBodyAttachments>,
+    force: Option<SoftBodyExternalForce>,
+    impulse: Option<SoftBodyExternalImpulse>,
+    /// The particles pinned by the [`SoftBody`] builder.
+    builder_pinned: Option<Vec<u32>>,
+}
+
+/// The query reading the [`IndexedComponents`] of an entity.
+type IndexedComponentsQuery<'a> = (
+    Option<&'a SoftBodyPinnedParticles>,
+    Option<&'a SoftBodyKinematicTargets>,
+    Option<&'a SoftBodyAttachments>,
+    Option<&'a SoftBodyExternalForce>,
+    Option<&'a SoftBodyExternalImpulse>,
+    Option<&'a SoftBody>,
+);
+
+/// The cluster components of a cluster entity, inherited by the clusters split off its cluster.
+type ClusterComponentsQuery<'a> = (
+    Has<SoftBodyClusterPinned>,
+    Option<&'a SoftBodyClusterKinematicTarget>,
+    Option<&'a SoftBodyClusterShapeMatching>,
+    Option<&'a SoftBodyClusterMaterial>,
+);
+
+impl IndexedComponents {
+    fn new(
+        (pinned, targets, attachments, force, impulse, soft_body): QueryItem<
+            IndexedComponentsQuery,
+        >,
+    ) -> Self {
+        Self {
+            pinned: pinned.cloned(),
+            targets: targets.cloned(),
+            attachments: attachments.cloned(),
+            force: force.cloned(),
+            impulse: impulse.cloned(),
+            builder_pinned: soft_body
+                .map(|sb| sb.builder.pinned.clone())
+                .filter(|pinned| !pinned.is_empty()),
+        }
+    }
+
+    fn is_empty(&self) -> bool {
+        self.pinned.is_none()
+            && self.targets.is_none()
+            && self.attachments.is_none()
+            && self.force.is_none()
+            && self.impulse.is_none()
+            && self.builder_pinned.is_none()
+    }
+
+    /// Splits these components between the pieces of a tear, following the particles they refer
+    /// to (the entries of the particles that no longer exist are dropped).
+    fn split(&self, event: &RapierSoftBodyTearEvent, pieces: &[SoftBodyHandle]) -> Vec<Self> {
+        let destination = |particle: u32| {
+            let (handle, index) = event.particle_destination(particle)?;
+            Some((pieces.iter().position(|h| *h == handle)?, index))
+        };
+        let split_list = |list: &[u32]| {
+            let mut result = vec![vec![]; pieces.len()];
+            for particle in list {
+                if let Some((k, index)) = destination(*particle) {
+                    result[k].push(index);
+                }
+            }
+            result
+        };
+        let mut result = vec![Self::default(); pieces.len()];
+        if let Some(pinned) = &self.pinned {
+            for (r, pinned) in result.iter_mut().zip(split_list(&pinned.0)) {
+                r.pinned = Some(SoftBodyPinnedParticles(pinned));
+            }
+        }
+        if let Some(pinned) = &self.builder_pinned {
+            for (r, pinned) in result.iter_mut().zip(split_list(pinned)) {
+                r.builder_pinned = Some(pinned);
+            }
+        }
+        if let Some(targets) = &self.targets {
+            result.iter_mut().for_each(|r| r.targets = Some(default()));
+            for (particle, target) in &targets.0 {
+                if let Some((k, index)) = destination(*particle) {
+                    result[k].targets.as_mut().unwrap().0.push((index, *target));
+                }
+            }
+        }
+        if let Some(attachments) = &self.attachments {
+            result
+                .iter_mut()
+                .for_each(|r| r.attachments = Some(default()));
+            for attachment in &attachments.0 {
+                if let Some((k, index)) = destination(attachment.particle) {
+                    result[k]
+                        .attachments
+                        .as_mut()
+                        .unwrap()
+                        .0
+                        .push(SoftBodyAttachment {
+                            particle: index,
+                            body: attachment.body,
+                        });
+                }
+            }
+        }
+        if let Some(force) = &self.force {
+            result.iter_mut().for_each(|r| {
+                r.force = Some(SoftBodyExternalForce {
+                    force: force.force,
+                    particle_forces: vec![],
+                })
+            });
+            for (particle, particle_force) in &force.particle_forces {
+                if let Some((k, index)) = destination(*particle) {
+                    let forces = &mut result[k].force.as_mut().unwrap().particle_forces;
+                    forces.push((index, *particle_force));
+                }
+            }
+        }
+        if let Some(impulse) = &self.impulse {
+            result.iter_mut().for_each(|r| {
+                r.impulse = Some(SoftBodyExternalImpulse {
+                    velocity_change: impulse.velocity_change,
+                    particle_impulses: vec![],
+                })
+            });
+            for (particle, particle_impulse) in &impulse.particle_impulses {
+                if let Some((k, index)) = destination(*particle) {
+                    let impulses = &mut result[k].impulse.as_mut().unwrap().particle_impulses;
+                    impulses.push((index, *particle_impulse));
+                }
+            }
+        }
+        result
+    }
+
+    /// Inserts these components on `entity`.
+    fn insert(self, entity_commands: &mut EntityCommands) {
+        if let Some(pinned) = self.pinned {
+            entity_commands.try_insert(pinned);
+        }
+        if let Some(targets) = self.targets {
+            entity_commands.try_insert(targets);
+        }
+        if let Some(attachments) = self.attachments {
+            entity_commands.try_insert(attachments);
+        }
+        if let Some(force) = self.force {
+            entity_commands.try_insert(force);
+        }
+        if let Some(impulse) = self.impulse {
+            entity_commands.try_insert(impulse);
+        }
+        if let Some(pinned) = self.builder_pinned {
+            // The builder is kept for the removal of `SoftBodyPinnedParticles`: keep it in sync.
+            entity_commands.queue_silenced(move |mut entity: EntityWorldMut| {
+                if let Some(mut soft_body) = entity.get_mut::<SoftBody>() {
+                    soft_body.bypass_change_detection().builder.pinned = pinned;
+                }
+            });
+        }
+    }
+}
+
+/// The mass-weighted rest centroid of the particles of the given clusters, as
+/// `(soft body, cluster index)` pairs.
+fn rest_centroid(
+    rigidbody_set: &RapierRigidBodySet,
+    clusters: impl IntoIterator<Item = (SoftBodyHandle, u32)>,
+) -> crate::math::Vect {
+    let mut com = crate::math::Vect::ZERO;
+    let mut mass = 0.0;
+    for (handle, index) in clusters {
+        let Some(sb) = rigidbody_set.soft_bodies.get(handle) else {
+            continue;
+        };
+        for &v in sb.cluster(index).map(|c| c.particles()).unwrap_or_default() {
+            let particle = &sb.particles()[v as usize];
+            com += particle.rest_position() * particle.mass();
+            mass += particle.mass();
+        }
+    }
+    if mass > 0.0 {
+        com / mass
+    } else {
+        com
+    }
+}
+
+/// The kinematic target of a cluster split off the source cluster of `split`, placing its
+/// particles where `source_target` placed them in the source cluster.
+fn inherited_kinematic_target(
+    rigidbody_set: &RapierRigidBodySet,
+    raw: &RapierSoftBodyTearEvent,
+    split: &rapier::dynamics::SoftClusterSplit,
+    source_target: &SoftBodyClusterKinematicTarget,
+) -> SoftBodyClusterKinematicTarget {
+    // A target places the rest shape centered on the cluster's rest centroid, which moved.
+    let source_centroid = rest_centroid(
+        rigidbody_set,
+        raw.clusters
+            .iter()
+            .filter(|s| s.source_cluster == split.source_cluster)
+            .map(|s| (s.soft_body, s.cluster)),
+    );
+    let centroid = rest_centroid(rigidbody_set, [(split.soft_body, split.cluster)]);
+    let delta = centroid - source_centroid;
+    #[cfg(feature = "dim2")]
+    let delta = delta.extend(0.0);
+    let mut target = *source_target;
+    target.0.translation += target.0.rotation * delta;
+    target
+}
+
+/// System responsible for spawning the entities of the soft bodies split off by tears, and for
+/// sending the corresponding [`SoftBodyTearEvent`] messages.
+pub fn handle_soft_body_tears(
+    mut commands: Commands,
+    mut contexts: Query<(
+        Entity,
+        &mut RapierContextSimulation,
+        &mut RapierContextColliders,
+        &RapierContextJoints,
+        &mut RapierRigidBodySet,
+    )>,
+    mut clusters: Query<&mut SoftBodyCluster>,
+    cluster_components: Query<ClusterComponentsQuery>,
+    indexed_components: Query<IndexedComponentsQuery>,
+    mut tear_events: MessageWriter<SoftBodyTearEvent>,
+) {
+    // The index-based components of the torn soft bodies and of their pieces, remapped through
+    // every tear of this frame.
+    let mut remapped: HashMap<Entity, IndexedComponents> = HashMap::new();
+
+    for (context_entity, mut simulation, mut colliders, joints, mut rigidbody_set) in
+        contexts.iter_mut()
+    {
+        if simulation.pending_soft_body_tears.is_empty() {
+            continue;
+        }
+        let colliders = &mut *colliders;
+        let rigidbody_set = &mut *rigidbody_set;
+        for pending in std::mem::take(&mut simulation.pending_soft_body_tears) {
+            let raw = pending.raw;
+            // Soft bodies inserted without entity are left alone.
+            let Some(torn_entity) = rigidbody_set.soft_body_entity(raw.soft_body) else {
+                continue;
+            };
+
+            let mut pieces = Vec::with_capacity(raw.pieces.len());
+            let mut piece_entities = Vec::with_capacity(raw.pieces.len());
+            for (k, piece) in raw.pieces.iter().enumerate() {
+                // The entity already spawned for this piece by a manual tear, if any.
+                let reserved = k
+                    .checked_sub(1)
+                    .and_then(|i| pending.piece_entities.get(i))
+                    .copied();
+                let piece_entity = if k == 0 {
+                    torn_entity
+                } else {
+                    let Some(sb) = rigidbody_set.soft_bodies.get(piece.soft_body) else {
+                        if let Some(reserved) = reserved {
+                            commands.entity(reserved).despawn();
+                        }
+                        continue;
+                    };
+                    let state = soft_body_state(sb);
+                    let mut torn_commands = commands.entity(torn_entity);
+                    let deny = |builder: &mut bevy::ecs::entity::EntityClonerBuilder<
+                        bevy::ecs::entity::OptOut,
+                    >| {
+                        builder.deny::<(
+                            RapierSoftBodyHandle,
+                            SoftBodyState,
+                            SoftBodyPinnedParticles,
+                            SoftBodyKinematicTargets,
+                            SoftBodyAttachments,
+                            SoftBodyExternalForce,
+                            SoftBodyExternalImpulse,
+                            Children,
+                            RapierRigidBodyHandle,
+                            RapierColliderHandle,
+                        )>();
+                        #[cfg(all(feature = "to-bevy-mesh", feature = "dim3"))]
+                        builder.deny::<bevy::mesh::Mesh3d>();
+                        #[cfg(all(feature = "to-bevy-mesh", feature = "dim2"))]
+                        builder.deny::<bevy::mesh::Mesh2d>();
+                    };
+                    let piece_entity = match reserved {
+                        Some(reserved) => {
+                            torn_commands.clone_with_opt_out(reserved, deny);
+                            reserved
+                        }
+                        None => torn_commands.clone_and_spawn_with_opt_out(deny).id(),
+                    };
+                    commands.entity(piece_entity).insert((
+                        RapierSoftBodyHandle(piece.soft_body),
+                        state,
+                        RapierContextEntityLink(context_entity),
+                    ));
+                    rigidbody_set.map_soft_body_piece(colliders, piece.soft_body, piece_entity);
+                    piece_entity
+                };
+                rigidbody_set.map_soft_body_collision_mesh(
+                    colliders,
+                    piece.soft_body,
+                    piece_entity,
+                );
+                rigidbody_set.map_soft_body_whole_proxy(piece_entity, piece.soft_body);
+
+                // The cluster entities moved to this piece now belong to its soft body.
+                if let Some(sb) = rigidbody_set.soft_bodies.get(piece.soft_body) {
+                    for [_, cluster] in &piece.clusters {
+                        let Some(proxy_entity) = sb
+                            .cluster_proxy(*cluster)
+                            .and_then(|proxy| rigidbody_set.rigid_body_entity(proxy))
+                        else {
+                            continue;
+                        };
+                        if let Ok(mut cluster) = clusters.get_mut(proxy_entity) {
+                            if cluster.soft_body != piece_entity {
+                                cluster.soft_body = piece_entity;
+                            }
+                        }
+                    }
+                }
+
+                piece_entities.push((piece.soft_body, piece_entity));
+                pieces.push(SoftBodyTearPiece {
+                    soft_body: piece_entity,
+                    particles: piece.particles.clone(),
+                });
+            }
+            if raw.pieces.is_empty() {
+                rigidbody_set.map_soft_body_collision_mesh(colliders, raw.soft_body, torn_entity);
+                rigidbody_set.map_soft_body_whole_proxy(torn_entity, raw.soft_body);
+            } else {
+                // The particles were renumbered: remap the components referring to them.
+                let source = remapped.remove(&torn_entity).unwrap_or_else(|| {
+                    indexed_components
+                        .get(torn_entity)
+                        .map(IndexedComponents::new)
+                        .unwrap_or_default()
+                });
+                if !source.is_empty() {
+                    let handles: Vec<_> = piece_entities.iter().map(|(h, _)| *h).collect();
+                    let split = source.split(&raw, &handles);
+                    for ((_, entity), components) in piece_entities.iter().zip(split) {
+                        remapped.insert(*entity, components);
+                    }
+                }
+            }
+
+            let mut cluster_splits = Vec::with_capacity(raw.clusters.len());
+            for split in &raw.clusters {
+                let Some(soft_body) = rigidbody_set.soft_body_entity(split.soft_body) else {
+                    continue;
+                };
+                let mut proxy = rigidbody_set.rigid_body_entity(split.proxy);
+                if !split.keeps_proxy {
+                    // The entity of the split cluster: a cluster entity or a soft body entity.
+                    let source = raw
+                        .clusters
+                        .iter()
+                        .find(|s| s.source_cluster == split.source_cluster && s.keeps_proxy)
+                        .and_then(|s| rigidbody_set.rigid_body_entity(s.proxy));
+                    let (pinned, target, shape_matching, material) = source
+                        .and_then(|e| cluster_components.get(e).ok())
+                        .unwrap_or_default();
+                    let target = target.map(|target| {
+                        inherited_kinematic_target(rigidbody_set, &raw, split, target)
+                    });
+
+                    if source.is_some_and(|e| clusters.contains(e)) {
+                        // Give a fresh proxy its own entity if the split cluster had one.
+                        let particles = rigidbody_set
+                            .soft_bodies
+                            .get(split.soft_body)
+                            .and_then(|sb| sb.cluster(split.cluster))
+                            .map(|c| c.particles().to_vec())
+                            .unwrap_or_default();
+                        let pose = rigidbody_set
+                            .bodies
+                            .get(split.proxy)
+                            .map(|rb| utils::iso_to_transform(rb.position()))
+                            .unwrap_or_default();
+                        let mut cluster_commands = commands.spawn((
+                            SoftBodyCluster {
+                                soft_body,
+                                particles,
+                            },
+                            RapierRigidBodyHandle(split.proxy),
+                            RapierContextEntityLink(context_entity),
+                            pose,
+                        ));
+                        // The piece inherits the components driving the split cluster.
+                        if pinned {
+                            cluster_commands.insert(SoftBodyClusterPinned);
+                        }
+                        if let Some(target) = target {
+                            cluster_commands.insert(target);
+                        }
+                        if let Some(shape_matching) = shape_matching {
+                            cluster_commands.insert(*shape_matching);
+                        }
+                        if let Some(material) = material {
+                            cluster_commands.insert(*material);
+                        }
+                        let cluster_entity = cluster_commands.id();
+                        if let Some(rb) = rigidbody_set.bodies.get_mut(split.proxy) {
+                            rb.user_data = cluster_entity.to_bits() as u128;
+                        }
+                        rigidbody_set
+                            .entity2body
+                            .insert(cluster_entity, split.proxy);
+                        proxy = Some(cluster_entity);
+                    } else if let (Some(target), Some(piece)) = (target, proxy) {
+                        // A piece's whole-body cluster: its entity was cloned with the target of
+                        // the torn soft body, which must be shifted too.
+                        commands.entity(piece).try_insert(target);
+                    }
+                }
+                cluster_splits.push(SoftBodyClusterSplit {
+                    source_cluster: split.source_cluster,
+                    soft_body,
+                    cluster: split.cluster,
+                    proxy,
+                    keeps_proxy: split.keeps_proxy,
+                });
+            }
+
+            let moved_joints = raw
+                .moved_joints
+                .iter()
+                .map(|moved| SoftBodyJointMove {
+                    joint: joints.impulse_joint_entity(moved.joint),
+                    from: rigidbody_set.rigid_body_entity(moved.from),
+                    to: rigidbody_set.rigid_body_entity(moved.to),
+                })
+                .collect();
+
+            tear_events.write(SoftBodyTearEvent {
+                context: context_entity,
+                soft_body: torn_entity,
+                pieces,
+                cluster_splits,
+                moved_joints,
+                raw,
+            });
+        }
+    }
+
+    for (entity, components) in remapped {
+        components.insert(&mut commands.entity(entity));
+    }
+}
+
+/// The mesh component a soft-body mesh is rendered with.
+#[cfg(all(feature = "to-bevy-mesh", feature = "dim3"))]
+type SoftBodyMeshComponent = bevy::mesh::Mesh3d;
+/// The mesh component a soft-body mesh is rendered with.
+#[cfg(all(feature = "to-bevy-mesh", feature = "dim2"))]
+type SoftBodyMeshComponent = bevy::mesh::Mesh2d;
+
+/// System responsible for updating the meshes of the soft bodies with a
+/// [`SoftBodyMeshSync`](crate::dynamics::SoftBodyMeshSync) component.
+#[cfg(feature = "to-bevy-mesh")]
+pub fn sync_soft_body_meshes(
+    mut commands: Commands,
+    meshes: Option<ResMut<Assets<bevy::mesh::Mesh>>>,
+    rigid_body_sets: Query<(&RapierRigidBodySet, &RapierContextColliders)>,
+    global_transforms: Query<&GlobalTransform>,
+    mut soft_bodies: Query<(
+        Entity,
+        &RapierSoftBodyHandle,
+        &RapierContextEntityLink,
+        &mut crate::dynamics::SoftBodyMeshSync,
+        Option<&Transform>,
+        Option<&ChildOf>,
+        Option<&SoftBodyMeshComponent>,
+    )>,
+) {
+    use crate::dynamics::{SoftBodyMeshSignature, SoftBodyRenderGeometry};
+    use bevy::mesh::{Indices, Mesh};
+
+    let Some(mut meshes) = meshes else {
+        return;
+    };
+
+    for (entity, handle, link, mut sync, transform, child_of, mesh_component) in
+        soft_bodies.iter_mut()
+    {
+        let Ok((set, colliders)) = rigid_body_sets.get(link.0) else {
+            continue;
+        };
+        let Some(sb) = set.soft_bodies.get(handle.0) else {
+            continue;
+        };
+        let geometry = SoftBodyRenderGeometry::new(sb, &colliders.colliders);
+        // The global transform the entity will have after this frame's transform propagation.
+        let global = match (transform, child_of) {
+            (Some(transform), Some(child_of)) => global_transforms
+                .get(child_of.parent())
+                .map(|parent| parent.mul_transform(*transform))
+                .unwrap_or_else(|_| GlobalTransform::from(*transform)),
+            (Some(transform), None) => GlobalTransform::from(*transform),
+            (None, _) => GlobalTransform::IDENTITY,
+        };
+        let world_to_local = global.affine().inverse();
+        let signature = SoftBodyMeshSignature {
+            handle: handle.0,
+            topology_version: sb.topology_version(),
+            num_vertices: geometry.vertices.len(),
+            num_indices: geometry.indices.len(),
+        };
+
+        if sync.built == Some(signature) {
+            if let Some(mut mesh) = mesh_component.and_then(|m| meshes.get_mut(&m.0)) {
+                mesh.insert_attribute(
+                    Mesh::ATTRIBUTE_POSITION,
+                    geometry.positions(&world_to_local),
+                );
+                if geometry.triangles
+                    && !geometry.indices.is_empty()
+                    && matches!(mesh.indices(), Some(Indices::U32(_)))
+                {
+                    mesh.compute_smooth_normals();
+                }
+                continue;
+            }
+        }
+
+        // First sync or topology change: (re)build the whole mesh.
+        let mesh = geometry.to_mesh(&world_to_local);
+        match mesh_component {
+            Some(component) if meshes.contains(&component.0) => {
+                let _ = meshes.insert(&component.0, mesh);
+            }
+            _ => {
+                let mesh_handle = meshes.add(mesh);
+                commands
+                    .entity(entity)
+                    .insert(SoftBodyMeshComponent::from(mesh_handle));
+            }
+        }
+        sync.built = Some(signature);
+    }
+}
diff --git a/bindings/bevy_rapier/src/plugin/systems/vehicle_controller.rs b/bindings/bevy_rapier/src/plugin/systems/vehicle_controller.rs
new file mode 100644
index 000000000..b93d9c621
--- /dev/null
+++ b/bindings/bevy_rapier/src/plugin/systems/vehicle_controller.rs
@@ -0,0 +1,274 @@
+use crate::control::controller_filter::ControllerExclusions;
+use crate::control::ControllerIgnored;
+use crate::control::{RayCastVehicleController, VehicleWheel, VehicleWheelState};
+use crate::dynamics::RapierRigidBodyHandle;
+use crate::plugin::context::{
+    RapierContextColliders, RapierContextEntityLink, RapierContextSimulation, RapierRigidBodySet,
+};
+use crate::plugin::RapierConfiguration;
+use bevy::ecs::entity::EntityHashSet;
+use bevy::prelude::*;
+use rapier::control::{DynamicRayCastVehicleController, WheelTuning};
+use rapier::geometry::{Collider as RapierCollider, ColliderHandle, ColliderSet};
+use rapier::pipeline::QueryFilter;
+
+/// Rebuilds the Rapier vehicle if its wheel count no longer matches the component's wheels.
+fn sync_raw_vehicle(
+    vehicle: &mut RayCastVehicleController,
+    chassis: rapier::dynamics::RigidBodyHandle,
+) {
+    let wheels_match = vehicle
+        .raw
+        .as_ref()
+        .is_some_and(|raw| raw.wheels().len() == vehicle.wheels.len());
+
+    if !wheels_match {
+        let mut raw = DynamicRayCastVehicleController::new(chassis);
+        for wheel in &vehicle.wheels {
+            let raw_wheel = raw.add_wheel(
+                wheel.chassis_connection_point,
+                wheel.direction,
+                wheel.axle,
+                wheel.suspension_rest_length,
+                wheel.radius,
+                &WheelTuning::default(),
+            );
+            raw_wheel.rotation = wheel.state.rotation;
+        }
+        vehicle.raw = Some(raw);
+    }
+
+    let RayCastVehicleController {
+        wheels,
+        index_up_axis,
+        index_forward_axis,
+        raw,
+        ..
+    } = vehicle;
+    let raw = raw.as_mut().expect("the raw vehicle was just created");
+    raw.chassis = chassis;
+    raw.index_up_axis = *index_up_axis;
+    raw.index_forward_axis = *index_forward_axis;
+
+    for (wheel, raw_wheel) in wheels.iter().zip(raw.wheels_mut()) {
+        wheel.sync_to_raw(raw_wheel);
+    }
+}
+
+fn read_wheel_state(
+    wheel: &mut VehicleWheel,
+    raw: &rapier::control::Wheel,
+    colliders: &ColliderSet,
+) {
+    let info = raw.raycast_info();
+    wheel.state = VehicleWheelState {
+        rotation: raw.rotation,
+        suspension_length: info.suspension_length,
+        is_in_contact: info.is_in_contact,
+        contact_point: info.contact_point_ws,
+        contact_normal: info.contact_normal_ws,
+        hard_point: info.hard_point_ws,
+        center: raw.center(),
+        suspension_direction: raw.suspension(),
+        axle_direction: raw.axle(),
+        ground_entity: info
+            .ground_object
+            .and_then(|h| RapierContextColliders::collider_entity_with_set(colliders, h)),
+        suspension_force: raw.wheel_suspension_force,
+        forward_impulse: raw.forward_impulse,
+        side_impulse: raw.side_impulse,
+    };
+}
+
+/// System responsible for updating the [`RayCastVehicleController`]s before the simulation
+/// step, and writing back their wheels' state.
+pub fn update_vehicle_controllers(
+    mut context_access: Query<(
+        &RapierContextSimulation,
+        &mut RapierContextColliders,
+        &mut RapierRigidBodySet,
+        &RapierConfiguration,
+    )>,
+    mut vehicles: Query<(
+        &RapierContextEntityLink,
+        &RapierRigidBodyHandle,
+        &mut RayCastVehicleController,
+    )>,
+    ignored: Query<Entity, With<ControllerIgnored>>,
+) {
+    let ignored: EntityHashSet = ignored.iter().collect();
+    for (link, handle, mut vehicle) in vehicles.iter_mut() {
+        let Ok((context, mut context_colliders, mut rigidbody_set, config)) =
+            context_access.get_mut(link.0)
+        else {
+            continue;
+        };
+        if !config.physics_pipeline_active {
+            continue;
+        }
+        let context_colliders = &mut *context_colliders;
+        let rigidbody_set = &mut *rigidbody_set;
+        if !rigidbody_set
+            .bodies
+            .get(handle.0)
+            .is_some_and(|body| body.is_enabled())
+        {
+            continue;
+        }
+
+        let vehicle = &mut *vehicle;
+        sync_raw_vehicle(vehicle, handle.0);
+
+        let RayCastVehicleController {
+            wheels,
+            filter_flags,
+            filter_groups,
+            exclude_colliders,
+            exclude_rigid_bodies,
+            filter_predicate,
+            current_vehicle_speed,
+            raw,
+            ..
+        } = vehicle;
+        let raw = raw.as_mut().expect("the raw vehicle was just synchronized");
+
+        let exclusions = ControllerExclusions::new(
+            exclude_colliders,
+            exclude_rigid_bodies,
+            &ignored,
+            filter_predicate.as_ref(),
+            rigidbody_set,
+        );
+        let predicate = |_: ColliderHandle, collider: &RapierCollider| exclusions.test(collider);
+        let filter = QueryFilter {
+            flags: *filter_flags,
+            groups: filter_groups.map(|g| g.into()),
+            exclude_collider: None,
+            // The wheels' rays start inside the chassis, so it must never be hit.
+            exclude_rigid_body: Some(handle.0),
+            predicate: (!exclusions.is_empty())
+                .then_some(&predicate as &dyn Fn(ColliderHandle, &RapierCollider) -> bool),
+        };
+        let query_pipeline = context.broad_phase.as_query_pipeline_mut(
+            context.narrow_phase.query_dispatcher(),
+            &mut rigidbody_set.bodies,
+            &mut context_colliders.colliders,
+            filter,
+        );
+        raw.update_vehicle(context.integration_parameters.dt, query_pipeline);
+
+        *current_vehicle_speed = raw.current_vehicle_speed;
+        for (wheel, raw_wheel) in wheels.iter_mut().zip(raw.wheels()) {
+            read_wheel_state(wheel, raw_wheel, &context_colliders.colliders);
+        }
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+    use crate::geometry::Collider;
+    use crate::plugin::{NoUserData, RapierPhysicsPlugin};
+    use crate::prelude::{RigidBody, Velocity};
+    use bevy::time::{TimePlugin, TimeUpdateStrategy};
+
+    fn vehicle_wheels(hw: f32, hh: f32) -> Vec<VehicleWheel> {
+        let tuning = WheelTuning {
+            suspension_stiffness: 100.0,
+            suspension_damping: 10.0,
+            ..WheelTuning::default()
+        };
+        [
+            Vec3::new(hw * 1.5, -hh, hw),
+            Vec3::new(hw * 1.5, -hh, -hw),
+            Vec3::new(-hw * 1.5, -hh, hw),
+            Vec3::new(-hw * 1.5, -hh, -hw),
+        ]
+        .into_iter()
+        .map(|pos| VehicleWheel::new(pos, -Vec3::Y, Vec3::Z, hh, hh / 4.0, tuning))
+        .collect()
+    }
+
+    #[test]
+    fn vehicle_rests_on_wheels_and_moves_forward() {
+        let mut app = App::new();
+        app.add_plugins((
+            TransformPlugin,
+            TimePlugin,
+            RapierPhysicsPlugin::<NoUserData>::default(),
+        ))
+        .insert_resource(TimeUpdateStrategy::ManualDuration(
+            std::time::Duration::from_secs_f32(1.0 / 60.0),
+        ));
+        app.finish();
+
+        app.world_mut().spawn((
+            Transform::from_xyz(0.0, -0.1, 0.0),
+            Collider::cuboid(50.0, 0.1, 50.0),
+        ));
+
+        let (hw, hh) = (0.3, 0.15);
+        let chassis = app
+            .world_mut()
+            .spawn((
+                Transform::from_xyz(0.0, 0.5, 0.0),
+                RigidBody::Dynamic,
+                Collider::cuboid(hw * 2.0, hh, hw),
+                crate::geometry::ColliderMassProperties::Density(100.0),
+                Velocity::zero(),
+                RayCastVehicleController::new(vehicle_wheels(hw, hh)),
+            ))
+            .id();
+
+        // Let the vehicle settle on its suspension.
+        for _ in 0..120 {
+            app.update();
+        }
+
+        let vehicle = app
+            .world()
+            .get::<RayCastVehicleController>(chassis)
+            .unwrap();
+        assert!(
+            vehicle.wheels.iter().all(|w| w.state.is_in_contact),
+            "All the wheels should touch the ground: {:?}",
+            vehicle.wheels
+        );
+        assert!(vehicle
+            .wheels
+            .iter()
+            .all(|w| w.state.ground_entity.is_some()));
+        let rest_height = app.world().get::<Transform>(chassis).unwrap().translation.y;
+        assert!(
+            rest_height > hh + 0.05,
+            "The chassis should be held above the ground by the suspension"
+        );
+        let start_x = app.world().get::<Transform>(chassis).unwrap().translation.x;
+
+        // Accelerate with the front wheels.
+        {
+            let mut vehicle = app
+                .world_mut()
+                .get_mut::<RayCastVehicleController>(chassis)
+                .unwrap();
+            vehicle.wheels[0].engine_force = 30.0;
+            vehicle.wheels[1].engine_force = 30.0;
+        }
+        for _ in 0..60 {
+            app.update();
+        }
+
+        let end_x = app.world().get::<Transform>(chassis).unwrap().translation.x;
+        let vehicle = app
+            .world()
+            .get::<RayCastVehicleController>(chassis)
+            .unwrap();
+        assert!(
+            end_x > start_x + 0.1,
+            "The vehicle should move forward: {start_x} -> {end_x}"
+        );
+        assert!(vehicle.current_vehicle_speed > 0.0);
+        assert!(vehicle.wheels[0].state.rotation > 0.0);
+        assert!(vehicle.any_wheel_in_contact());
+    }
+}
diff --git a/bindings/bevy_rapier/src/plugin/systems/writeback.rs b/bindings/bevy_rapier/src/plugin/systems/writeback.rs
new file mode 100644
index 000000000..87adcdb49
--- /dev/null
+++ b/bindings/bevy_rapier/src/plugin/systems/writeback.rs
@@ -0,0 +1,84 @@
+use crate::dynamics::MassProperties;
+use crate::dynamics::ReadMassProperties;
+use crate::geometry::{
+    Collider, ColliderMassProperties, RapierColliderHandle, ReadColliderMassProperties,
+};
+use crate::plugin::context::{RapierContextColliders, RapierContextEntityLink, RapierRigidBodySet};
+use crate::plugin::RapierConfiguration;
+use crate::prelude::MassModifiedEvent;
+use bevy::prelude::*;
+
+/// System responsible for writing updated mass properties back into the [`ReadMassProperties`] component.
+pub fn writeback_mass_properties(
+    link: Query<&RapierContextEntityLink>,
+    rigidbody_set: Query<&RapierRigidBodySet>,
+    config: Query<&RapierConfiguration>,
+
+    mut mass_props: Query<&mut ReadMassProperties>,
+    mut mass_modified: MessageReader<MassModifiedEvent>,
+) {
+    for entity in mass_modified.read() {
+        let link = link
+            .get(entity.0)
+            .expect("Could not find `RapierContextEntityLink`");
+        let config = config
+            .get(link.0)
+            .expect("Could not find `RapierConfiguration`");
+        if config.physics_pipeline_active {
+            let Ok(rigidbody_set) = rigidbody_set.get(link.0) else {
+                continue;
+            };
+
+            if let Some(handle) = rigidbody_set.entity2body.get(entity).copied() {
+                if let Some(rb) = rigidbody_set.bodies.get(handle) {
+                    if let Ok(mut mass_props) = mass_props.get_mut(**entity) {
+                        let new_mass_props =
+                            MassProperties::from_rapier(rb.mass_properties().local_mprops);
+
+                        // NOTE: we write the new value only if there was an
+                        //       actual change, in order to not trigger bevy’s
+                        //       change tracking when the values didn’t change.
+                        if mass_props.get() != &new_mass_props {
+                            mass_props.set(new_mass_props);
+                        }
+                    }
+                }
+            }
+        }
+    }
+}
+
+/// System responsible for writing the mass properties of colliders back into the
+/// [`ReadColliderMassProperties`] component.
+///
+/// This runs for colliders that were just created, or with a modified shape or
+/// [`ColliderMassProperties`].
+pub fn writeback_collider_mass_properties(
+    context_colliders: Query<&RapierContextColliders>,
+    mut colliders: Query<
+        (
+            &RapierColliderHandle,
+            &RapierContextEntityLink,
+            &mut ReadColliderMassProperties,
+        ),
+        Or<(
+            Added<RapierColliderHandle>,
+            Added<ReadColliderMassProperties>,
+            Changed<Collider>,
+            Changed<ColliderMassProperties>,
+        )>,
+    >,
+) {
+    for (handle, link, mut mass_props) in colliders.iter_mut() {
+        let Some(co) = context_colliders
+            .get(link.0)
+            .ok()
+            .and_then(|ctxt| ctxt.colliders.get(handle.0))
+        else {
+            continue;
+        };
+
+        // NOTE: only write actual changes to avoid triggering bevy's change detection.
+        mass_props.set_if_neq(ReadColliderMassProperties::from_rapier(co));
+    }
+}
diff --git a/bindings/bevy_rapier/src/plugin/tests.rs b/bindings/bevy_rapier/src/plugin/tests.rs
new file mode 100644
index 000000000..c3f846c11
--- /dev/null
+++ b/bindings/bevy_rapier/src/plugin/tests.rs
@@ -0,0 +1,637 @@
+//! Tests of the simulation pipeline configuration, diagnostics and serialization.
+
+use bevy::prelude::*;
+use bevy::time::{TimePlugin, TimeUpdateStrategy};
+
+use crate::plugin::context::DefaultRapierContext;
+use crate::prelude::*;
+
+/// An app running the physics at a fixed 60Hz timestep.
+fn test_app(plugin: RapierPhysicsPlugin<NoUserData>) -> App {
+    let mut app = App::new();
+    app.add_plugins((TransformPlugin, TimePlugin, plugin));
+    app.insert_resource(TimestepMode::Fixed {
+        dt: 1.0 / 60.0,
+        substeps: 1,
+    });
+    app.insert_resource(TimeUpdateStrategy::ManualDuration(
+        std::time::Duration::from_secs_f32(1.0 / 60.0),
+    ));
+    app.finish();
+    app
+}
+
+fn context_entity(app: &mut App) -> Entity {
+    app.world_mut()
+        .query_filtered::<Entity, With<DefaultRapierContext>>()
+        .single(app.world())
+        .unwrap()
+}
+
+fn configure(app: &mut App, f: impl FnOnce(&mut RapierConfiguration)) {
+    let context = context_entity(app);
+    let mut config = app
+        .world_mut()
+        .get_mut::<RapierConfiguration>(context)
+        .unwrap();
+    f(&mut config);
+}
+
+fn body_translation(app: &mut App, entity: Entity) -> Vect {
+    let context = context_entity(app);
+    let bodies = app.world().get::<RapierRigidBodySet>(context).unwrap();
+    let handle = bodies.entity2body()[&entity];
+    #[allow(clippy::useless_conversion)] // Needed in 3D but not 2D.
+    bodies.bodies[handle].translation().into()
+}
+
+#[derive(Resource)]
+struct Received<M: Message> {
+    messages: Vec<M>,
+}
+
+impl<M: Message> Default for Received<M> {
+    fn default() -> Self {
+        Self { messages: vec![] }
+    }
+}
+
+fn collect<M: Message + Clone>(app: &mut App) {
+    app.init_resource::<Received<M>>().add_systems(
+        PostUpdate,
+        (|mut reader: MessageReader<M>, mut received: ResMut<Received<M>>| {
+            received.messages.extend(reader.read().cloned());
+        })
+        .after(PhysicsSet::Writeback),
+    );
+}
+
+#[test]
+fn quarantine_event_is_sent_for_nan_velocity() {
+    let mut app = test_app(RapierPhysicsPlugin::default());
+    collect::<PhysicsQuarantineEvent>(&mut app);
+    app.update();
+
+    let body = app
+        .world_mut()
+        .spawn((
+            Transform::from_xyz(0.0, 3.0, 0.0),
+            RigidBody::Dynamic,
+            Collider::ball(0.5),
+            Velocity::zero(),
+        ))
+        .id();
+    let healthy = app
+        .world_mut()
+        .spawn((
+            Transform::from_xyz(5.0, 3.0, 0.0),
+            RigidBody::Dynamic,
+            Collider::ball(0.5),
+        ))
+        .id();
+    for _ in 0..3 {
+        app.update();
+    }
+    assert!(app
+        .world()
+        .resource::<Received<PhysicsQuarantineEvent>>()
+        .messages
+        .is_empty());
+
+    app.world_mut().get_mut::<Velocity>(body).unwrap().linear = Vect::splat(crate::math::Real::NAN);
+    app.update();
+
+    let context = context_entity(&mut app);
+    let received = &app
+        .world()
+        .resource::<Received<PhysicsQuarantineEvent>>()
+        .messages;
+    assert_eq!(
+        received,
+        &[PhysicsQuarantineEvent {
+            context,
+            bodies: vec![body],
+            colliders: vec![],
+            soft_bodies: vec![],
+        }]
+    );
+
+    let bodies = app.world().get::<RapierRigidBodySet>(context).unwrap();
+    assert!(!bodies.bodies[bodies.entity2body()[&body]].is_enabled());
+    assert!(bodies.bodies[bodies.entity2body()[&healthy]].is_enabled());
+    assert!(app.world().get::<RigidBodyDisabled>(body).is_some());
+    assert!(app.world().get::<RigidBodyDisabled>(healthy).is_none());
+
+    // Fixing the velocity and removing the component releases the body from the quarantine.
+    *app.world_mut().get_mut::<Velocity>(body).unwrap() = Velocity::linear(Vect::X);
+    app.world_mut()
+        .entity_mut(body)
+        .remove::<RigidBodyDisabled>();
+    app.update();
+    app.update();
+    let bodies = app.world().get::<RapierRigidBodySet>(context).unwrap();
+    let rb = &bodies.bodies[bodies.entity2body()[&body]];
+    assert!(rb.is_enabled());
+    assert!(rb.translation().x > 0.0 && rb.translation().is_finite());
+    assert_eq!(
+        app.world()
+            .resource::<Received<PhysicsQuarantineEvent>>()
+            .messages
+            .len(),
+        1
+    );
+}
+
+#[test]
+fn mass_read_backs_are_inserted_automatically() {
+    let mut app = test_app(RapierPhysicsPlugin::default());
+    app.update();
+    let body = app
+        .world_mut()
+        .spawn((
+            Transform::from_xyz(0.0, 3.0, 0.0),
+            RigidBody::Dynamic,
+            Collider::ball(0.5),
+            ColliderMassProperties::Mass(2.0),
+        ))
+        .id();
+    app.update();
+    app.update();
+
+    let world = app.world();
+    assert_eq!(world.get::<ReadMassProperties>(body).unwrap().mass, 2.0);
+    assert_eq!(
+        world.get::<ReadColliderMassProperties>(body).unwrap().mass,
+        2.0
+    );
+    // The world-space mass properties are opt-in.
+    assert!(world.get::<ReadWorldMassProperties>(body).is_none());
+}
+
+/// Spawns two overlapping dynamic bodies at `y = 3`, and a kinematic and a fixed body far away.
+fn spawn_collision_only_scene(app: &mut App, sensors: bool) -> [Entity; 4] {
+    let collider = |app: &mut App, entity: Entity| {
+        if sensors {
+            app.world_mut().entity_mut(entity).insert(Sensor);
+        }
+    };
+    let body1 = app
+        .world_mut()
+        .spawn((
+            Transform::from_xyz(0.0, 3.0, 0.0),
+            RigidBody::Dynamic,
+            Collider::ball(0.5),
+            ActiveEvents::COLLISION_EVENTS,
+        ))
+        .id();
+    collider(app, body1);
+    let body2 = app
+        .world_mut()
+        .spawn((
+            Transform::from_xyz(0.5, 3.0, 0.0),
+            RigidBody::Dynamic,
+            Collider::ball(0.5),
+        ))
+        .id();
+    let kinematic = app
+        .world_mut()
+        .spawn((
+            Transform::from_xyz(10.0, 0.0, 0.0),
+            RigidBody::KinematicPositionBased,
+            Collider::ball(0.5),
+            ActiveEvents::COLLISION_EVENTS,
+            ActiveCollisionTypes::default() | ActiveCollisionTypes::KINEMATIC_STATIC,
+        ))
+        .id();
+    collider(app, kinematic);
+    let fixed = app
+        .world_mut()
+        .spawn((
+            Transform::from_xyz(-10.0, 0.0, 0.0),
+            RigidBody::Fixed,
+            Collider::ball(0.5),
+        ))
+        .id();
+    [body1, body2, kinematic, fixed]
+}
+
+fn check_collision_only_mode(sensors: bool) {
+    let mut app = test_app(RapierPhysicsPlugin::default());
+    collect::<CollisionEvent>(&mut app);
+    app.update();
+    configure(&mut app, |config| {
+        config.simulation_mode = SimulationMode::CollisionOnly;
+    });
+    let [body1, body2, kinematic, fixed] = spawn_collision_only_scene(&mut app, sensors);
+
+    for _ in 0..10 {
+        app.update();
+    }
+
+    // The overlapping bodies are neither pushed apart nor falling.
+    approx::assert_relative_eq!(body_translation(&mut app, body1), Vect::Y * 3.0);
+    approx::assert_relative_eq!(
+        body_translation(&mut app, body2),
+        Vect::X * 0.5 + Vect::Y * 3.0
+    );
+    assert_eq!(
+        app.world().get::<Transform>(body1).unwrap().translation.y,
+        3.0
+    );
+
+    let received = &app.world().resource::<Received<CollisionEvent>>().messages;
+    assert_eq!(received.len(), 1);
+    assert!(matches!(
+        received[0],
+        CollisionEvent::Started(a, b, _) if (a, b) == (body1, body2) || (a, b) == (body2, body1)
+    ));
+
+    // Moving a kinematic body through its transform still moves its rigid-body and collider.
+    app.world_mut()
+        .get_mut::<Transform>(kinematic)
+        .unwrap()
+        .translation = Vec3::new(0.0, 3.5, 0.0);
+    app.update();
+    approx::assert_relative_eq!(body_translation(&mut app, kinematic), Vect::Y * 3.5);
+    assert_eq!(
+        app.world()
+            .resource::<Received<CollisionEvent>>()
+            .messages
+            .iter()
+            .filter(|e| matches!(e, CollisionEvent::Started(..)))
+            .count(),
+        3
+    );
+
+    // The kinematic body also reports its contacts with fixed bodies.
+    app.world_mut()
+        .get_mut::<Transform>(kinematic)
+        .unwrap()
+        .translation = Vec3::new(-10.0, 0.5, 0.0);
+    app.update();
+    approx::assert_relative_eq!(body_translation(&mut app, fixed), Vect::X * -10.0);
+    let received = &app.world().resource::<Received<CollisionEvent>>().messages;
+    assert!(matches!(
+        received.last(),
+        Some(CollisionEvent::Started(a, b, _)) if (*a, *b) == (kinematic, fixed) || (*a, *b) == (fixed, kinematic)
+    ));
+}
+
+#[test]
+fn collision_only_mode_detects_intersections_without_dynamics() {
+    check_collision_only_mode(true);
+}
+
+#[test]
+fn collision_only_mode_detects_contacts_without_dynamics() {
+    check_collision_only_mode(false);
+}
+
+fn num_steps(app: &mut App) -> usize {
+    let context = context_entity(app);
+    app.world()
+        .get::<RapierContextSimulation>(context)
+        .unwrap()
+        .step_stats()
+        .num_steps
+}
+
+#[test]
+fn zero_dt_frames_do_not_step() {
+    let mut app = test_app(RapierPhysicsPlugin::default());
+    app.insert_resource(TimestepMode::default());
+    let body = app
+        .world_mut()
+        .spawn((
+            Transform::from_xyz(0.0, 3.0, 0.0),
+            RigidBody::Dynamic,
+            Collider::ball(0.5),
+        ))
+        .id();
+
+    // The first frame has a zero delta time: nothing is stepped but the body is still created.
+    app.update();
+    assert_eq!(num_steps(&mut app), 0);
+    assert_eq!(body_translation(&mut app, body).y, 3.0);
+
+    app.update();
+    assert_eq!(num_steps(&mut app), 1);
+    assert!(body_translation(&mut app, body).y < 3.0);
+
+    // Same with a zero fixed dt.
+    app.insert_resource(TimestepMode::Fixed {
+        dt: 0.0,
+        substeps: 1,
+    });
+    let y = body_translation(&mut app, body).y;
+    app.update();
+    assert_eq!(num_steps(&mut app), 0);
+    assert_eq!(body_translation(&mut app, body).y, y);
+}
+
+#[test]
+fn diagnostics_are_measured_after_a_step() {
+    let mut app = App::new();
+    app.add_plugins((
+        TransformPlugin,
+        TimePlugin,
+        RapierPhysicsPlugin::<NoUserData>::default(),
+        RapierDiagnosticsPlugin::default(),
+    ));
+    app.insert_resource(TimestepMode::Fixed {
+        dt: 1.0 / 60.0,
+        substeps: 2,
+    });
+    app.finish();
+    app.update();
+
+    app.world_mut().spawn((
+        Transform::from_xyz(0.0, 0.0, 0.0),
+        RigidBody::Fixed,
+        Collider::ball(1.0),
+    ));
+    app.world_mut().spawn((
+        Transform::from_xyz(0.0, 1.5, 0.0),
+        RigidBody::Dynamic,
+        Collider::ball(1.0),
+    ));
+    app.update();
+    app.update();
+
+    let store = app.world().resource::<bevy::diagnostic::DiagnosticsStore>();
+    let value = |path| store.get(&path).unwrap().value();
+    assert!(value(RapierDiagnosticsPlugin::STEP_TIME).unwrap() > 0.0);
+    assert_eq!(value(RapierDiagnosticsPlugin::STEPS), Some(2.0));
+    assert_eq!(value(RapierDiagnosticsPlugin::RIGID_BODIES), Some(2.0));
+    assert_eq!(value(RapierDiagnosticsPlugin::COLLIDERS), Some(2.0));
+    assert_eq!(value(RapierDiagnosticsPlugin::CONTACT_PAIRS), Some(1.0));
+    assert_eq!(
+        value(RapierDiagnosticsPlugin::ACTIVE_CONTACT_PAIRS),
+        Some(1.0)
+    );
+    assert!(value(RapierDiagnosticsPlugin::CONTACT_CONSTRAINTS).unwrap() >= 1.0);
+    assert!(value(RapierDiagnosticsPlugin::SOLVER_CONSTRAINTS).unwrap() >= 1.0);
+    assert_eq!(value(RapierDiagnosticsPlugin::CCD_SUBSTEPS), Some(0.0));
+    #[cfg(feature = "profiler")]
+    assert!(value(RapierDiagnosticsPlugin::SOLVER_TIME).is_some());
+
+    let context = context_entity(&mut app);
+    let stats = app
+        .world()
+        .get::<RapierContextSimulation>(context)
+        .unwrap()
+        .step_stats();
+    assert_eq!(stats.num_steps, 2);
+    assert_eq!(stats.num_contact_pairs, 1);
+    // Each step solves the contact manifold between the two balls.
+    assert_eq!(stats.num_solver_constraints, 2);
+}
+
+#[test]
+fn diagnostics_sum_every_context_and_measure_each_one() {
+    let mut app = App::new();
+    app.add_plugins((
+        TransformPlugin,
+        TimePlugin,
+        RapierPhysicsPlugin::<NoUserData>::default(),
+        RapierDiagnosticsPlugin::default().with_per_context_diagnostics(true),
+    ));
+    app.insert_resource(TimestepMode::Fixed {
+        dt: 1.0 / 60.0,
+        substeps: 1,
+    });
+    app.finish();
+    app.update();
+
+    let default_context = context_entity(&mut app);
+    let other_context = app
+        .world_mut()
+        .spawn(RapierContextSimulation::default())
+        .id();
+    for (context, num_bodies) in [(default_context, 1), (other_context, 2)] {
+        for i in 0..num_bodies {
+            app.world_mut().spawn((
+                Transform::from_xyz(i as f32 * 5.0, 0.0, 0.0),
+                RigidBody::Dynamic,
+                Collider::ball(1.0),
+                RapierContextEntityLink(context),
+            ));
+        }
+    }
+    // The per-context diagnostics are registered on the first measurement.
+    for _ in 0..3 {
+        app.update();
+    }
+
+    let store = app.world().resource::<bevy::diagnostic::DiagnosticsStore>();
+    let value = |path| store.get(&path).and_then(|d| d.value());
+    let context_value =
+        |path, context| value(RapierDiagnosticsPlugin::context_path(&path, context));
+    assert_eq!(value(RapierDiagnosticsPlugin::RIGID_BODIES), Some(3.0));
+    assert_eq!(value(RapierDiagnosticsPlugin::STEPS), Some(2.0));
+    assert_eq!(
+        context_value(RapierDiagnosticsPlugin::RIGID_BODIES, default_context),
+        Some(1.0)
+    );
+    assert_eq!(
+        context_value(RapierDiagnosticsPlugin::RIGID_BODIES, other_context),
+        Some(2.0)
+    );
+    assert_eq!(
+        context_value(RapierDiagnosticsPlugin::STEPS, other_context),
+        Some(1.0)
+    );
+    assert_eq!(
+        RapierDiagnosticsPlugin::context_path(&RapierDiagnosticsPlugin::STEP_TIME, other_context)
+            .as_str(),
+        format!("rapier/{other_context}/step_time")
+    );
+}
+
+#[cfg(feature = "serde-serialize")]
+#[test]
+fn broad_phase_optimization_strategy_is_applied() {
+    for strategy in [
+        BroadPhaseOptimizationStrategy::None,
+        BroadPhaseOptimizationStrategy::SubtreeOptimizer,
+    ] {
+        let RapierContextInitialization::InitializeDefaultRapierContext {
+            integration_parameters,
+            rapier_configuration,
+            ..
+        } = RapierContextInitialization::default()
+        else {
+            unreachable!()
+        };
+        let mut app = test_app(RapierPhysicsPlugin::default().with_custom_initialization(
+            RapierContextInitialization::InitializeDefaultRapierContext {
+                integration_parameters,
+                rapier_configuration,
+                broad_phase_optimization_strategy: strategy,
+            },
+        ));
+        app.update();
+
+        // Rapier doesn't expose the strategy, but serializes it.
+        let context = context_entity(&mut app);
+        let simulation = app.world().get::<RapierContextSimulation>(context).unwrap();
+        let json = serde_json::to_value(&simulation.broad_phase).unwrap();
+        let expected = match strategy {
+            BroadPhaseOptimizationStrategy::None => "None",
+            BroadPhaseOptimizationStrategy::SubtreeOptimizer => "SubtreeOptimizer",
+        };
+        assert_eq!(json["optimization_strategy"], expected);
+    }
+}
+
+#[cfg(feature = "serde-serialize")]
+#[test]
+fn configuration_serialization_round_trip() {
+    let config = RapierConfiguration {
+        simulation_mode: SimulationMode::CollisionOnly,
+        num_threads: Some(3),
+        ..RapierConfiguration::new(2.0)
+    };
+    let json = serde_json::to_string(&config).unwrap();
+    let restored: RapierConfiguration = serde_json::from_str(&json).unwrap();
+    assert_eq!(restored.gravity, config.gravity);
+    assert_eq!(restored.simulation_mode, config.simulation_mode);
+    assert_eq!(restored.num_threads, config.num_threads);
+
+    let timestep = TimestepMode::Interpolated {
+        dt: 0.5,
+        time_scale: 2.0,
+        substeps: 3,
+    };
+    let json = serde_json::to_string(&timestep).unwrap();
+    assert_eq!(
+        serde_json::from_str::<TimestepMode>(&json).unwrap(),
+        timestep
+    );
+
+    let json = serde_json::to_string(&RapierContextInitialization::default()).unwrap();
+    let RapierContextInitialization::InitializeDefaultRapierContext {
+        integration_parameters,
+        ..
+    } = serde_json::from_str(&json).unwrap()
+    else {
+        panic!("unexpected initialization");
+    };
+    assert_eq!(integration_parameters.length_unit, 1.0);
+}
+
+#[cfg(all(feature = "parallel", not(feature = "unsync-callbacks")))]
+#[test]
+fn thread_pool_configuration_is_applied() {
+    let mut app = test_app(RapierPhysicsPlugin::default());
+    app.update();
+    let context = context_entity(&mut app);
+    let num_threads = |app: &App| {
+        app.world()
+            .get::<RapierContextSimulation>(context)
+            .unwrap()
+            .pipeline
+            .num_threads()
+    };
+    assert_eq!(num_threads(&app), None);
+
+    configure(&mut app, |config| config.num_threads = Some(2));
+    app.update();
+    assert_eq!(num_threads(&app), Some(2));
+
+    configure(&mut app, |config| config.num_threads = None);
+    app.update();
+    assert_eq!(num_threads(&app), None);
+}
+
+#[cfg(feature = "serde-serialize")]
+#[test]
+fn serialization_round_trip_restores_entity_maps() {
+    use crate::plugin::context::{RapierContextColliders, RapierContextJoints};
+
+    let mut app = test_app(RapierPhysicsPlugin::default());
+    app.update();
+
+    let ground = app
+        .world_mut()
+        .spawn((
+            Transform::from_xyz(0.0, -1.0, 0.0),
+            RigidBody::Fixed,
+            Collider::ball(1.0),
+        ))
+        .id();
+    let body = app
+        .world_mut()
+        .spawn((
+            Transform::from_xyz(0.0, 5.0, 0.0),
+            RigidBody::Dynamic,
+            Collider::ball(0.5),
+        ))
+        .id();
+    let jointed = app
+        .world_mut()
+        .spawn((
+            Transform::from_xyz(2.0, 5.0, 0.0),
+            RigidBody::Dynamic,
+            Collider::ball(0.5),
+            ImpulseJoint::new(body, FixedJointBuilder::new().local_anchor2(Vect::X * -2.0)),
+        ))
+        .id();
+    for _ in 0..5 {
+        app.update();
+    }
+
+    let context = context_entity(&mut app);
+    let world = app.world();
+    let simulation = world.get::<RapierContextSimulation>(context).unwrap();
+    let colliders = world.get::<RapierContextColliders>(context).unwrap();
+    let bodies = world.get::<RapierRigidBodySet>(context).unwrap();
+    let joints = world.get::<RapierContextJoints>(context).unwrap();
+
+    let simulation_json = serde_json::to_string(simulation).unwrap();
+    let colliders_json = serde_json::to_string(colliders).unwrap();
+    let bodies_json = serde_json::to_string(bodies).unwrap();
+    let joints_json = serde_json::to_string(joints).unwrap();
+
+    let restored_simulation: RapierContextSimulation =
+        serde_json::from_str(&simulation_json).unwrap();
+    let restored_colliders: RapierContextColliders = serde_json::from_str(&colliders_json).unwrap();
+    let restored_bodies: RapierRigidBodySet = serde_json::from_str(&bodies_json).unwrap();
+    let restored_joints: RapierContextJoints = serde_json::from_str(&joints_json).unwrap();
+
+    assert_eq!(restored_bodies.entity2body(), bodies.entity2body());
+    assert_eq!(
+        restored_colliders.entity2collider(),
+        colliders.entity2collider()
+    );
+    assert_eq!(
+        restored_joints.entity2impulse_joint(),
+        joints.entity2impulse_joint()
+    );
+    assert_eq!(restored_joints.entity2impulse_joint().len(), 1);
+    for entity in [ground, body, jointed] {
+        let handle = restored_bodies.entity2body()[&entity];
+        assert_eq!(restored_bodies.rigid_body_entity(handle), Some(entity));
+        let collider = restored_colliders.entity2collider()[&entity];
+        assert_eq!(restored_colliders.collider_entity(collider), Some(entity));
+    }
+
+    // Restore the snapshot and check that the simulation continues.
+    let before = body_translation(&mut app, body);
+    app.world_mut().entity_mut(context).insert((
+        restored_simulation,
+        restored_colliders,
+        restored_bodies,
+        restored_joints,
+    ));
+    for _ in 0..5 {
+        app.update();
+    }
+    let after = body_translation(&mut app, body);
+    assert!(after.y < before.y, "{after} should be below {before}");
+
+    let world = app.world();
+    let bodies = world.get::<RapierRigidBodySet>(context).unwrap();
+    let handle = bodies.entity2body()[&body];
+    assert_eq!(bodies.rigid_body_entity(handle), Some(body));
+}
diff --git a/bindings/bevy_rapier/src/reflect/mod.rs b/bindings/bevy_rapier/src/reflect/mod.rs
new file mode 100644
index 000000000..4c83e4cd7
--- /dev/null
+++ b/bindings/bevy_rapier/src/reflect/mod.rs
@@ -0,0 +1,597 @@
+use crate::math::Real;
+use bevy::reflect::reflect_remote;
+#[cfg(feature = "fem")]
+use rapier::dynamics::SoftFemParameters;
+use rapier::dynamics::{
+    SoftBodiesSettings, SoftBodyMaterial as RapierSoftBodyMaterial, SoftEdgePlasticFlow,
+    SoftPatchConstraints, SoftRecoverySettings,
+};
+use rapier::{dynamics::IntegrationParameters, prelude::SpringCoefficients};
+
+#[cfg(feature = "dim3")]
+use rapier::dynamics::FrictionModel;
+
+/// Friction models used for all contact constraints between two rigid-bodies.
+///
+/// This selection does not apply to multibodies that always rely on the [`FrictionModel::Coulomb`].
+#[cfg(feature = "dim3")]
+#[reflect_remote(FrictionModel)]
+#[derive(Default, Copy, Clone, Debug, PartialEq, Eq)]
+#[cfg_attr(feature = "serde-serialize", derive(Serialize, Deserialize))]
+pub enum FrictionModelWrapper {
+    /// A simplified friction model significantly faster to solve than [`Self::Coulomb`]
+    /// but less accurate.
+    ///
+    /// Instead of solving one Coulomb friction constraint per contact in a contact manifold,
+    /// this approximation only solves one Coulomb friction constraint per group of 4 contacts
+    /// in a contact manifold, plus one "twist" constraint. The "twist" constraint is purely
+    /// rotational and aims to eliminate angular movement in the manifold’s tangent plane.
+    #[default]
+    Simplified,
+    /// The coulomb friction model.
+    ///
+    /// This results in one Coulomb friction constraint per contact point.
+    Coulomb,
+}
+
+#[reflect_remote(SpringCoefficients<Real>)]
+#[derive(Copy, Clone, Debug, PartialEq)]
+/// Coefficients for a spring, typically used for configuring constraint softness for contacts and
+/// joints.
+pub struct SpringCoefficientsWrapper {
+    /// Sets the natural frequency (Hz) of the spring-like constraint.
+    ///
+    /// Higher values make the constraint stiffer and resolve constraint violations more quickly.
+    pub natural_frequency: Real,
+    /// Sets the damping ratio for the spring-like constraint.
+    ///
+    /// Larger values make the joint more compliant (allowing more drift before stabilization).
+    pub damping_ratio: Real,
+}
+
+#[reflect_remote(SoftPatchConstraints)]
+#[derive(Copy, Clone, Debug, PartialEq, Eq)]
+#[cfg_attr(feature = "serde-serialize", derive(Serialize, Deserialize))]
+/// What the per-point constraints of the features a soft-body volume constraint acts on do.
+pub enum SoftPatchConstraintsWrapper {
+    /// Keep them as they are (they may fight the volume constraint).
+    Keep,
+    /// Stand them down: the volume constraint alone acts on those features.
+    StandDown,
+    /// Keep them but along the volume constraint's normal, with their separation measured along
+    /// it, so they push the way the constraint does.
+    AlongNormal,
+}
+
+#[reflect_remote(SoftRecoverySettings)]
+#[derive(Copy, Clone, Debug, PartialEq, Default)]
+#[cfg_attr(feature = "serde-serialize", derive(Serialize, Deserialize))]
+/// Runtime configuration of the soft-body tangle detection and recovery stack.
+///
+/// See [`SoftRecoverySettings`] for the details of each field.
+pub struct SoftRecoverySettingsWrapper {
+    /// Raise the speculative contact margin from velocities authored between steps (default:
+    /// `true`).
+    pub authored_velocity_margin: bool,
+    /// Give the edge-vs-edge pass a speculative reach (default: `false`).
+    pub edge_speculation: bool,
+    /// Detect inverted cells each step (default: `true`).
+    pub inverted_cell_detection: bool,
+    /// Detect surface self-crossings each step (default: `true`).
+    pub self_crossing_detection: bool,
+    /// Skip the self-crossing sweep while the surface barely moved (default: `true`).
+    pub detection_motion_gating: bool,
+    /// Detect boundary crossings between pairs of soft surfaces (default: `true`).
+    pub cross_body_detection: bool,
+    /// Self contacts of tangled features stand down (default: `true`).
+    pub self_stand_down: bool,
+    /// A vertex constraint touching a boundary crossing between two surfaces may only expel
+    /// (default: `true`).
+    pub cross_body_expel_gate: bool,
+    /// Edge constraints touching a cross-body boundary crossing stand down (default: `true`).
+    pub edge_stand_down: bool,
+    /// Constraints on crossing-flagged features repel instead of standing down (default:
+    /// `false`).
+    pub crossing_repulsion: bool,
+    /// Guide the crossing repulsion by the pair's volume normal (default: `false`).
+    pub crossing_repulsion_guide: bool,
+    /// Guide the self-crossing repulsion by the fold's volume normal (default: `false`).
+    pub crossing_repulsion_self_guide: bool,
+    /// Material recovery pace, in length units per second (default: `0.5`).
+    pub recovery_pace: Real,
+    /// Intersection-volume contact constraints for closed surfaces (default: `true`).
+    pub overlap_constraints: bool,
+    /// Overlap constraints against rigid colliders too (default: `true`).
+    pub overlap_rigid: bool,
+    /// A self-crossed mesh takes no pair constraint (default: `true`).
+    pub overlap_skip_self_tangled: bool,
+    /// The 3D closed-closed edge constraints stand down on a pair an overlap constraint owns
+    /// (default: `true`).
+    pub overlap_edge_stand_down: bool,
+    /// Bound on the velocity change the coupled constraint may hand any side per step, in
+    /// multiples of the recovery pace (default: `1.0`).
+    pub overlap_constraint_pace: Real,
+    /// What the per-point constraints of the features inside a volume constraint's patch do
+    /// (default: `AlongNormal`).
+    #[reflect(remote = SoftPatchConstraintsWrapper)]
+    pub overlap_patch_constraints: SoftPatchConstraints,
+    /// Measure the intersection volume on the contact skins (default: `false`).
+    pub overlap_skin_volume: bool,
+    /// The skin overlap kept at rest, as a fraction of the pair's skins (default: `0.0`).
+    pub overlap_kept_depth: Real,
+    /// Volume constraints on a body's self-overlaps between distinct surface regions (default:
+    /// `false`).
+    pub overlap_self_regions: bool,
+    /// Push along each constraint's normal instead of the volume gradients (default: `true`).
+    pub overlap_normal_push: bool,
+    /// Split each pair's patch into a grid of cells with their own constraint (default:
+    /// `false`).
+    pub overlap_multi_volume: bool,
+    /// Cells per tangent axis of the multi-volume grid (default: `3`).
+    pub overlap_split: u32,
+    /// Steps without progress of a pair's volume estimate before its positional correction
+    /// stands down (default: `240`).
+    pub overlap_patience: u32,
+    /// Relative drop of the estimate that counts as progress for the patience (default:
+    /// `0.02`).
+    pub overlap_progress_margin: Real,
+}
+
+#[cfg(feature = "fem")]
+#[reflect_remote(SoftFemParameters)]
+#[derive(Copy, Clone, Debug, PartialEq, Default)]
+#[cfg_attr(feature = "serde-serialize", derive(Serialize, Deserialize))]
+/// Tuning of the FEM soft-body solver.
+pub struct SoftFemParametersWrapper {
+    /// Relative residual at which the conjugate gradient stops (default: `1.0e-5`).
+    pub linear_tolerance: Real,
+    /// Hard cap on the conjugate-gradient iterations (default: `20`).
+    pub max_linear_iterations: usize,
+    /// Largest number of degrees of freedom for which the step-start matrix of a body is
+    /// factorized directly (default: `600`).
+    pub max_dense_dofs: usize,
+}
+
+// Duplicated because `reflect_remote` doesn't support conditional fields.
+#[cfg(not(feature = "fem"))]
+#[reflect_remote(SoftBodiesSettings)]
+#[derive(Copy, Clone, Debug, PartialEq, Default)]
+#[cfg_attr(feature = "serde-serialize", derive(Serialize, Deserialize))]
+/// Simulation settings shared by every soft body of a Rapier context.
+pub struct SoftBodiesSettingsWrapper {
+    /// Runtime toggles and tuning for the soft-body tangle detection and recovery stack.
+    #[reflect(remote = SoftRecoverySettingsWrapper)]
+    pub recovery: SoftRecoverySettings,
+    /// Strain beyond which a soft-body constraint is re-solved after the contacts inside every
+    /// substep (default: `0.75`).
+    pub resweep_strain: Real,
+    /// Maximum number of extra substeps a soft body requests for its island while it is hit fast
+    /// (default: `4`).
+    pub max_extra_substeps: usize,
+    /// Factor applied to the contact softness natural frequencies for the soft-body contacts
+    /// (default: `4.0`).
+    pub contact_stiffening: Real,
+}
+
+#[cfg(feature = "fem")]
+#[reflect_remote(SoftBodiesSettings)]
+#[derive(Copy, Clone, Debug, PartialEq, Default)]
+#[cfg_attr(feature = "serde-serialize", derive(Serialize, Deserialize))]
+/// Simulation settings shared by every soft body of a Rapier context.
+pub struct SoftBodiesSettingsWrapper {
+    /// Runtime toggles and tuning for the soft-body tangle detection and recovery stack.
+    #[reflect(remote = SoftRecoverySettingsWrapper)]
+    pub recovery: SoftRecoverySettings,
+    /// Strain beyond which a soft-body constraint is re-solved after the contacts inside every
+    /// substep (default: `0.75`).
+    pub resweep_strain: Real,
+    /// Maximum number of extra substeps a soft body requests for its island while it is hit fast
+    /// (default: `4`).
+    pub max_extra_substeps: usize,
+    /// Factor applied to the contact softness natural frequencies for the soft-body contacts
+    /// (default: `4.0`).
+    pub contact_stiffening: Real,
+    /// Tuning of the FEM soft-body solver.
+    #[reflect(remote = SoftFemParametersWrapper)]
+    pub fem: SoftFemParameters,
+}
+
+#[reflect_remote(SoftEdgePlasticFlow)]
+#[derive(Copy, Clone, Debug, PartialEq, Eq, Default)]
+/// Which strains make a soft-body edge flow plastically.
+pub enum SoftEdgePlasticFlowWrapper {
+    /// Both a squeeze and a stretch past the yield take a permanent set.
+    #[default]
+    Both,
+    /// Only a squeeze sets.
+    Compression,
+    /// Only a stretch sets.
+    Tension,
+}
+
+#[reflect_remote(RapierSoftBodyMaterial)]
+#[derive(Copy, Clone, Debug, PartialEq, Default)]
+/// The stiffness, damping, plasticity and tearing parameters of a soft body.
+///
+/// See [`RapierSoftBodyMaterial`] for the details of each field.
+pub struct SoftBodyMaterialWrapper {
+    /// Softness of the structural edges.
+    #[reflect(remote = SpringCoefficientsWrapper)]
+    pub edge_softness: SpringCoefficients<Real>,
+    /// Softness of the bending edges and dihedral constraints.
+    #[reflect(remote = SpringCoefficientsWrapper)]
+    pub bend_softness: SpringCoefficients<Real>,
+    /// Softness of the per-cell volume constraints and of the global volume preservation.
+    #[reflect(remote = SpringCoefficientsWrapper)]
+    pub volume_softness: SpringCoefficients<Real>,
+    /// Softness of the shape-matching constraints.
+    #[reflect(remote = SpringCoefficientsWrapper)]
+    pub shape_matching_softness: SpringCoefficients<Real>,
+    /// Young's modulus of the elastic cells.
+    pub young_modulus: Real,
+    /// Poisson's ratio of the elastic cells, in `[0, 0.5)`.
+    pub poisson_ratio: Real,
+    /// Damping ratio of the elastic cells.
+    pub elastic_damping_ratio: Real,
+    /// Plastic yield of the elastic cells (`0.0`: no plasticity).
+    pub plastic_yield: Real,
+    /// Rate (per second) at which the strain in excess of the yield is absorbed into the rest
+    /// shape.
+    pub plastic_creep: Real,
+    /// Largest accumulated plastic deformation of a cell.
+    pub plastic_max: Real,
+    /// Rate (per second) at which the particles' velocities are pulled toward the body's best-fit
+    /// rigid motion.
+    pub deformation_damping: Real,
+    /// Plastic yield of the edges (`0.0`: none).
+    pub edge_plastic_yield: Real,
+    /// Rate (per second) at which an edge's strain in excess of its yield is absorbed into its
+    /// rest length.
+    pub edge_plastic_creep: Real,
+    /// Largest permanent set an edge may accumulate, as a fraction of its initial length.
+    pub edge_plastic_max: Real,
+    /// Whether the edges take a permanent set under a squeeze, a stretch, or both.
+    #[reflect(remote = SoftEdgePlasticFlowWrapper)]
+    pub edge_plastic_flow: SoftEdgePlasticFlow,
+    /// Strain beyond which elements break (`None`: unbreakable).
+    pub tear_strain: Option<Real>,
+    /// Force beyond which the edges break (`None`: unbreakable).
+    pub tear_force: Option<Real>,
+    /// Time constant, in seconds, over which an element's load is smoothed before the tear test.
+    pub tear_smoothing: Real,
+    /// How much tougher an undamaged interior element is than a surface one.
+    pub interior_strength: Real,
+    /// Maximum number of edges torn per step.
+    pub max_tears_per_step: u32,
+    /// The smallest piece, in measure elements, a tear may split off.
+    pub min_piece: Option<u32>,
+}
+
+#[cfg(not(feature = "dim3"))]
+#[reflect_remote(IntegrationParameters)]
+#[derive(Copy, Clone, Debug, PartialEq)]
+/// Parameters for a time-step of the physics engine.
+pub struct IntegrationParametersWrapper {
+    /// The timestep length (default: `1.0 / 60.0`).
+    pub dt: Real,
+    /// Minimum timestep size when using CCD with multiple substeps (default: `1.0 / 60.0 / 100.0`).
+    ///
+    /// When CCD with multiple substeps is enabled, the timestep is subdivided
+    /// into smaller pieces. This timestep subdivision won't generate timestep
+    /// lengths smaller than `min_ccd_dt`.
+    ///
+    /// Setting this to a large value will reduce the opportunity to performing
+    /// CCD substepping, resulting in potentially more time dropped by the
+    /// motion-clamping mechanism. Setting this to an very small value may lead
+    /// to numerical instabilities.
+    pub min_ccd_dt: Real,
+
+    /// Softness coefficients for contact constraints.
+    #[reflect(remote = SpringCoefficientsWrapper)]
+    pub contact_softness: SpringCoefficients<Real>,
+
+    /// Softness coefficients for contact constraints where one side is a fixed body.
+    ///
+    /// Stiffer than [`IntegrationParameters::contact_softness`] by default so bodies are
+    /// held firmly against static walls/floors; set equal to
+    /// [`IntegrationParameters::contact_softness`] to disable.
+    #[reflect(remote = SpringCoefficientsWrapper)]
+    pub static_contact_softness: SpringCoefficients<Real>,
+
+    /// The coefficient in `[0, 1]` applied to warmstart impulses, i.e., impulses that are used as the
+    /// initial solution (instead of 0) at the next simulation step.
+    ///
+    /// This should generally be set to 1.
+    ///
+    /// (default `1.0`).
+    pub warmstart_coefficient: Real,
+
+    /// The approximate size of most dynamic objects in the scene.
+    ///
+    /// This value is used internally to estimate some length-based tolerance. In particular, the
+    /// values [`IntegrationParameters::allowed_linear_error`],
+    /// [`IntegrationParameters::max_corrective_velocity`],
+    /// [`IntegrationParameters::prediction_distance`], [`RigidBodyActivation::normalized_linear_threshold`]
+    /// are scaled by this value implicitly.
+    ///
+    /// This value can be understood as the number of units-per-meter in your physical world compared
+    /// to a human-sized world in meter. For example, in a 2d game, if your typical object size is 100
+    /// pixels, set the [`Self::length_unit`] parameter to 100.0. The physics engine will interpret
+    /// it as if 100 pixels is equivalent to 1 meter in its various internal threshold.
+    /// (default `1.0`).
+    pub length_unit: Real,
+
+    /// Amount of penetration the engine won’t attempt to correct (default: `0.001m`).
+    ///
+    /// This value is implicitly scaled by [`IntegrationParameters::length_unit`].
+    pub normalized_allowed_linear_error: Real,
+    /// Maximum amount of penetration the solver will attempt to resolve in one timestep (default: `10.0`).
+    ///
+    /// This value is implicitly scaled by [`IntegrationParameters::length_unit`].
+    pub normalized_max_corrective_velocity: Real,
+    /// The maximal distance separating two objects that will generate predictive contacts (default: `0.002m`).
+    ///
+    /// This value is implicitly scaled by [`IntegrationParameters::length_unit`].
+    pub normalized_prediction_distance: Real,
+    /// Maximum linear velocity a body may have after each solver substep (default: `400.0` m/s).
+    ///
+    /// This value is implicitly scaled by [`IntegrationParameters::length_unit`].
+    pub normalized_max_linear_velocity: Real,
+    /// The number of solver iterations run by the constraints solver for calculating forces (default: `4`).
+    pub num_solver_iterations: usize,
+    /// Number of internal Project Gauss Seidel (PGS) iterations run at each solver iteration (default: `1`).
+    pub num_internal_pgs_iterations: usize,
+    /// The number of stabilization iterations run at each solver iterations (default: `1`).
+    pub num_internal_stabilization_iterations: usize,
+    /// Maximum number of substeps performed by the  solver (default: `1`).
+    pub max_ccd_substeps: usize,
+    /// If enabled, contact manifolds of a collider pair sharing (nearly) the same normal are
+    /// merged into one "cluster" manifold before constraint generation (default: `true`, 3D only).
+    pub contact_clustering: bool,
+    /// If enabled, a contact pair that barely moved since its last full narrow-phase update
+    /// skips contact determination and keeps its existing contact points (default: `true`).
+    pub contact_recycling: bool,
+    /// Maximum relative-pose drift below which a contact pair may be recycled instead of fully
+    /// updated (default: `0.05`). Only used when contact recycling is enabled.
+    ///
+    /// This value is implicitly scaled by [`IntegrationParameters::length_unit`].
+    pub normalized_contact_recycle_distance: Real,
+    /// If `false`, friction is only solved during the unbiased (relax) pass of each substep
+    /// instead of both passes (default: `false`).
+    pub friction_in_bias_pass: bool,
+    /// If enabled, impulse-joint constraints are warm-started like contacts (default: `false`).
+    pub warmstart_joints: bool,
+    /// Simulation settings shared by every soft body.
+    #[reflect(remote = SoftBodiesSettingsWrapper)]
+    pub soft_bodies: rapier::dynamics::SoftBodiesSettings,
+}
+
+// These structs are duplicated in their entirety due to [`FrictionModel`] not being available in 2D, and `bevy::reflect_remote` not supporting conditional fields.
+#[cfg(feature = "dim3")]
+#[reflect_remote(IntegrationParameters)]
+#[derive(Copy, Clone, Debug, PartialEq)]
+/// Parameters for a time-step of the physics engine.
+pub struct IntegrationParametersWrapper {
+    /// The timestep length (default: `1.0 / 60.0`).
+    pub dt: Real,
+    /// Minimum timestep size when using CCD with multiple substeps (default: `1.0 / 60.0 / 100.0`).
+    ///
+    /// When CCD with multiple substeps is enabled, the timestep is subdivided
+    /// into smaller pieces. This timestep subdivision won't generate timestep
+    /// lengths smaller than `min_ccd_dt`.
+    ///
+    /// Setting this to a large value will reduce the opportunity to performing
+    /// CCD substepping, resulting in potentially more time dropped by the
+    /// motion-clamping mechanism. Setting this to an very small value may lead
+    /// to numerical instabilities.
+    pub min_ccd_dt: Real,
+
+    /// Softness coefficients for contact constraints.
+    #[reflect(remote = SpringCoefficientsWrapper)]
+    pub contact_softness: SpringCoefficients<Real>,
+
+    /// Softness coefficients for contact constraints where one side is a fixed body.
+    ///
+    /// Stiffer than [`IntegrationParameters::contact_softness`] by default so bodies are
+    /// held firmly against static walls/floors; set equal to
+    /// [`IntegrationParameters::contact_softness`] to disable.
+    #[reflect(remote = SpringCoefficientsWrapper)]
+    pub static_contact_softness: SpringCoefficients<Real>,
+
+    /// The coefficient in `[0, 1]` applied to warmstart impulses, i.e., impulses that are used as the
+    /// initial solution (instead of 0) at the next simulation step.
+    ///
+    /// This should generally be set to 1.
+    ///
+    /// (default `1.0`).
+    pub warmstart_coefficient: Real,
+
+    /// The approximate size of most dynamic objects in the scene.
+    ///
+    /// This value is used internally to estimate some length-based tolerance. In particular, the
+    /// values [`IntegrationParameters::allowed_linear_error`],
+    /// [`IntegrationParameters::max_corrective_velocity`],
+    /// [`IntegrationParameters::prediction_distance`], [`RigidBodyActivation::normalized_linear_threshold`]
+    /// are scaled by this value implicitly.
+    ///
+    /// This value can be understood as the number of units-per-meter in your physical world compared
+    /// to a human-sized world in meter. For example, in a 2d game, if your typical object size is 100
+    /// pixels, set the [`Self::length_unit`] parameter to 100.0. The physics engine will interpret
+    /// it as if 100 pixels is equivalent to 1 meter in its various internal threshold.
+    /// (default `1.0`).
+    pub length_unit: Real,
+
+    /// Amount of penetration the engine won’t attempt to correct (default: `0.001m`).
+    ///
+    /// This value is implicitly scaled by [`IntegrationParameters::length_unit`].
+    pub normalized_allowed_linear_error: Real,
+    /// Maximum amount of penetration the solver will attempt to resolve in one timestep (default: `10.0`).
+    ///
+    /// This value is implicitly scaled by [`IntegrationParameters::length_unit`].
+    pub normalized_max_corrective_velocity: Real,
+    /// The maximal distance separating two objects that will generate predictive contacts (default: `0.002m`).
+    ///
+    /// This value is implicitly scaled by [`IntegrationParameters::length_unit`].
+    pub normalized_prediction_distance: Real,
+    /// Maximum linear velocity a body may have after each solver substep (default: `400.0` m/s).
+    ///
+    /// This value is implicitly scaled by [`IntegrationParameters::length_unit`].
+    pub normalized_max_linear_velocity: Real,
+    /// The number of solver iterations run by the constraints solver for calculating forces (default: `4`).
+    pub num_solver_iterations: usize,
+    /// Number of internal Project Gauss Seidel (PGS) iterations run at each solver iteration (default: `1`).
+    pub num_internal_pgs_iterations: usize,
+    /// The number of stabilization iterations run at each solver iterations (default: `1`).
+    pub num_internal_stabilization_iterations: usize,
+    /// Maximum number of substeps performed by the  solver (default: `1`).
+    pub max_ccd_substeps: usize,
+    /// If enabled, contact manifolds of a collider pair sharing (nearly) the same normal are
+    /// merged into one "cluster" manifold before constraint generation (default: `true`, 3D only).
+    pub contact_clustering: bool,
+    /// If enabled, a contact pair that barely moved since its last full narrow-phase update
+    /// skips contact determination and keeps its existing contact points (default: `true`).
+    pub contact_recycling: bool,
+    /// Maximum relative-pose drift below which a contact pair may be recycled instead of fully
+    /// updated (default: `0.05`). Only used when contact recycling is enabled.
+    ///
+    /// This value is implicitly scaled by [`IntegrationParameters::length_unit`].
+    pub normalized_contact_recycle_distance: Real,
+    /// If `false`, friction is only solved during the unbiased (relax) pass of each substep
+    /// instead of both passes (default: `false`).
+    pub friction_in_bias_pass: bool,
+    /// If enabled, impulse-joint constraints are warm-started like contacts (default: `false`).
+    pub warmstart_joints: bool,
+    /// Simulation settings shared by every soft body.
+    #[reflect(remote = SoftBodiesSettingsWrapper)]
+    pub soft_bodies: rapier::dynamics::SoftBodiesSettings,
+    /// Friction models used for all contact constraints between two rigid-bodies.
+    #[reflect(remote = FrictionModelWrapper)]
+    pub friction_model: FrictionModel,
+}
+
+#[cfg(feature = "dim2")]
+#[reflect_remote(rapier::dynamics::JointAxis)]
+#[derive(Copy, Clone, Debug, PartialEq)]
+/// Identifiers of degrees of freedoms of a joint.
+pub enum JointAxisWrapper {
+    /// The linear (translational) degree of freedom along the joint’s local X axis.
+    LinX = 0,
+    /// The linear (translational) degree of freedom along the joint’s local Y axis.
+    LinY,
+    /// The rotational degree of freedom of the joint.
+    AngX,
+}
+
+#[cfg(feature = "dim3")]
+#[reflect_remote(rapier::dynamics::JointAxis)]
+#[derive(Copy, Clone, Debug, PartialEq)]
+/// Identifiers of degrees of freedoms of a joint.
+pub enum JointAxisWrapper {
+    /// The linear (translational) degree of freedom along the joint’s local X axis.
+    LinX = 0,
+    /// The linear (translational) degree of freedom along the joint’s local Y axis.
+    LinY,
+    /// The linear (translational) degree of freedom along the joint’s local Z axis.
+    LinZ,
+    /// The rotational degree of freedom along the joint’s local X axis.
+    AngX,
+    /// The rotational degree of freedom along the joint’s local Y axis.
+    AngY,
+    /// The rotational degree of freedom along the joint’s local Z axis.
+    AngZ,
+}
+
+#[cfg(feature = "dim3")]
+#[reflect_remote(rapier::control::WheelTuning)]
+#[derive(Copy, Clone, Debug, PartialEq)]
+/// Parameters affecting the physical behavior of a wheel of a ray-cast vehicle.
+pub struct WheelTuningWrapper {
+    /// The suspension stiffness.
+    ///
+    /// Increase this value if the suspension appears to not push the vehicle strong enough.
+    pub suspension_stiffness: Real,
+    /// The suspension’s damping when it is being compressed.
+    pub suspension_compression: Real,
+    /// The suspension’s damping when it is being released.
+    ///
+    /// Increase this value if the suspension appears to overshoot.
+    pub suspension_damping: Real,
+    /// The maximum distance the suspension can travel before and after its resting length.
+    pub max_suspension_travel: Real,
+    /// The multiplier of friction between a tire and the collider it's on top of.
+    pub side_friction_stiffness: Real,
+    /// Parameter controlling how much traction the tire has.
+    ///
+    /// The larger the value, the more instantaneous braking will happen (with the risk of
+    /// causing the vehicle to flip if it’s too strong).
+    pub friction_slip: Real,
+    /// The maximum force applied by the suspension.
+    pub max_suspension_force: Real,
+}
+
+#[cfg(any(feature = "debug-render-3d", feature = "debug-render-2d"))]
+#[reflect_remote(rapier::pipeline::DebugRenderStyle)]
+#[derive(Copy, Clone, Debug, PartialEq)]
+/// Style used for computing colors when rendering the scene with the debug-renderer.
+///
+/// Colors are in HSLA format: `[hue 0..=360, saturation 0..=1, lightness 0..=1, alpha 0..=1]`.
+pub struct DebugRenderStyleWrapper {
+    /// The number of subdivisions used to approximate the curved parts of a shape with smooth
+    /// faces.
+    pub subdivisions: u32,
+    /// The number of subdivisions used to approximate the curved borders of round shapes.
+    pub border_subdivisions: u32,
+    /// The color of colliders attached to dynamic rigid-bodies.
+    pub collider_dynamic_color: [f32; 4],
+    /// The color of colliders attached to fixed rigid-bodies.
+    pub collider_fixed_color: [f32; 4],
+    /// The color of colliders attached to kinematic rigid-bodies.
+    pub collider_kinematic_color: [f32; 4],
+    /// The color of colliders not attached to any rigid-body.
+    pub collider_parentless_color: [f32; 4],
+    /// The color of the line between a rigid-body’s center-of-mass and the anchors of its
+    /// attached impulse joints.
+    pub impulse_joint_anchor_color: [f32; 4],
+    /// The color of the line between the two anchors of an impulse joint.
+    pub impulse_joint_separation_color: [f32; 4],
+    /// The color of the line between a rigid-body’s center-of-mass and the anchors of its
+    /// attached multibody joints.
+    pub multibody_joint_anchor_color: [f32; 4],
+    /// The color of the line between the two anchors of a multibody joint.
+    pub multibody_joint_separation_color: [f32; 4],
+    /// Color multiplier applied to the objects attached to sleeping rigid-bodies.
+    pub sleep_color_multiplier: [f32; 4],
+    /// Color multiplier applied to the objects attached to awake rigid-bodies eligible for sleep.
+    pub sleep_eligible_color_multiplier: [f32; 4],
+    /// Color multiplier applied to the objects attached to disabled rigid-bodies.
+    pub disabled_color_multiplier: [f32; 4],
+    /// The length of the local coordinate axes rendered for a rigid-body.
+    pub rigid_body_axes_length: Real,
+    /// The color for the segments joining the two contact points.
+    pub contact_depth_color: [f32; 4],
+    /// The color of the contact normals.
+    pub contact_normal_color: [f32; 4],
+    /// The length of the contact normals.
+    pub contact_normal_length: Real,
+    /// The color of the soft bodies' elements.
+    pub soft_body_element_color: [f32; 4],
+    /// The color of an unloaded soft-body element when coloring the elements by their load.
+    pub soft_body_slack_color: [f32; 4],
+    /// The color of a soft-body element at its tear threshold when coloring the elements by
+    /// their load.
+    pub soft_body_loaded_color: [f32; 4],
+    /// Color of the soft-body cluster frames.
+    pub soft_body_frame_color: [f32; 4],
+    /// The color of the colliders' AABBs.
+    pub collider_aabb_color: [f32; 4],
+    /// The color of the vertex pseudo-normals of triangle-meshes and polylines.
+    pub vertex_pseudo_normal_color: [f32; 4],
+    /// The color of the edge pseudo-normals of triangle-meshes (3D only).
+    pub edge_pseudo_normal_color: [f32; 4],
+    /// The length of the pseudo-normals.
+    pub pseudo_normal_length: Real,
+    /// Color of the soft bodies' volume constraints' normals.
+    pub volume_contact_normal_color: [f32; 4],
+    /// Color of the volume gradients drawn at the particles of a volume constraint.
+    pub volume_gradient_color: [f32; 4],
+}
diff --git a/bindings/bevy_rapier/src/render/mod.rs b/bindings/bevy_rapier/src/render/mod.rs
new file mode 100644
index 000000000..0c171e1bc
--- /dev/null
+++ b/bindings/bevy_rapier/src/render/mod.rs
@@ -0,0 +1,441 @@
+use crate::plugin::context::{
+    RapierContextColliders, RapierContextJoints, RapierContextSimulation, RapierRigidBodySet,
+};
+use bevy::prelude::*;
+use bevy::transform::TransformSystems;
+use rapier::math::Vector;
+use rapier::pipeline::{DebugRenderBackend, DebugRenderObject, DebugRenderPipeline};
+pub use rapier::pipeline::{DebugRenderMode, DebugRenderStyle};
+use std::fmt::Debug;
+
+#[cfg(doc)]
+use crate::prelude::{Collider, ImpulseJoint, MultibodyJoint, SoftBody};
+
+/// The color of a collider when using the debug-renderer.
+///
+/// Insert this component alongside the [`Collider`] component to
+/// force to a specific value the color used to render the
+/// collider and its AABB. It takes precedence over [`DebugRenderColor`] for these objects.
+#[derive(Copy, Clone, Component, PartialEq, Debug, Reflect)]
+pub struct ColliderDebugColor(pub Hsla);
+
+/// Overrides the global [`DebugRenderContext`] for a single collider.
+///
+/// This applies to the collider’s shape, its AABB, and the contact pairs it is involved in
+/// (which are hidden if either collider is [`ColliderDebug::NeverRender`]). It takes precedence
+/// over [`DebugRenderVisibility`] for these objects.
+#[derive(Copy, Clone, Reflect, Component, Eq, PartialEq, Default, Debug)]
+pub enum ColliderDebug {
+    /// Always render the debug gizmos for this collider, regardless of global config.
+    #[default]
+    AlwaysRender,
+    /// Never render the debug gizmos for this collider, regardless of global config.
+    NeverRender,
+}
+
+/// The color used by the debug-renderer for every object attached to this entity.
+///
+/// This applies to the entity’s collider and collider AABB (unless it has a
+/// [`ColliderDebugColor`]), to its rigid-body’s local axes, to its [`ImpulseJoint`] or
+/// [`MultibodyJoint`], and to the elements of its [`SoftBody`] (overriding the stress coloring of
+/// [`DebugRenderMode::SOFT_BODY_STRESS`]).
+#[derive(Copy, Clone, Component, PartialEq, Debug, Reflect)]
+pub struct DebugRenderColor(pub Hsla);
+
+/// Controls whether the debug-renderer draws the objects attached to this entity.
+///
+/// This applies to the entity’s collider shape (unless it has a [`ColliderDebug`], and
+/// regardless of [`DebugRenderContext::default_collider_debug`]), collider AABB, the contact
+/// pairs involving its collider, its rigid-body’s local axes, its [`ImpulseJoint`] or
+/// [`MultibodyJoint`], and the elements of its [`SoftBody`].
+#[derive(Copy, Clone, Reflect, Component, Eq, PartialEq, Default, Debug)]
+pub enum DebugRenderVisibility {
+    /// Render the objects attached to this entity (if enabled by the [`DebugRenderMode`]).
+    #[default]
+    Visible,
+    /// Never render the objects attached to this entity.
+    Hidden,
+}
+
+/// Reflectable mirror of [`DebugRenderMode`], with one boolean per flag.
+///
+/// Convert from and to [`DebugRenderMode`] with [`From`]/[`Into`].
+#[derive(Copy, Clone, Debug, PartialEq, Eq, Reflect)]
+pub struct DebugRenderModeFlags {
+    /// See [`DebugRenderMode::COLLIDER_SHAPES`].
+    pub collider_shapes: bool,
+    /// See [`DebugRenderMode::RIGID_BODY_AXES`].
+    pub rigid_body_axes: bool,
+    /// See [`DebugRenderMode::MULTIBODY_JOINTS`].
+    pub multibody_joints: bool,
+    /// See [`DebugRenderMode::IMPULSE_JOINTS`].
+    pub impulse_joints: bool,
+    /// See [`DebugRenderMode::SOLVER_CONTACTS`].
+    pub solver_contacts: bool,
+    /// See [`DebugRenderMode::CONTACTS`].
+    pub contacts: bool,
+    /// See [`DebugRenderMode::COLLIDER_AABBS`].
+    pub collider_aabbs: bool,
+    /// See [`DebugRenderMode::SOFT_BODIES`].
+    pub soft_bodies: bool,
+    /// See [`DebugRenderMode::PSEUDO_NORMALS`].
+    pub pseudo_normals: bool,
+    /// See [`DebugRenderMode::SOFT_VOLUME_CONTACTS`].
+    pub soft_volume_contacts: bool,
+    /// See [`DebugRenderMode::SOFT_BODY_STRESS`].
+    pub soft_body_stress: bool,
+}
+
+impl Default for DebugRenderModeFlags {
+    fn default() -> Self {
+        DebugRenderMode::default().into()
+    }
+}
+
+impl From<DebugRenderMode> for DebugRenderModeFlags {
+    fn from(mode: DebugRenderMode) -> Self {
+        Self {
+            collider_shapes: mode.contains(DebugRenderMode::COLLIDER_SHAPES),
+            rigid_body_axes: mode.contains(DebugRenderMode::RIGID_BODY_AXES),
+            multibody_joints: mode.contains(DebugRenderMode::MULTIBODY_JOINTS),
+            impulse_joints: mode.contains(DebugRenderMode::IMPULSE_JOINTS),
+            solver_contacts: mode.contains(DebugRenderMode::SOLVER_CONTACTS),
+            contacts: mode.contains(DebugRenderMode::CONTACTS),
+            collider_aabbs: mode.contains(DebugRenderMode::COLLIDER_AABBS),
+            soft_bodies: mode.contains(DebugRenderMode::SOFT_BODIES),
+            pseudo_normals: mode.contains(DebugRenderMode::PSEUDO_NORMALS),
+            soft_volume_contacts: mode.contains(DebugRenderMode::SOFT_VOLUME_CONTACTS),
+            soft_body_stress: mode.contains(DebugRenderMode::SOFT_BODY_STRESS),
+        }
+    }
+}
+
+impl From<DebugRenderModeFlags> for DebugRenderMode {
+    fn from(flags: DebugRenderModeFlags) -> Self {
+        let mut mode = DebugRenderMode::empty();
+        mode.set(DebugRenderMode::COLLIDER_SHAPES, flags.collider_shapes);
+        mode.set(DebugRenderMode::RIGID_BODY_AXES, flags.rigid_body_axes);
+        mode.set(DebugRenderMode::MULTIBODY_JOINTS, flags.multibody_joints);
+        mode.set(DebugRenderMode::IMPULSE_JOINTS, flags.impulse_joints);
+        mode.set(DebugRenderMode::SOLVER_CONTACTS, flags.solver_contacts);
+        mode.set(DebugRenderMode::CONTACTS, flags.contacts);
+        mode.set(DebugRenderMode::COLLIDER_AABBS, flags.collider_aabbs);
+        mode.set(DebugRenderMode::SOFT_BODIES, flags.soft_bodies);
+        mode.set(DebugRenderMode::PSEUDO_NORMALS, flags.pseudo_normals);
+        mode.set(
+            DebugRenderMode::SOFT_VOLUME_CONTACTS,
+            flags.soft_volume_contacts,
+        );
+        mode.set(DebugRenderMode::SOFT_BODY_STRESS, flags.soft_body_stress);
+        mode
+    }
+}
+
+/// Plugin rensponsible for rendering (using lines) what Rapier "sees" when performing
+/// its physics simulation. This is typically useful to check proper
+/// alignment between colliders and your own visual assets.
+pub struct RapierDebugRenderPlugin {
+    /// Whether to show debug gizmos for all colliders.
+    ///
+    /// Can be overridden for individual colliders by adding a [`ColliderDebug`] component.
+    pub default_collider_debug: ColliderDebug,
+    /// Is the debug-rendering enabled?
+    pub enabled: bool,
+    /// Control some aspects of the render coloring.
+    ///
+    /// Its lengths are expressed in meters: they are multiplied by the length unit of each
+    /// context (see [`DebugRenderContext::scale_lengths_by_length_unit`]).
+    pub style: DebugRenderStyle,
+    /// Flags to select what part of physics scene is rendered (by default
+    /// everything is rendered).
+    pub mode: DebugRenderMode,
+}
+
+impl Default for RapierDebugRenderPlugin {
+    fn default() -> Self {
+        Self {
+            enabled: true,
+            default_collider_debug: ColliderDebug::AlwaysRender,
+            style: DebugRenderStyle::default(),
+            mode: DebugRenderMode::default(),
+        }
+    }
+}
+
+impl RapierDebugRenderPlugin {
+    /// Initialize the render plugin such that it is initially disabled.
+    pub fn disabled(mut self) -> Self {
+        self.enabled = false;
+        self
+    }
+}
+
+/// Context to control some aspect of the debug-renderer after initialization.
+#[derive(Resource, Reflect)]
+#[reflect(Resource)]
+pub struct DebugRenderContext {
+    /// Is the debug-rendering currently enabled?
+    pub enabled: bool,
+    /// Whether to show debug gizmos for all colliders.
+    ///
+    /// Can be overridden for individual colliders by adding a [`ColliderDebug`] or
+    /// [`DebugRenderVisibility`] component.
+    pub default_collider_debug: ColliderDebug,
+    /// The style used to compute the colors and lengths of the rendered lines.
+    ///
+    /// Its lengths ([`DebugRenderStyle::rigid_body_axes_length`],
+    /// [`DebugRenderStyle::contact_normal_length`] and [`DebugRenderStyle::pseudo_normal_length`])
+    /// are multiplied by the length unit of each context if
+    /// [`Self::scale_lengths_by_length_unit`] is set.
+    #[reflect(remote = crate::reflect::DebugRenderStyleWrapper)]
+    pub style: DebugRenderStyle,
+    /// Flags selecting the parts of the physics scene that are rendered.
+    pub mode: DebugRenderModeFlags,
+    /// If `true` (the default), the lengths of [`Self::style`] are expressed in meters and
+    /// multiplied by the [`IntegrationParameters::length_unit`] (e.g. the pixels-per-meter in
+    /// 2D) of the rendered context.
+    ///
+    /// [`IntegrationParameters::length_unit`]: rapier::dynamics::IntegrationParameters::length_unit
+    pub scale_lengths_by_length_unit: bool,
+    /// Pipeline responsible for rendering.
+    ///
+    /// Its `style` and `mode` are synchronized with [`Self::style`] and [`Self::mode`] before
+    /// each render. Modifying `pipeline.style` or `pipeline.mode` directly is still supported:
+    /// such changes are copied back into [`Self::style`] and [`Self::mode`].
+    #[reflect(ignore)]
+    pub pipeline: DebugRenderPipeline,
+}
+
+impl Default for DebugRenderContext {
+    fn default() -> Self {
+        Self {
+            enabled: true,
+            default_collider_debug: ColliderDebug::AlwaysRender,
+            style: DebugRenderStyle::default(),
+            mode: DebugRenderModeFlags::default(),
+            scale_lengths_by_length_unit: true,
+            pipeline: DebugRenderPipeline::default(),
+        }
+    }
+}
+
+impl DebugRenderContext {
+    /// Copies the style and mode into the pipeline (or the other way round if the pipeline was
+    /// modified directly since the last synchronization).
+    fn sync_pipeline(&mut self, state: &mut DebugRenderSyncState) {
+        let mut mode = DebugRenderMode::from(self.mode);
+        match state.synced {
+            Some((style, prev_mode)) => {
+                if self.pipeline.style != style {
+                    self.style = self.pipeline.style;
+                }
+                if self.pipeline.mode != prev_mode {
+                    mode = self.pipeline.mode;
+                    self.mode = mode.into();
+                }
+            }
+            None => state.built_subdivisions = self.pipeline.style.subdivisions,
+        }
+
+        if self.style.subdivisions != state.built_subdivisions {
+            // The shape outlines depend on the subdivisions, so the pipeline must be rebuilt.
+            self.pipeline = DebugRenderPipeline::new(self.style, mode);
+            state.built_subdivisions = self.style.subdivisions;
+        } else {
+            self.pipeline.style = self.style;
+            self.pipeline.mode = mode;
+        }
+        state.synced = Some((self.style, mode));
+    }
+}
+
+/// The style and mode last copied into [`DebugRenderContext::pipeline`].
+#[derive(Resource, Default)]
+struct DebugRenderSyncState {
+    synced: Option<(DebugRenderStyle, DebugRenderMode)>,
+    built_subdivisions: u32,
+}
+
+/// Multiplies the length-like fields of `style` by `length_unit`.
+fn scale_style(mut style: DebugRenderStyle, length_unit: f32) -> DebugRenderStyle {
+    style.rigid_body_axes_length *= length_unit;
+    style.contact_normal_length *= length_unit;
+    style.pseudo_normal_length *= length_unit;
+    style
+}
+
+impl Plugin for RapierDebugRenderPlugin {
+    fn build(&self, app: &mut App) {
+        app.register_type::<DebugRenderContext>();
+        app.register_type::<ColliderDebug>();
+        app.register_type::<ColliderDebugColor>();
+        app.register_type::<DebugRenderColor>();
+        app.register_type::<DebugRenderVisibility>();
+        app.register_type::<DebugRenderModeFlags>();
+        app.register_type::<crate::reflect::DebugRenderStyleWrapper>();
+
+        app.init_resource::<DebugRenderSyncState>();
+        app.insert_resource(DebugRenderContext {
+            enabled: self.enabled,
+            default_collider_debug: self.default_collider_debug,
+            style: self.style,
+            mode: self.mode.into(),
+            scale_lengths_by_length_unit: true,
+            pipeline: DebugRenderPipeline::new(self.style, self.mode),
+        })
+        .add_systems(
+            PostUpdate,
+            debug_render_scene.after(TransformSystems::Propagate),
+        );
+    }
+}
+
+/// The per-entity debug-render overrides.
+type DebugOverrides = (
+    Option<&'static ColliderDebugColor>,
+    Option<&'static ColliderDebug>,
+    Option<&'static DebugRenderColor>,
+    Option<&'static DebugRenderVisibility>,
+);
+
+struct BevyLinesRenderBackend<'world, 'state, 'world2, 'state2, 'q, 'p> {
+    overrides: &'q Query<'world, 'state, DebugOverrides>,
+    default_collider_debug: ColliderDebug,
+    gizmos: &'p mut Gizmos<'world2, 'state2>,
+}
+
+impl<'world, 'state, 'world2, 'state2, 'q, 'p>
+    BevyLinesRenderBackend<'world, 'state, 'world2, 'state2, 'q, 'p>
+{
+    /// The entity whose components can override the rendering of `object`.
+    fn object_entity(object: &DebugRenderObject) -> Option<Entity> {
+        let user_data = match object {
+            DebugRenderObject::Collider(_, co) | DebugRenderObject::ColliderAabb(_, co, _) => {
+                co.user_data
+            }
+            DebugRenderObject::RigidBody(_, rb) => rb.user_data,
+            DebugRenderObject::ImpulseJoint(_, joint) => joint.data.user_data,
+            DebugRenderObject::MultibodyJoint(_, _, link) => link.joint().data.user_data,
+            DebugRenderObject::SoftBody(_, sb) => sb.user_data,
+            DebugRenderObject::ContactPair(..) => return None,
+        };
+        Entity::try_from_bits(user_data as u64)
+    }
+
+    /// The explicit visibility of the collider objects of `collider`, if any.
+    fn collider_visibility(&self, collider: &rapier::geometry::Collider) -> Option<bool> {
+        let entity = Entity::try_from_bits(collider.user_data as u64)?;
+        let (_, collider_debug, _, visibility) = self.overrides.get(entity).ok()?;
+        collider_debug
+            .map(|d| *d == ColliderDebug::AlwaysRender)
+            .or(visibility.map(|v| *v == DebugRenderVisibility::Visible))
+    }
+
+    fn object_color(&self, object: DebugRenderObject, default: [f32; 4]) -> [f32; 4] {
+        let Some(entity) = Self::object_entity(&object) else {
+            return default;
+        };
+        let Ok((collider_color, _, color, _)) = self.overrides.get(entity) else {
+            return default;
+        };
+        let color = match object {
+            DebugRenderObject::Collider(..) | DebugRenderObject::ColliderAabb(..) => {
+                collider_color.map(|c| c.0).or(color.map(|c| c.0))
+            }
+            _ => color.map(|c| c.0),
+        };
+
+        color.map(|co: Hsla| co.to_f32_array()).unwrap_or(default)
+    }
+}
+
+impl<'world, 'state, 'world2, 'state2, 'q, 'p> DebugRenderBackend
+    for BevyLinesRenderBackend<'world, 'state, 'world2, 'state2, 'q, 'p>
+{
+    fn filter_object(&self, object: DebugRenderObject) -> bool {
+        match object {
+            DebugRenderObject::Collider(_, co) => self
+                .collider_visibility(co)
+                .unwrap_or(self.default_collider_debug == ColliderDebug::AlwaysRender),
+            DebugRenderObject::ColliderAabb(_, co, _) => {
+                self.collider_visibility(co).unwrap_or(true)
+            }
+            DebugRenderObject::ContactPair(_, co1, co2) => {
+                self.collider_visibility(co1) != Some(false)
+                    && self.collider_visibility(co2) != Some(false)
+            }
+            DebugRenderObject::RigidBody(..)
+            | DebugRenderObject::ImpulseJoint(..)
+            | DebugRenderObject::MultibodyJoint(..)
+            | DebugRenderObject::SoftBody(..) => Self::object_entity(&object)
+                .and_then(|entity| self.overrides.get(entity).ok())
+                .and_then(|(_, _, _, visibility)| visibility)
+                .is_none_or(|v| *v == DebugRenderVisibility::Visible),
+        }
+    }
+
+    #[cfg(feature = "dim2")]
+    fn draw_line(&mut self, object: DebugRenderObject, a: Vector, b: Vector, color: [f32; 4]) {
+        let color = self.object_color(object, color);
+        self.gizmos.line(
+            [a.x, a.y, 0.0].into(),
+            [b.x, b.y, 0.0].into(),
+            Color::hsla(color[0], color[1], color[2], color[3]),
+        )
+    }
+
+    #[cfg(feature = "dim3")]
+    fn draw_line(&mut self, object: DebugRenderObject, a: Vector, b: Vector, color: [f32; 4]) {
+        let color = self.object_color(object, color);
+        self.gizmos.line(
+            [a.x, a.y, a.z].into(),
+            [b.x, b.y, b.z].into(),
+            Color::hsla(color[0], color[1], color[2], color[3]),
+        )
+    }
+}
+
+fn debug_render_scene(
+    rapier_context: Query<(
+        &RapierContextSimulation,
+        &RapierContextColliders,
+        &RapierContextJoints,
+        &RapierRigidBodySet,
+    )>,
+    mut render_context: ResMut<DebugRenderContext>,
+    mut sync_state: ResMut<DebugRenderSyncState>,
+    mut gizmos: Gizmos,
+    overrides: Query<DebugOverrides>,
+) {
+    if !render_context.enabled {
+        return;
+    }
+
+    let render_context = &mut *render_context;
+    render_context.sync_pipeline(&mut sync_state);
+
+    for (rapier_context, rapier_context_colliders, joints, rigidbody_set) in rapier_context.iter() {
+        let mut backend = BevyLinesRenderBackend {
+            overrides: &overrides,
+            default_collider_debug: render_context.default_collider_debug,
+            gizmos: &mut gizmos,
+        };
+
+        if render_context.scale_lengths_by_length_unit {
+            render_context.pipeline.style = scale_style(
+                render_context.style,
+                rapier_context.integration_parameters.length_unit,
+            );
+        }
+        render_context.pipeline.render(
+            &mut backend,
+            &rigidbody_set.bodies,
+            &rapier_context_colliders.colliders,
+            &joints.impulse_joints,
+            &joints.multibody_joints,
+            &rapier_context.narrow_phase,
+            &rigidbody_set.soft_bodies,
+        );
+        render_context.pipeline.style = render_context.style;
+    }
+}
diff --git a/bindings/bevy_rapier/src/utils/mod.rs b/bindings/bevy_rapier/src/utils/mod.rs
new file mode 100644
index 000000000..0efd2abb7
--- /dev/null
+++ b/bindings/bevy_rapier/src/utils/mod.rs
@@ -0,0 +1,70 @@
+use crate::math::{Rot, Vect};
+use bevy::prelude::Transform;
+use rapier::math::Pose;
+
+/// Builds a Rapier [`Pose`] from a translation/rotation pair using bevy_rapier's [`Vect`] / [`Rot`] aliases.
+#[cfg(feature = "dim2")]
+pub(crate) fn pose_from(translation: Vect, rotation: Rot) -> Pose {
+    Pose::new(translation, rotation)
+}
+
+/// Builds a Rapier [`Pose`] from a translation/rotation pair using bevy_rapier's [`Vect`] / [`Rot`] aliases.
+#[cfg(feature = "dim3")]
+pub(crate) fn pose_from(translation: Vect, rotation: Rot) -> Pose {
+    Pose::from_parts(translation, rotation)
+}
+
+/// Converts a Rapier pose to a Bevy transform.
+#[cfg(feature = "dim2")]
+pub fn iso_to_transform(iso: &Pose) -> Transform {
+    Transform {
+        translation: iso.translation.extend(0.0),
+        rotation: bevy::prelude::Quat::from_rotation_z(iso.rotation.angle()),
+        ..Default::default()
+    }
+}
+
+/// Converts a Rapier pose to a Bevy transform.
+#[cfg(feature = "dim3")]
+pub fn iso_to_transform(iso: &Pose) -> Transform {
+    Transform {
+        translation: iso.translation,
+        rotation: iso.rotation,
+        ..Default::default()
+    }
+}
+
+/// Converts a Bevy transform to a Rapier pose.
+#[cfg(feature = "dim2")]
+pub(crate) fn transform_to_iso(transform: &Transform) -> Pose {
+    use bevy::math::Vec3Swizzles;
+    Pose::new(
+        transform.translation.xy(),
+        transform.rotation.to_scaled_axis().z,
+    )
+}
+
+/// Converts a Bevy transform to a Rapier pose.
+#[cfg(feature = "dim3")]
+pub(crate) fn transform_to_iso(transform: &Transform) -> Pose {
+    Pose::from_parts(transform.translation, transform.rotation)
+}
+
+#[cfg(test)]
+#[cfg(feature = "dim3")]
+mod tests {
+    use super::*;
+    use bevy::prelude::Transform;
+
+    #[test]
+    fn convert_back_to_equal_transform() {
+        let transform = Transform {
+            translation: bevy::prelude::Vec3::new(-2.1855694e-8, 0.0, 0.0),
+            rotation: bevy::prelude::Quat::from_xyzw(0.99999994, 0.0, 1.6292068e-7, 0.0)
+                .normalize(),
+            ..Default::default()
+        };
+        let converted_transform = iso_to_transform(&transform_to_iso(&transform));
+        assert_eq!(converted_transform, transform);
+    }
+}
diff --git a/c/CMakeLists.txt b/bindings/c/CMakeLists.txt
similarity index 99%
rename from c/CMakeLists.txt
rename to bindings/c/CMakeLists.txt
index dcc26e74f..dfbef1cbf 100644
--- a/c/CMakeLists.txt
+++ b/bindings/c/CMakeLists.txt
@@ -69,7 +69,7 @@ if(NOT RAPIER_PROFILE MATCHES "^(release|debug)$")
   message(FATAL_ERROR "RAPIER_PROFILE must be release/debug")
 endif()
 find_program(CARGO_EXECUTABLE cargo REQUIRED)
-get_filename_component(RAPIER_ROOT "${CMAKE_CURRENT_SOURCE_DIR}/.." ABSOLUTE)
+get_filename_component(RAPIER_ROOT "${CMAKE_CURRENT_SOURCE_DIR}/../.." ABSOLUTE)
 set(RAPIER_CRATE "rapier${RAPIER_DIMENSION}d")
 if(RAPIER_PRECISION STREQUAL "64")
   string(APPEND RAPIER_CRATE "-f64")
diff --git a/c/README.md b/bindings/c/README.md
similarity index 92%
rename from c/README.md
rename to bindings/c/README.md
index 51368c363..39f62f7f6 100644
--- a/c/README.md
+++ b/bindings/c/README.md
@@ -9,7 +9,7 @@ the repository root.
 ## Build the library
 
 ```sh
-cmake -S c -B build/c -DCMAKE_BUILD_TYPE=Release
+cmake -S bindings/c -B build/c -DCMAKE_BUILD_TYPE=Release
 cmake --build build/c --config Release --parallel
 ```
 
@@ -59,7 +59,7 @@ layout of the linked library.
 ## Run the testbed
 
 ```sh
-cmake -S c -B build/c3 -DRAPIER_BUILD_TESTBED=ON -DRAPIER_DIMENSION=3 \
+cmake -S bindings/c -B build/c3 -DRAPIER_BUILD_TESTBED=ON -DRAPIER_DIMENSION=3 \
   -DRAPIER_PROFILE=release -DCMAKE_BUILD_TYPE=Release
 cmake --build build/c3 --target rapier_testbed --config Release --parallel
 ./build/c3/testbed/rapier_testbed
@@ -78,7 +78,7 @@ headless runs, and [dependencies](testbed/dependencies.md) for offline builds.
 Generate the searchable API reference and usage guides:
 
 ```sh
-cmake -S c/doxygen -B build/c-docs
+cmake -S bindings/c/doxygen -B build/c-docs
 cmake --build build/c-docs --target rapier_docs --parallel
 ```
 
@@ -100,9 +100,9 @@ ctest --test-dir build/c -C Release --output-on-failure
 ```
 
 The headers are checked in; users do not need to generate them. When changing the
-bindings or API comments in `c/src/`, regenerate the header with:
+bindings or API comments in `bindings/c/src/`, regenerate the header with:
 
 ```sh
 cargo install cbindgen --version 0.29.4 --locked
-python3 c/tools/generate-header.py
+python3 bindings/c/tools/generate-header.py
 ```
diff --git a/c/VERSION b/bindings/c/VERSION
similarity index 100%
rename from c/VERSION
rename to bindings/c/VERSION
diff --git a/c/build.rs b/bindings/c/build.rs
similarity index 100%
rename from c/build.rs
rename to bindings/c/build.rs
diff --git a/c/cbindgen.toml b/bindings/c/cbindgen.toml
similarity index 95%
rename from c/cbindgen.toml
rename to bindings/c/cbindgen.toml
index 06bc33169..92177372f 100644
--- a/c/cbindgen.toml
+++ b/bindings/c/cbindgen.toml
@@ -4,7 +4,7 @@ cpp_compat = true
 usize_is_size_t = true
 style = "both"
 documentation_style = "doxy"
-autogen_warning = "/* Generated by cbindgen. Regenerate with c/tools/generate-header.sh. */"
+autogen_warning = "/* Generated by cbindgen. Regenerate with bindings/c/tools/generate-header.sh. */"
 header = """
 /** @file
  * Rapier C ABI. Select dimension and precision before including this file.
diff --git a/c/cmake/RapierConfig.cmake.in b/bindings/c/cmake/RapierConfig.cmake.in
similarity index 100%
rename from c/cmake/RapierConfig.cmake.in
rename to bindings/c/cmake/RapierConfig.cmake.in
diff --git a/c/doxygen/CMakeLists.txt b/bindings/c/doxygen/CMakeLists.txt
similarity index 100%
rename from c/doxygen/CMakeLists.txt
rename to bindings/c/doxygen/CMakeLists.txt
diff --git a/c/doxygen/Doxyfile.in b/bindings/c/doxygen/Doxyfile.in
similarity index 100%
rename from c/doxygen/Doxyfile.in
rename to bindings/c/doxygen/Doxyfile.in
diff --git a/c/doxygen/check.py b/bindings/c/doxygen/check.py
similarity index 100%
rename from c/doxygen/check.py
rename to bindings/c/doxygen/check.py
diff --git a/c/doxygen/index.html.in b/bindings/c/doxygen/index.html.in
similarity index 100%
rename from c/doxygen/index.html.in
rename to bindings/c/doxygen/index.html.in
diff --git a/c/doxygen/reference.dox b/bindings/c/doxygen/reference.dox
similarity index 100%
rename from c/doxygen/reference.dox
rename to bindings/c/doxygen/reference.dox
diff --git a/c/examples/RapierNative.cs b/bindings/c/examples/RapierNative.cs
similarity index 100%
rename from c/examples/RapierNative.cs
rename to bindings/c/examples/RapierNative.cs
diff --git a/c/examples/compare_steps.rs b/bindings/c/examples/compare_steps.rs
similarity index 96%
rename from c/examples/compare_steps.rs
rename to bindings/c/examples/compare_steps.rs
index ed25fe160..2b6118fe8 100644
--- a/c/examples/compare_steps.rs
+++ b/bindings/c/examples/compare_steps.rs
@@ -1,5 +1,5 @@
 //! Replay trusted C-testbed snapshots with the native Rust API, in the same Cargo
-//! configuration. See c/testbed/tools/README.md. This is a manual benchmark.
+//! configuration. See bindings/c/testbed/tools/README.md. This is a manual benchmark.
 use bincode::Options;
 use rapier::prelude::*;
 use std::{path::Path, time::Instant};
diff --git a/c/examples/falling_ball.c b/bindings/c/examples/falling_ball.c
similarity index 100%
rename from c/examples/falling_ball.c
rename to bindings/c/examples/falling_ball.c
diff --git a/c/include/rapier.h b/bindings/c/include/rapier.h
similarity index 99%
rename from c/include/rapier.h
rename to bindings/c/include/rapier.h
index 22ed6d595..3b87798c1 100644
--- a/c/include/rapier.h
+++ b/bindings/c/include/rapier.h
@@ -54,7 +54,7 @@
 #ifndef RAPIER_H
 #define RAPIER_H
 
-/* Generated by cbindgen. Regenerate with c/tools/generate-header.sh. */
+/* Generated by cbindgen. Regenerate with bindings/c/tools/generate-header.sh. */
 
 #include <stdarg.h>
 #include <stdbool.h>
@@ -2483,7 +2483,7 @@ typedef struct R2ColliderDesc {
    */
   struct R2ShapeDesc shape;
   /**
-   * Pose relative to the parent body; world-space for an unparented collider.
+   * Pose relative to the parent body; world-space for a collider without a parent.
    */
   struct R2Pose position;
   /**
@@ -13385,7 +13385,7 @@ typedef struct R3ColliderDesc {
    */
   struct R3ShapeDesc shape;
   /**
-   * Pose relative to the parent body; world-space for an unparented collider.
+   * Pose relative to the parent body; world-space for a collider without a parent.
    */
   struct R3Pose position;
   /**
diff --git a/c/include/rapier.hpp b/bindings/c/include/rapier.hpp
similarity index 100%
rename from c/include/rapier.hpp
rename to bindings/c/include/rapier.hpp
diff --git a/c/include/rapier_helpers.h b/bindings/c/include/rapier_helpers.h
similarity index 100%
rename from c/include/rapier_helpers.h
rename to bindings/c/include/rapier_helpers.h
diff --git a/c/include/rapier_math.h b/bindings/c/include/rapier_math.h
similarity index 100%
rename from c/include/rapier_math.h
rename to bindings/c/include/rapier_math.h
diff --git a/c/rapier-c-macros/Cargo.toml b/bindings/c/rapier-c-macros/Cargo.toml
similarity index 100%
rename from c/rapier-c-macros/Cargo.toml
rename to bindings/c/rapier-c-macros/Cargo.toml
diff --git a/c/rapier-c-macros/src/lib.rs b/bindings/c/rapier-c-macros/src/lib.rs
similarity index 100%
rename from c/rapier-c-macros/src/lib.rs
rename to bindings/c/rapier-c-macros/src/lib.rs
diff --git a/c/rapier2d-f64-ffi/Cargo.toml b/bindings/c/rapier2d-f64-ffi/Cargo.toml
similarity index 85%
rename from c/rapier2d-f64-ffi/Cargo.toml
rename to bindings/c/rapier2d-f64-ffi/Cargo.toml
index cab6836d4..0e3b0ea57 100644
--- a/c/rapier2d-f64-ffi/Cargo.toml
+++ b/bindings/c/rapier2d-f64-ffi/Cargo.toml
@@ -24,7 +24,7 @@ fem = ["rapier/fem"]
 
 [dependencies]
 rapier-c-macros = { path = "../rapier-c-macros" }
-rapier = { package = "rapier2d-f64", path = "../../crates/rapier2d-f64", features = ["serde-serialize", "debug-render"] }
+rapier = { package = "rapier2d-f64", path = "../../../crates/rapier2d-f64", features = ["serde-serialize", "debug-render"] }
 bincode.workspace = true
 serde.workspace = true
 
diff --git a/c/rapier2d-ffi/Cargo.toml b/bindings/c/rapier2d-ffi/Cargo.toml
similarity index 87%
rename from c/rapier2d-ffi/Cargo.toml
rename to bindings/c/rapier2d-ffi/Cargo.toml
index 69fe0680e..09b5e7c76 100644
--- a/c/rapier2d-ffi/Cargo.toml
+++ b/bindings/c/rapier2d-ffi/Cargo.toml
@@ -25,7 +25,7 @@ fem = ["rapier/fem"]
 
 [dependencies]
 rapier-c-macros = { path = "../rapier-c-macros" }
-rapier = { package = "rapier2d", path = "../../crates/rapier2d", features = ["serde-serialize", "debug-render"] }
+rapier = { package = "rapier2d", path = "../../../crates/rapier2d", features = ["serde-serialize", "debug-render"] }
 bincode.workspace = true
 serde.workspace = true
 
diff --git a/c/rapier3d-f64-ffi/Cargo.toml b/bindings/c/rapier3d-f64-ffi/Cargo.toml
similarity index 85%
rename from c/rapier3d-f64-ffi/Cargo.toml
rename to bindings/c/rapier3d-f64-ffi/Cargo.toml
index 1c8f4c0b5..d3529ca87 100644
--- a/c/rapier3d-f64-ffi/Cargo.toml
+++ b/bindings/c/rapier3d-f64-ffi/Cargo.toml
@@ -24,7 +24,7 @@ fem = ["rapier/fem"]
 
 [dependencies]
 rapier-c-macros = { path = "../rapier-c-macros" }
-rapier = { package = "rapier3d-f64", path = "../../crates/rapier3d-f64", features = ["serde-serialize", "debug-render"] }
+rapier = { package = "rapier3d-f64", path = "../../../crates/rapier3d-f64", features = ["serde-serialize", "debug-render"] }
 bincode.workspace = true
 serde.workspace = true
 
diff --git a/c/rapier3d-ffi/Cargo.toml b/bindings/c/rapier3d-ffi/Cargo.toml
similarity index 91%
rename from c/rapier3d-ffi/Cargo.toml
rename to bindings/c/rapier3d-ffi/Cargo.toml
index 2f949acea..7b2f8a1ae 100644
--- a/c/rapier3d-ffi/Cargo.toml
+++ b/bindings/c/rapier3d-ffi/Cargo.toml
@@ -26,7 +26,7 @@ robotics = ["dep:rapier3d-urdf", "dep:rapier3d-mjcf", "dep:rapier3d-meshloader"]
 
 [dependencies]
 rapier-c-macros = { path = "../rapier-c-macros" }
-rapier = { package = "rapier3d", path = "../../crates/rapier3d", features = ["serde-serialize", "debug-render"] }
+rapier = { package = "rapier3d", path = "../../../crates/rapier3d", features = ["serde-serialize", "debug-render"] }
 rapier3d-urdf = { workspace = true, optional = true, features = ["stl", "collada", "wavefront"] }
 rapier3d-mjcf = { workspace = true, optional = true, features = ["stl", "wavefront", "msh"] }
 rapier3d-meshloader = { workspace = true, optional = true, features = ["stl", "collada", "wavefront"] }
diff --git a/c/src/array_views.rs b/bindings/c/src/array_views.rs
similarity index 100%
rename from c/src/array_views.rs
rename to bindings/c/src/array_views.rs
diff --git a/c/src/config_data.rs b/bindings/c/src/config_data.rs
similarity index 100%
rename from c/src/config_data.rs
rename to bindings/c/src/config_data.rs
diff --git a/c/src/control.rs b/bindings/c/src/control.rs
similarity index 100%
rename from c/src/control.rs
rename to bindings/c/src/control.rs
diff --git a/c/src/descriptors.rs b/bindings/c/src/descriptors.rs
similarity index 99%
rename from c/src/descriptors.rs
rename to bindings/c/src/descriptors.rs
index e043e830a..db5ee3fc3 100644
--- a/c/src/descriptors.rs
+++ b/bindings/c/src/descriptors.rs
@@ -501,7 +501,7 @@ pub const RPR_MASS_PROPERTIES: u32 = 2;
 pub struct RprColliderDesc {
     /// Non-owning shape description; build/insert consumes its views synchronously.
     pub shape: RprShapeDesc,
-    /// Pose relative to the parent body; world-space for an unparented collider.
+    /// Pose relative to the parent body; world-space for a collider without a parent.
     pub position: RprPose,
     /// RPR_MASS_DENSITY, RPR_MASS_TOTAL, or RPR_MASS_PROPERTIES.
     pub massMode: u32,
diff --git a/c/src/dynamics.rs b/bindings/c/src/dynamics.rs
similarity index 100%
rename from c/src/dynamics.rs
rename to bindings/c/src/dynamics.rs
diff --git a/c/src/error.rs b/bindings/c/src/error.rs
similarity index 100%
rename from c/src/error.rs
rename to bindings/c/src/error.rs
diff --git a/c/src/extra.rs b/bindings/c/src/extra.rs
similarity index 100%
rename from c/src/extra.rs
rename to bindings/c/src/extra.rs
diff --git a/c/src/geometry.rs b/bindings/c/src/geometry.rs
similarity index 100%
rename from c/src/geometry.rs
rename to bindings/c/src/geometry.rs
diff --git a/c/src/geometry_views.rs b/bindings/c/src/geometry_views.rs
similarity index 100%
rename from c/src/geometry_views.rs
rename to bindings/c/src/geometry_views.rs
diff --git a/c/src/handle_access.rs b/bindings/c/src/handle_access.rs
similarity index 100%
rename from c/src/handle_access.rs
rename to bindings/c/src/handle_access.rs
diff --git a/c/src/handle_world.rs b/bindings/c/src/handle_world.rs
similarity index 100%
rename from c/src/handle_world.rs
rename to bindings/c/src/handle_world.rs
diff --git a/c/src/joint_access.rs b/bindings/c/src/joint_access.rs
similarity index 100%
rename from c/src/joint_access.rs
rename to bindings/c/src/joint_access.rs
diff --git a/c/src/joint_desc.rs b/bindings/c/src/joint_desc.rs
similarity index 100%
rename from c/src/joint_desc.rs
rename to bindings/c/src/joint_desc.rs
diff --git a/c/src/joint_extras.rs b/bindings/c/src/joint_extras.rs
similarity index 100%
rename from c/src/joint_extras.rs
rename to bindings/c/src/joint_extras.rs
diff --git a/c/src/joints.rs b/bindings/c/src/joints.rs
similarity index 100%
rename from c/src/joints.rs
rename to bindings/c/src/joints.rs
diff --git a/c/src/lib.rs b/bindings/c/src/lib.rs
similarity index 95%
rename from c/src/lib.rs
rename to bindings/c/src/lib.rs
index 9d58a1991..d2cd0fb94 100644
--- a/c/src/lib.rs
+++ b/bindings/c/src/lib.rs
@@ -1,4 +1,4 @@
-//! C ABI shared by the four Rapier dimensions/precisions. See c/README.md.
+//! C ABI shared by the four Rapier dimensions/precisions. See bindings/c/README.md.
 #![deny(unsafe_op_in_unsafe_fn)]
 #![allow(clippy::missing_safety_doc, clippy::too_many_arguments)]
 use rapier::math::{AngVector, Pose, Real, Rotation, Vector};
diff --git a/c/src/objects.rs b/bindings/c/src/objects.rs
similarity index 100%
rename from c/src/objects.rs
rename to bindings/c/src/objects.rs
diff --git a/c/src/owner_handle_tests.rs b/bindings/c/src/owner_handle_tests.rs
similarity index 100%
rename from c/src/owner_handle_tests.rs
rename to bindings/c/src/owner_handle_tests.rs
diff --git a/c/src/pipeline.rs b/bindings/c/src/pipeline.rs
similarity index 100%
rename from c/src/pipeline.rs
rename to bindings/c/src/pipeline.rs
diff --git a/c/src/pod_tests.rs b/bindings/c/src/pod_tests.rs
similarity index 100%
rename from c/src/pod_tests.rs
rename to bindings/c/src/pod_tests.rs
diff --git a/c/src/queries.rs b/bindings/c/src/queries.rs
similarity index 100%
rename from c/src/queries.rs
rename to bindings/c/src/queries.rs
diff --git a/c/src/queries_extras.rs b/bindings/c/src/queries_extras.rs
similarity index 100%
rename from c/src/queries_extras.rs
rename to bindings/c/src/queries_extras.rs
diff --git a/c/src/read_access.rs b/bindings/c/src/read_access.rs
similarity index 100%
rename from c/src/read_access.rs
rename to bindings/c/src/read_access.rs
diff --git a/c/src/render.rs b/bindings/c/src/render.rs
similarity index 100%
rename from c/src/render.rs
rename to bindings/c/src/render.rs
diff --git a/c/src/return_values.rs b/bindings/c/src/return_values.rs
similarity index 100%
rename from c/src/return_values.rs
rename to bindings/c/src/return_values.rs
diff --git a/c/src/robotics.rs b/bindings/c/src/robotics.rs
similarity index 100%
rename from c/src/robotics.rs
rename to bindings/c/src/robotics.rs
diff --git a/c/src/scoped_access.rs b/bindings/c/src/scoped_access.rs
similarity index 100%
rename from c/src/scoped_access.rs
rename to bindings/c/src/scoped_access.rs
diff --git a/c/src/shape_desc.rs b/bindings/c/src/shape_desc.rs
similarity index 100%
rename from c/src/shape_desc.rs
rename to bindings/c/src/shape_desc.rs
diff --git a/c/src/soft_body.rs b/bindings/c/src/soft_body.rs
similarity index 100%
rename from c/src/soft_body.rs
rename to bindings/c/src/soft_body.rs
diff --git a/c/src/soft_desc.rs b/bindings/c/src/soft_desc.rs
similarity index 100%
rename from c/src/soft_desc.rs
rename to bindings/c/src/soft_desc.rs
diff --git a/c/src/soft_extras.rs b/bindings/c/src/soft_extras.rs
similarity index 100%
rename from c/src/soft_extras.rs
rename to bindings/c/src/soft_extras.rs
diff --git a/c/src/soft_extras_tests.rs b/bindings/c/src/soft_extras_tests.rs
similarity index 100%
rename from c/src/soft_extras_tests.rs
rename to bindings/c/src/soft_extras_tests.rs
diff --git a/c/src/soft_recipes.rs b/bindings/c/src/soft_recipes.rs
similarity index 100%
rename from c/src/soft_recipes.rs
rename to bindings/c/src/soft_recipes.rs
diff --git a/c/src/tests.rs b/bindings/c/src/tests.rs
similarity index 100%
rename from c/src/tests.rs
rename to bindings/c/src/tests.rs
diff --git a/c/src/types.rs b/bindings/c/src/types.rs
similarity index 100%
rename from c/src/types.rs
rename to bindings/c/src/types.rs
diff --git a/c/src/world.rs b/bindings/c/src/world.rs
similarity index 100%
rename from c/src/world.rs
rename to bindings/c/src/world.rs
diff --git a/c/src/world_extras.rs b/bindings/c/src/world_extras.rs
similarity index 100%
rename from c/src/world_extras.rs
rename to bindings/c/src/world_extras.rs
diff --git a/c/src/world_queries.rs b/bindings/c/src/world_queries.rs
similarity index 100%
rename from c/src/world_queries.rs
rename to bindings/c/src/world_queries.rs
diff --git a/c/src/world_tests.rs b/bindings/c/src/world_tests.rs
similarity index 100%
rename from c/src/world_tests.rs
rename to bindings/c/src/world_tests.rs
diff --git a/c/testbed/.clang-format b/bindings/c/testbed/.clang-format
similarity index 100%
rename from c/testbed/.clang-format
rename to bindings/c/testbed/.clang-format
diff --git a/c/testbed/CMakeLists.txt b/bindings/c/testbed/CMakeLists.txt
similarity index 100%
rename from c/testbed/CMakeLists.txt
rename to bindings/c/testbed/CMakeLists.txt
diff --git a/c/testbed/README.md b/bindings/c/testbed/README.md
similarity index 98%
rename from c/testbed/README.md
rename to bindings/c/testbed/README.md
index 554a5dabb..67ab9999f 100644
--- a/c/testbed/README.md
+++ b/bindings/c/testbed/README.md
@@ -10,7 +10,7 @@ packages needed to compile raylib's bundled GLFW. See [dependencies.md](dependen
 From the repository root:
 
 ```sh
-cmake -S c -B build/c3 -DRAPIER_BUILD_TESTBED=ON -DRAPIER_DIMENSION=3 \
+cmake -S bindings/c -B build/c3 -DRAPIER_BUILD_TESTBED=ON -DRAPIER_DIMENSION=3 \
   -DRAPIER_PROFILE=release -DCMAKE_BUILD_TYPE=Release
 cmake --build build/c3 --config Release --parallel
 build/c3/testbed/rapier_testbed --example restitution3
@@ -135,7 +135,7 @@ uses the Rust example's SVG tessellator, so there is no SVG dependency at runtim
 To regenerate it after editing the source logo:
 
 ```sh
-cargo run -p rapier-c-logo-mesh > c/testbed/examples2d/utils/logo_mesh.h
+cargo run -p rapier-c-logo-mesh > bindings/c/testbed/examples2d/utils/logo_mesh.h
 ```
 
 `testbed_interactions` drives the actual C example loops with synthetic input:
diff --git a/c/testbed/THIRD_PARTY_NOTICES.txt b/bindings/c/testbed/THIRD_PARTY_NOTICES.txt
similarity index 100%
rename from c/testbed/THIRD_PARTY_NOTICES.txt
rename to bindings/c/testbed/THIRD_PARTY_NOTICES.txt
diff --git a/c/testbed/cmake/Dependencies.cmake b/bindings/c/testbed/cmake/Dependencies.cmake
similarity index 100%
rename from c/testbed/cmake/Dependencies.cmake
rename to bindings/c/testbed/cmake/Dependencies.cmake
diff --git a/c/testbed/coverage.json b/bindings/c/testbed/coverage.json
similarity index 100%
rename from c/testbed/coverage.json
rename to bindings/c/testbed/coverage.json
diff --git a/c/testbed/dependencies.md b/bindings/c/testbed/dependencies.md
similarity index 100%
rename from c/testbed/dependencies.md
rename to bindings/c/testbed/dependencies.md
diff --git a/c/testbed/example_math.h b/bindings/c/testbed/example_math.h
similarity index 100%
rename from c/testbed/example_math.h
rename to bindings/c/testbed/example_math.h
diff --git a/c/testbed/examples2d/add_remove2.c b/bindings/c/testbed/examples2d/add_remove2.c
similarity index 100%
rename from c/testbed/examples2d/add_remove2.c
rename to bindings/c/testbed/examples2d/add_remove2.c
diff --git a/c/testbed/examples2d/b2d_compounds.c b/bindings/c/testbed/examples2d/b2d_compounds.c
similarity index 100%
rename from c/testbed/examples2d/b2d_compounds.c
rename to bindings/c/testbed/examples2d/b2d_compounds.c
diff --git a/c/testbed/examples2d/b2d_joint_grid.c b/bindings/c/testbed/examples2d/b2d_joint_grid.c
similarity index 100%
rename from c/testbed/examples2d/b2d_joint_grid.c
rename to bindings/c/testbed/examples2d/b2d_joint_grid.c
diff --git a/c/testbed/examples2d/b2d_junkyard.c b/bindings/c/testbed/examples2d/b2d_junkyard.c
similarity index 100%
rename from c/testbed/examples2d/b2d_junkyard.c
rename to bindings/c/testbed/examples2d/b2d_junkyard.c
diff --git a/c/testbed/examples2d/b2d_large_pyramid.c b/bindings/c/testbed/examples2d/b2d_large_pyramid.c
similarity index 100%
rename from c/testbed/examples2d/b2d_large_pyramid.c
rename to bindings/c/testbed/examples2d/b2d_large_pyramid.c
diff --git a/c/testbed/examples2d/b2d_many_pyramids.c b/bindings/c/testbed/examples2d/b2d_many_pyramids.c
similarity index 100%
rename from c/testbed/examples2d/b2d_many_pyramids.c
rename to bindings/c/testbed/examples2d/b2d_many_pyramids.c
diff --git a/c/testbed/examples2d/b2d_rain.c b/bindings/c/testbed/examples2d/b2d_rain.c
similarity index 100%
rename from c/testbed/examples2d/b2d_rain.c
rename to bindings/c/testbed/examples2d/b2d_rain.c
diff --git a/c/testbed/examples2d/b2d_smash.c b/bindings/c/testbed/examples2d/b2d_smash.c
similarity index 100%
rename from c/testbed/examples2d/b2d_smash.c
rename to bindings/c/testbed/examples2d/b2d_smash.c
diff --git a/c/testbed/examples2d/b2d_spinner.c b/bindings/c/testbed/examples2d/b2d_spinner.c
similarity index 100%
rename from c/testbed/examples2d/b2d_spinner.c
rename to bindings/c/testbed/examples2d/b2d_spinner.c
diff --git a/c/testbed/examples2d/b2d_tumbler.c b/bindings/c/testbed/examples2d/b2d_tumbler.c
similarity index 100%
rename from c/testbed/examples2d/b2d_tumbler.c
rename to bindings/c/testbed/examples2d/b2d_tumbler.c
diff --git a/c/testbed/examples2d/b2d_washer.c b/bindings/c/testbed/examples2d/b2d_washer.c
similarity index 100%
rename from c/testbed/examples2d/b2d_washer.c
rename to bindings/c/testbed/examples2d/b2d_washer.c
diff --git a/c/testbed/examples2d/ccd2.c b/bindings/c/testbed/examples2d/ccd2.c
similarity index 100%
rename from c/testbed/examples2d/ccd2.c
rename to bindings/c/testbed/examples2d/ccd2.c
diff --git a/c/testbed/examples2d/character_controller2.c b/bindings/c/testbed/examples2d/character_controller2.c
similarity index 100%
rename from c/testbed/examples2d/character_controller2.c
rename to bindings/c/testbed/examples2d/character_controller2.c
diff --git a/c/testbed/examples2d/collision_groups2.c b/bindings/c/testbed/examples2d/collision_groups2.c
similarity index 100%
rename from c/testbed/examples2d/collision_groups2.c
rename to bindings/c/testbed/examples2d/collision_groups2.c
diff --git a/c/testbed/examples2d/convex_polygons2.c b/bindings/c/testbed/examples2d/convex_polygons2.c
similarity index 100%
rename from c/testbed/examples2d/convex_polygons2.c
rename to bindings/c/testbed/examples2d/convex_polygons2.c
diff --git a/c/testbed/examples2d/damping2.c b/bindings/c/testbed/examples2d/damping2.c
similarity index 100%
rename from c/testbed/examples2d/damping2.c
rename to bindings/c/testbed/examples2d/damping2.c
diff --git a/c/testbed/examples2d/debug_angular_limits2.c b/bindings/c/testbed/examples2d/debug_angular_limits2.c
similarity index 100%
rename from c/testbed/examples2d/debug_angular_limits2.c
rename to bindings/c/testbed/examples2d/debug_angular_limits2.c
diff --git a/c/testbed/examples2d/debug_box_ball2.c b/bindings/c/testbed/examples2d/debug_box_ball2.c
similarity index 100%
rename from c/testbed/examples2d/debug_box_ball2.c
rename to bindings/c/testbed/examples2d/debug_box_ball2.c
diff --git a/c/testbed/examples2d/debug_compression2.c b/bindings/c/testbed/examples2d/debug_compression2.c
similarity index 100%
rename from c/testbed/examples2d/debug_compression2.c
rename to bindings/c/testbed/examples2d/debug_compression2.c
diff --git a/c/testbed/examples2d/debug_intersection2.c b/bindings/c/testbed/examples2d/debug_intersection2.c
similarity index 100%
rename from c/testbed/examples2d/debug_intersection2.c
rename to bindings/c/testbed/examples2d/debug_intersection2.c
diff --git a/c/testbed/examples2d/debug_many_colliders2.c b/bindings/c/testbed/examples2d/debug_many_colliders2.c
similarity index 100%
rename from c/testbed/examples2d/debug_many_colliders2.c
rename to bindings/c/testbed/examples2d/debug_many_colliders2.c
diff --git a/c/testbed/examples2d/debug_self_intersect2.c b/bindings/c/testbed/examples2d/debug_self_intersect2.c
similarity index 100%
rename from c/testbed/examples2d/debug_self_intersect2.c
rename to bindings/c/testbed/examples2d/debug_self_intersect2.c
diff --git a/c/testbed/examples2d/debug_total_overlap2.c b/bindings/c/testbed/examples2d/debug_total_overlap2.c
similarity index 100%
rename from c/testbed/examples2d/debug_total_overlap2.c
rename to bindings/c/testbed/examples2d/debug_total_overlap2.c
diff --git a/c/testbed/examples2d/debug_vertical_column2.c b/bindings/c/testbed/examples2d/debug_vertical_column2.c
similarity index 100%
rename from c/testbed/examples2d/debug_vertical_column2.c
rename to bindings/c/testbed/examples2d/debug_vertical_column2.c
diff --git a/c/testbed/examples2d/drum2.c b/bindings/c/testbed/examples2d/drum2.c
similarity index 100%
rename from c/testbed/examples2d/drum2.c
rename to bindings/c/testbed/examples2d/drum2.c
diff --git a/c/testbed/examples2d/heightfield2.c b/bindings/c/testbed/examples2d/heightfield2.c
similarity index 100%
rename from c/testbed/examples2d/heightfield2.c
rename to bindings/c/testbed/examples2d/heightfield2.c
diff --git a/c/testbed/examples2d/inv_pyramid2.c b/bindings/c/testbed/examples2d/inv_pyramid2.c
similarity index 100%
rename from c/testbed/examples2d/inv_pyramid2.c
rename to bindings/c/testbed/examples2d/inv_pyramid2.c
diff --git a/c/testbed/examples2d/inverse_kinematics2.c b/bindings/c/testbed/examples2d/inverse_kinematics2.c
similarity index 100%
rename from c/testbed/examples2d/inverse_kinematics2.c
rename to bindings/c/testbed/examples2d/inverse_kinematics2.c
diff --git a/c/testbed/examples2d/joint_motor_position2.c b/bindings/c/testbed/examples2d/joint_motor_position2.c
similarity index 100%
rename from c/testbed/examples2d/joint_motor_position2.c
rename to bindings/c/testbed/examples2d/joint_motor_position2.c
diff --git a/c/testbed/examples2d/joints2.c b/bindings/c/testbed/examples2d/joints2.c
similarity index 100%
rename from c/testbed/examples2d/joints2.c
rename to bindings/c/testbed/examples2d/joints2.c
diff --git a/c/testbed/examples2d/locked_rotations2.c b/bindings/c/testbed/examples2d/locked_rotations2.c
similarity index 100%
rename from c/testbed/examples2d/locked_rotations2.c
rename to bindings/c/testbed/examples2d/locked_rotations2.c
diff --git a/c/testbed/examples2d/multi_pendulum2.c b/bindings/c/testbed/examples2d/multi_pendulum2.c
similarity index 100%
rename from c/testbed/examples2d/multi_pendulum2.c
rename to bindings/c/testbed/examples2d/multi_pendulum2.c
diff --git a/c/testbed/examples2d/one_way_platforms2.c b/bindings/c/testbed/examples2d/one_way_platforms2.c
similarity index 100%
rename from c/testbed/examples2d/one_way_platforms2.c
rename to bindings/c/testbed/examples2d/one_way_platforms2.c
diff --git a/c/testbed/examples2d/pin_slot_joint2.c b/bindings/c/testbed/examples2d/pin_slot_joint2.c
similarity index 100%
rename from c/testbed/examples2d/pin_slot_joint2.c
rename to bindings/c/testbed/examples2d/pin_slot_joint2.c
diff --git a/c/testbed/examples2d/platform2.c b/bindings/c/testbed/examples2d/platform2.c
similarity index 100%
rename from c/testbed/examples2d/platform2.c
rename to bindings/c/testbed/examples2d/platform2.c
diff --git a/c/testbed/examples2d/polyline2.c b/bindings/c/testbed/examples2d/polyline2.c
similarity index 100%
rename from c/testbed/examples2d/polyline2.c
rename to bindings/c/testbed/examples2d/polyline2.c
diff --git a/c/testbed/examples2d/pyramid2.c b/bindings/c/testbed/examples2d/pyramid2.c
similarity index 100%
rename from c/testbed/examples2d/pyramid2.c
rename to bindings/c/testbed/examples2d/pyramid2.c
diff --git a/c/testbed/examples2d/restitution2.c b/bindings/c/testbed/examples2d/restitution2.c
similarity index 100%
rename from c/testbed/examples2d/restitution2.c
rename to bindings/c/testbed/examples2d/restitution2.c
diff --git a/c/testbed/examples2d/rope_joints2.c b/bindings/c/testbed/examples2d/rope_joints2.c
similarity index 100%
rename from c/testbed/examples2d/rope_joints2.c
rename to bindings/c/testbed/examples2d/rope_joints2.c
diff --git a/c/testbed/examples2d/s2d_arch.c b/bindings/c/testbed/examples2d/s2d_arch.c
similarity index 100%
rename from c/testbed/examples2d/s2d_arch.c
rename to bindings/c/testbed/examples2d/s2d_arch.c
diff --git a/c/testbed/examples2d/s2d_ball_and_chain.c b/bindings/c/testbed/examples2d/s2d_ball_and_chain.c
similarity index 100%
rename from c/testbed/examples2d/s2d_ball_and_chain.c
rename to bindings/c/testbed/examples2d/s2d_ball_and_chain.c
diff --git a/c/testbed/examples2d/s2d_bridge.c b/bindings/c/testbed/examples2d/s2d_bridge.c
similarity index 100%
rename from c/testbed/examples2d/s2d_bridge.c
rename to bindings/c/testbed/examples2d/s2d_bridge.c
diff --git a/c/testbed/examples2d/s2d_card_house.c b/bindings/c/testbed/examples2d/s2d_card_house.c
similarity index 100%
rename from c/testbed/examples2d/s2d_card_house.c
rename to bindings/c/testbed/examples2d/s2d_card_house.c
diff --git a/c/testbed/examples2d/s2d_confined.c b/bindings/c/testbed/examples2d/s2d_confined.c
similarity index 100%
rename from c/testbed/examples2d/s2d_confined.c
rename to bindings/c/testbed/examples2d/s2d_confined.c
diff --git a/c/testbed/examples2d/s2d_far_pyramid.c b/bindings/c/testbed/examples2d/s2d_far_pyramid.c
similarity index 100%
rename from c/testbed/examples2d/s2d_far_pyramid.c
rename to bindings/c/testbed/examples2d/s2d_far_pyramid.c
diff --git a/c/testbed/examples2d/s2d_high_mass_ratio_1.c b/bindings/c/testbed/examples2d/s2d_high_mass_ratio_1.c
similarity index 100%
rename from c/testbed/examples2d/s2d_high_mass_ratio_1.c
rename to bindings/c/testbed/examples2d/s2d_high_mass_ratio_1.c
diff --git a/c/testbed/examples2d/s2d_high_mass_ratio_2.c b/bindings/c/testbed/examples2d/s2d_high_mass_ratio_2.c
similarity index 100%
rename from c/testbed/examples2d/s2d_high_mass_ratio_2.c
rename to bindings/c/testbed/examples2d/s2d_high_mass_ratio_2.c
diff --git a/c/testbed/examples2d/s2d_high_mass_ratio_3.c b/bindings/c/testbed/examples2d/s2d_high_mass_ratio_3.c
similarity index 100%
rename from c/testbed/examples2d/s2d_high_mass_ratio_3.c
rename to bindings/c/testbed/examples2d/s2d_high_mass_ratio_3.c
diff --git a/c/testbed/examples2d/s2d_joint_grid.c b/bindings/c/testbed/examples2d/s2d_joint_grid.c
similarity index 100%
rename from c/testbed/examples2d/s2d_joint_grid.c
rename to bindings/c/testbed/examples2d/s2d_joint_grid.c
diff --git a/c/testbed/examples2d/s2d_pyramid.c b/bindings/c/testbed/examples2d/s2d_pyramid.c
similarity index 100%
rename from c/testbed/examples2d/s2d_pyramid.c
rename to bindings/c/testbed/examples2d/s2d_pyramid.c
diff --git a/c/testbed/examples2d/sensor2.c b/bindings/c/testbed/examples2d/sensor2.c
similarity index 100%
rename from c/testbed/examples2d/sensor2.c
rename to bindings/c/testbed/examples2d/sensor2.c
diff --git a/c/testbed/examples2d/soft_blobs2.c b/bindings/c/testbed/examples2d/soft_blobs2.c
similarity index 100%
rename from c/testbed/examples2d/soft_blobs2.c
rename to bindings/c/testbed/examples2d/soft_blobs2.c
diff --git a/c/testbed/examples2d/soft_bodies2.c b/bindings/c/testbed/examples2d/soft_bodies2.c
similarity index 100%
rename from c/testbed/examples2d/soft_bodies2.c
rename to bindings/c/testbed/examples2d/soft_bodies2.c
diff --git a/c/testbed/examples2d/soft_cutting2.c b/bindings/c/testbed/examples2d/soft_cutting2.c
similarity index 100%
rename from c/testbed/examples2d/soft_cutting2.c
rename to bindings/c/testbed/examples2d/soft_cutting2.c
diff --git a/c/testbed/examples2d/soft_fem2.c b/bindings/c/testbed/examples2d/soft_fem2.c
similarity index 100%
rename from c/testbed/examples2d/soft_fem2.c
rename to bindings/c/testbed/examples2d/soft_fem2.c
diff --git a/c/testbed/examples2d/soft_force_tearing2.c b/bindings/c/testbed/examples2d/soft_force_tearing2.c
similarity index 100%
rename from c/testbed/examples2d/soft_force_tearing2.c
rename to bindings/c/testbed/examples2d/soft_force_tearing2.c
diff --git a/c/testbed/examples2d/soft_jelly2.c b/bindings/c/testbed/examples2d/soft_jelly2.c
similarity index 100%
rename from c/testbed/examples2d/soft_jelly2.c
rename to bindings/c/testbed/examples2d/soft_jelly2.c
diff --git a/c/testbed/examples2d/soft_joints2.c b/bindings/c/testbed/examples2d/soft_joints2.c
similarity index 100%
rename from c/testbed/examples2d/soft_joints2.c
rename to bindings/c/testbed/examples2d/soft_joints2.c
diff --git a/c/testbed/examples2d/soft_letters2.c b/bindings/c/testbed/examples2d/soft_letters2.c
similarity index 100%
rename from c/testbed/examples2d/soft_letters2.c
rename to bindings/c/testbed/examples2d/soft_letters2.c
diff --git a/c/testbed/examples2d/soft_pile2.c b/bindings/c/testbed/examples2d/soft_pile2.c
similarity index 100%
rename from c/testbed/examples2d/soft_pile2.c
rename to bindings/c/testbed/examples2d/soft_pile2.c
diff --git a/c/testbed/examples2d/soft_plasticity2.c b/bindings/c/testbed/examples2d/soft_plasticity2.c
similarity index 100%
rename from c/testbed/examples2d/soft_plasticity2.c
rename to bindings/c/testbed/examples2d/soft_plasticity2.c
diff --git a/c/testbed/examples2d/soft_stress2.c b/bindings/c/testbed/examples2d/soft_stress2.c
similarity index 100%
rename from c/testbed/examples2d/soft_stress2.c
rename to bindings/c/testbed/examples2d/soft_stress2.c
diff --git a/c/testbed/examples2d/soft_surface2.c b/bindings/c/testbed/examples2d/soft_surface2.c
similarity index 100%
rename from c/testbed/examples2d/soft_surface2.c
rename to bindings/c/testbed/examples2d/soft_surface2.c
diff --git a/c/testbed/examples2d/soft_tearing2.c b/bindings/c/testbed/examples2d/soft_tearing2.c
similarity index 100%
rename from c/testbed/examples2d/soft_tearing2.c
rename to bindings/c/testbed/examples2d/soft_tearing2.c
diff --git a/c/testbed/examples2d/soft_thin_features2.c b/bindings/c/testbed/examples2d/soft_thin_features2.c
similarity index 100%
rename from c/testbed/examples2d/soft_thin_features2.c
rename to bindings/c/testbed/examples2d/soft_thin_features2.c
diff --git a/c/testbed/examples2d/stress_tests/balls2.c b/bindings/c/testbed/examples2d/stress_tests/balls2.c
similarity index 100%
rename from c/testbed/examples2d/stress_tests/balls2.c
rename to bindings/c/testbed/examples2d/stress_tests/balls2.c
diff --git a/c/testbed/examples2d/stress_tests/boxes2.c b/bindings/c/testbed/examples2d/stress_tests/boxes2.c
similarity index 100%
rename from c/testbed/examples2d/stress_tests/boxes2.c
rename to bindings/c/testbed/examples2d/stress_tests/boxes2.c
diff --git a/c/testbed/examples2d/stress_tests/capsules2.c b/bindings/c/testbed/examples2d/stress_tests/capsules2.c
similarity index 100%
rename from c/testbed/examples2d/stress_tests/capsules2.c
rename to bindings/c/testbed/examples2d/stress_tests/capsules2.c
diff --git a/c/testbed/examples2d/stress_tests/convex_polygons2.c b/bindings/c/testbed/examples2d/stress_tests/convex_polygons2.c
similarity index 100%
rename from c/testbed/examples2d/stress_tests/convex_polygons2.c
rename to bindings/c/testbed/examples2d/stress_tests/convex_polygons2.c
diff --git a/c/testbed/examples2d/stress_tests/heightfield2.c b/bindings/c/testbed/examples2d/stress_tests/heightfield2.c
similarity index 100%
rename from c/testbed/examples2d/stress_tests/heightfield2.c
rename to bindings/c/testbed/examples2d/stress_tests/heightfield2.c
diff --git a/c/testbed/examples2d/stress_tests/joint_ball2.c b/bindings/c/testbed/examples2d/stress_tests/joint_ball2.c
similarity index 100%
rename from c/testbed/examples2d/stress_tests/joint_ball2.c
rename to bindings/c/testbed/examples2d/stress_tests/joint_ball2.c
diff --git a/c/testbed/examples2d/stress_tests/joint_fixed2.c b/bindings/c/testbed/examples2d/stress_tests/joint_fixed2.c
similarity index 100%
rename from c/testbed/examples2d/stress_tests/joint_fixed2.c
rename to bindings/c/testbed/examples2d/stress_tests/joint_fixed2.c
diff --git a/c/testbed/examples2d/stress_tests/joint_prismatic2.c b/bindings/c/testbed/examples2d/stress_tests/joint_prismatic2.c
similarity index 100%
rename from c/testbed/examples2d/stress_tests/joint_prismatic2.c
rename to bindings/c/testbed/examples2d/stress_tests/joint_prismatic2.c
diff --git a/c/testbed/examples2d/stress_tests/large_pyramids2.c b/bindings/c/testbed/examples2d/stress_tests/large_pyramids2.c
similarity index 100%
rename from c/testbed/examples2d/stress_tests/large_pyramids2.c
rename to bindings/c/testbed/examples2d/stress_tests/large_pyramids2.c
diff --git a/c/testbed/examples2d/stress_tests/many_pyramids2.c b/bindings/c/testbed/examples2d/stress_tests/many_pyramids2.c
similarity index 100%
rename from c/testbed/examples2d/stress_tests/many_pyramids2.c
rename to bindings/c/testbed/examples2d/stress_tests/many_pyramids2.c
diff --git a/c/testbed/examples2d/stress_tests/pyramid2.c b/bindings/c/testbed/examples2d/stress_tests/pyramid2.c
similarity index 100%
rename from c/testbed/examples2d/stress_tests/pyramid2.c
rename to bindings/c/testbed/examples2d/stress_tests/pyramid2.c
diff --git a/c/testbed/examples2d/stress_tests/ragdolls2.c b/bindings/c/testbed/examples2d/stress_tests/ragdolls2.c
similarity index 100%
rename from c/testbed/examples2d/stress_tests/ragdolls2.c
rename to bindings/c/testbed/examples2d/stress_tests/ragdolls2.c
diff --git a/c/testbed/examples2d/stress_tests/ropes2.c b/bindings/c/testbed/examples2d/stress_tests/ropes2.c
similarity index 100%
rename from c/testbed/examples2d/stress_tests/ropes2.c
rename to bindings/c/testbed/examples2d/stress_tests/ropes2.c
diff --git a/c/testbed/examples2d/stress_tests/soft_blobs2.c b/bindings/c/testbed/examples2d/stress_tests/soft_blobs2.c
similarity index 100%
rename from c/testbed/examples2d/stress_tests/soft_blobs2.c
rename to bindings/c/testbed/examples2d/stress_tests/soft_blobs2.c
diff --git a/c/testbed/examples2d/stress_tests/soft_cloth_keva2.c b/bindings/c/testbed/examples2d/stress_tests/soft_cloth_keva2.c
similarity index 100%
rename from c/testbed/examples2d/stress_tests/soft_cloth_keva2.c
rename to bindings/c/testbed/examples2d/stress_tests/soft_cloth_keva2.c
diff --git a/c/testbed/examples2d/stress_tests/soft_fem_beams2.c b/bindings/c/testbed/examples2d/stress_tests/soft_fem_beams2.c
similarity index 100%
rename from c/testbed/examples2d/stress_tests/soft_fem_beams2.c
rename to bindings/c/testbed/examples2d/stress_tests/soft_fem_beams2.c
diff --git a/c/testbed/examples2d/stress_tests/soft_jellies2.c b/bindings/c/testbed/examples2d/stress_tests/soft_jellies2.c
similarity index 100%
rename from c/testbed/examples2d/stress_tests/soft_jellies2.c
rename to bindings/c/testbed/examples2d/stress_tests/soft_jellies2.c
diff --git a/c/testbed/examples2d/stress_tests/soft_ropes2.c b/bindings/c/testbed/examples2d/stress_tests/soft_ropes2.c
similarity index 100%
rename from c/testbed/examples2d/stress_tests/soft_ropes2.c
rename to bindings/c/testbed/examples2d/stress_tests/soft_ropes2.c
diff --git a/c/testbed/examples2d/stress_tests/soft_slab2.c b/bindings/c/testbed/examples2d/stress_tests/soft_slab2.c
similarity index 100%
rename from c/testbed/examples2d/stress_tests/soft_slab2.c
rename to bindings/c/testbed/examples2d/stress_tests/soft_slab2.c
diff --git a/c/testbed/examples2d/stress_tests/soft_strips2.c b/bindings/c/testbed/examples2d/stress_tests/soft_strips2.c
similarity index 100%
rename from c/testbed/examples2d/stress_tests/soft_strips2.c
rename to bindings/c/testbed/examples2d/stress_tests/soft_strips2.c
diff --git a/c/testbed/examples2d/stress_tests/vertical_stacks2.c b/bindings/c/testbed/examples2d/stress_tests/vertical_stacks2.c
similarity index 100%
rename from c/testbed/examples2d/stress_tests/vertical_stacks2.c
rename to bindings/c/testbed/examples2d/stress_tests/vertical_stacks2.c
diff --git a/c/testbed/examples2d/trimesh2.c b/bindings/c/testbed/examples2d/trimesh2.c
similarity index 100%
rename from c/testbed/examples2d/trimesh2.c
rename to bindings/c/testbed/examples2d/trimesh2.c
diff --git a/c/testbed/examples2d/utils/character.h b/bindings/c/testbed/examples2d/utils/character.h
similarity index 100%
rename from c/testbed/examples2d/utils/character.h
rename to bindings/c/testbed/examples2d/utils/character.h
diff --git a/c/testbed/examples2d/utils/logo_mesh.h b/bindings/c/testbed/examples2d/utils/logo_mesh.h
similarity index 100%
rename from c/testbed/examples2d/utils/logo_mesh.h
rename to bindings/c/testbed/examples2d/utils/logo_mesh.h
diff --git a/c/testbed/examples2d/voxels2.c b/bindings/c/testbed/examples2d/voxels2.c
similarity index 100%
rename from c/testbed/examples2d/voxels2.c
rename to bindings/c/testbed/examples2d/voxels2.c
diff --git a/c/testbed/examples3d/b3d_joint_grid.c b/bindings/c/testbed/examples3d/b3d_joint_grid.c
similarity index 100%
rename from c/testbed/examples3d/b3d_joint_grid.c
rename to bindings/c/testbed/examples3d/b3d_joint_grid.c
diff --git a/c/testbed/examples3d/b3d_junkyard.c b/bindings/c/testbed/examples3d/b3d_junkyard.c
similarity index 100%
rename from c/testbed/examples3d/b3d_junkyard.c
rename to bindings/c/testbed/examples3d/b3d_junkyard.c
diff --git a/c/testbed/examples3d/b3d_large_pyramid.c b/bindings/c/testbed/examples3d/b3d_large_pyramid.c
similarity index 100%
rename from c/testbed/examples3d/b3d_large_pyramid.c
rename to bindings/c/testbed/examples3d/b3d_large_pyramid.c
diff --git a/c/testbed/examples3d/b3d_large_world.c b/bindings/c/testbed/examples3d/b3d_large_world.c
similarity index 100%
rename from c/testbed/examples3d/b3d_large_world.c
rename to bindings/c/testbed/examples3d/b3d_large_world.c
diff --git a/c/testbed/examples3d/b3d_many_pyramids.c b/bindings/c/testbed/examples3d/b3d_many_pyramids.c
similarity index 100%
rename from c/testbed/examples3d/b3d_many_pyramids.c
rename to bindings/c/testbed/examples3d/b3d_many_pyramids.c
diff --git a/c/testbed/examples3d/b3d_rain.c b/bindings/c/testbed/examples3d/b3d_rain.c
similarity index 100%
rename from c/testbed/examples3d/b3d_rain.c
rename to bindings/c/testbed/examples3d/b3d_rain.c
diff --git a/c/testbed/examples3d/b3d_trees.c b/bindings/c/testbed/examples3d/b3d_trees.c
similarity index 100%
rename from c/testbed/examples3d/b3d_trees.c
rename to bindings/c/testbed/examples3d/b3d_trees.c
diff --git a/c/testbed/examples3d/b3d_trees_run100.c b/bindings/c/testbed/examples3d/b3d_trees_run100.c
similarity index 100%
rename from c/testbed/examples3d/b3d_trees_run100.c
rename to bindings/c/testbed/examples3d/b3d_trees_run100.c
diff --git a/c/testbed/examples3d/b3d_trees_run25.c b/bindings/c/testbed/examples3d/b3d_trees_run25.c
similarity index 100%
rename from c/testbed/examples3d/b3d_trees_run25.c
rename to bindings/c/testbed/examples3d/b3d_trees_run25.c
diff --git a/c/testbed/examples3d/b3d_trees_run50.c b/bindings/c/testbed/examples3d/b3d_trees_run50.c
similarity index 100%
rename from c/testbed/examples3d/b3d_trees_run50.c
rename to bindings/c/testbed/examples3d/b3d_trees_run50.c
diff --git a/c/testbed/examples3d/b3d_washer.c b/bindings/c/testbed/examples3d/b3d_washer.c
similarity index 100%
rename from c/testbed/examples3d/b3d_washer.c
rename to bindings/c/testbed/examples3d/b3d_washer.c
diff --git a/c/testbed/examples3d/ccd3.c b/bindings/c/testbed/examples3d/ccd3.c
similarity index 100%
rename from c/testbed/examples3d/ccd3.c
rename to bindings/c/testbed/examples3d/ccd3.c
diff --git a/c/testbed/examples3d/character_controller3.c b/bindings/c/testbed/examples3d/character_controller3.c
similarity index 100%
rename from c/testbed/examples3d/character_controller3.c
rename to bindings/c/testbed/examples3d/character_controller3.c
diff --git a/c/testbed/examples3d/collision_groups3.c b/bindings/c/testbed/examples3d/collision_groups3.c
similarity index 100%
rename from c/testbed/examples3d/collision_groups3.c
rename to bindings/c/testbed/examples3d/collision_groups3.c
diff --git a/c/testbed/examples3d/compound3.c b/bindings/c/testbed/examples3d/compound3.c
similarity index 100%
rename from c/testbed/examples3d/compound3.c
rename to bindings/c/testbed/examples3d/compound3.c
diff --git a/c/testbed/examples3d/convex_decomposition3.c b/bindings/c/testbed/examples3d/convex_decomposition3.c
similarity index 100%
rename from c/testbed/examples3d/convex_decomposition3.c
rename to bindings/c/testbed/examples3d/convex_decomposition3.c
diff --git a/c/testbed/examples3d/convex_polyhedron3.c b/bindings/c/testbed/examples3d/convex_polyhedron3.c
similarity index 100%
rename from c/testbed/examples3d/convex_polyhedron3.c
rename to bindings/c/testbed/examples3d/convex_polyhedron3.c
diff --git a/c/testbed/examples3d/damping3.c b/bindings/c/testbed/examples3d/damping3.c
similarity index 100%
rename from c/testbed/examples3d/damping3.c
rename to bindings/c/testbed/examples3d/damping3.c
diff --git a/c/testbed/examples3d/debug_add_remove_collider3.c b/bindings/c/testbed/examples3d/debug_add_remove_collider3.c
similarity index 100%
rename from c/testbed/examples3d/debug_add_remove_collider3.c
rename to bindings/c/testbed/examples3d/debug_add_remove_collider3.c
diff --git a/c/testbed/examples3d/debug_angular_limits3.c b/bindings/c/testbed/examples3d/debug_angular_limits3.c
similarity index 100%
rename from c/testbed/examples3d/debug_angular_limits3.c
rename to bindings/c/testbed/examples3d/debug_angular_limits3.c
diff --git a/c/testbed/examples3d/debug_articulations3.c b/bindings/c/testbed/examples3d/debug_articulations3.c
similarity index 100%
rename from c/testbed/examples3d/debug_articulations3.c
rename to bindings/c/testbed/examples3d/debug_articulations3.c
diff --git a/c/testbed/examples3d/debug_balls3.c b/bindings/c/testbed/examples3d/debug_balls3.c
similarity index 100%
rename from c/testbed/examples3d/debug_balls3.c
rename to bindings/c/testbed/examples3d/debug_balls3.c
diff --git a/c/testbed/examples3d/debug_big_colliders3.c b/bindings/c/testbed/examples3d/debug_big_colliders3.c
similarity index 100%
rename from c/testbed/examples3d/debug_big_colliders3.c
rename to bindings/c/testbed/examples3d/debug_big_colliders3.c
diff --git a/c/testbed/examples3d/debug_boxes3.c b/bindings/c/testbed/examples3d/debug_boxes3.c
similarity index 100%
rename from c/testbed/examples3d/debug_boxes3.c
rename to bindings/c/testbed/examples3d/debug_boxes3.c
diff --git a/c/testbed/examples3d/debug_chain_high_mass_ratio3.c b/bindings/c/testbed/examples3d/debug_chain_high_mass_ratio3.c
similarity index 100%
rename from c/testbed/examples3d/debug_chain_high_mass_ratio3.c
rename to bindings/c/testbed/examples3d/debug_chain_high_mass_ratio3.c
diff --git a/c/testbed/examples3d/debug_cube_high_mass_ratio3.c b/bindings/c/testbed/examples3d/debug_cube_high_mass_ratio3.c
similarity index 100%
rename from c/testbed/examples3d/debug_cube_high_mass_ratio3.c
rename to bindings/c/testbed/examples3d/debug_cube_high_mass_ratio3.c
diff --git a/c/testbed/examples3d/debug_cylinder3.c b/bindings/c/testbed/examples3d/debug_cylinder3.c
similarity index 100%
rename from c/testbed/examples3d/debug_cylinder3.c
rename to bindings/c/testbed/examples3d/debug_cylinder3.c
diff --git a/c/testbed/examples3d/debug_deserialize3.c b/bindings/c/testbed/examples3d/debug_deserialize3.c
similarity index 100%
rename from c/testbed/examples3d/debug_deserialize3.c
rename to bindings/c/testbed/examples3d/debug_deserialize3.c
diff --git a/c/testbed/examples3d/debug_disabled3.c b/bindings/c/testbed/examples3d/debug_disabled3.c
similarity index 100%
rename from c/testbed/examples3d/debug_disabled3.c
rename to bindings/c/testbed/examples3d/debug_disabled3.c
diff --git a/c/testbed/examples3d/debug_dynamic_collider_add3.c b/bindings/c/testbed/examples3d/debug_dynamic_collider_add3.c
similarity index 100%
rename from c/testbed/examples3d/debug_dynamic_collider_add3.c
rename to bindings/c/testbed/examples3d/debug_dynamic_collider_add3.c
diff --git a/c/testbed/examples3d/debug_friction3.c b/bindings/c/testbed/examples3d/debug_friction3.c
similarity index 100%
rename from c/testbed/examples3d/debug_friction3.c
rename to bindings/c/testbed/examples3d/debug_friction3.c
diff --git a/c/testbed/examples3d/debug_infinite_fall3.c b/bindings/c/testbed/examples3d/debug_infinite_fall3.c
similarity index 100%
rename from c/testbed/examples3d/debug_infinite_fall3.c
rename to bindings/c/testbed/examples3d/debug_infinite_fall3.c
diff --git a/c/testbed/examples3d/debug_internal_edges3.c b/bindings/c/testbed/examples3d/debug_internal_edges3.c
similarity index 100%
rename from c/testbed/examples3d/debug_internal_edges3.c
rename to bindings/c/testbed/examples3d/debug_internal_edges3.c
diff --git a/c/testbed/examples3d/debug_long_chain3.c b/bindings/c/testbed/examples3d/debug_long_chain3.c
similarity index 100%
rename from c/testbed/examples3d/debug_long_chain3.c
rename to bindings/c/testbed/examples3d/debug_long_chain3.c
diff --git a/c/testbed/examples3d/debug_multi_collider_body3.c b/bindings/c/testbed/examples3d/debug_multi_collider_body3.c
similarity index 100%
rename from c/testbed/examples3d/debug_multi_collider_body3.c
rename to bindings/c/testbed/examples3d/debug_multi_collider_body3.c
diff --git a/c/testbed/examples3d/debug_multibody_ang_motor_pos3.c b/bindings/c/testbed/examples3d/debug_multibody_ang_motor_pos3.c
similarity index 100%
rename from c/testbed/examples3d/debug_multibody_ang_motor_pos3.c
rename to bindings/c/testbed/examples3d/debug_multibody_ang_motor_pos3.c
diff --git a/c/testbed/examples3d/debug_pop3.c b/bindings/c/testbed/examples3d/debug_pop3.c
similarity index 100%
rename from c/testbed/examples3d/debug_pop3.c
rename to bindings/c/testbed/examples3d/debug_pop3.c
diff --git a/c/testbed/examples3d/debug_prismatic3.c b/bindings/c/testbed/examples3d/debug_prismatic3.c
similarity index 100%
rename from c/testbed/examples3d/debug_prismatic3.c
rename to bindings/c/testbed/examples3d/debug_prismatic3.c
diff --git a/c/testbed/examples3d/debug_rollback3.c b/bindings/c/testbed/examples3d/debug_rollback3.c
similarity index 100%
rename from c/testbed/examples3d/debug_rollback3.c
rename to bindings/c/testbed/examples3d/debug_rollback3.c
diff --git a/c/testbed/examples3d/debug_self_intersect3.c b/bindings/c/testbed/examples3d/debug_self_intersect3.c
similarity index 100%
rename from c/testbed/examples3d/debug_self_intersect3.c
rename to bindings/c/testbed/examples3d/debug_self_intersect3.c
diff --git a/c/testbed/examples3d/debug_shape_modification3.c b/bindings/c/testbed/examples3d/debug_shape_modification3.c
similarity index 100%
rename from c/testbed/examples3d/debug_shape_modification3.c
rename to bindings/c/testbed/examples3d/debug_shape_modification3.c
diff --git a/c/testbed/examples3d/debug_sleeping_kinematic3.c b/bindings/c/testbed/examples3d/debug_sleeping_kinematic3.c
similarity index 100%
rename from c/testbed/examples3d/debug_sleeping_kinematic3.c
rename to bindings/c/testbed/examples3d/debug_sleeping_kinematic3.c
diff --git a/c/testbed/examples3d/debug_thin_cube_on_mesh3.c b/bindings/c/testbed/examples3d/debug_thin_cube_on_mesh3.c
similarity index 100%
rename from c/testbed/examples3d/debug_thin_cube_on_mesh3.c
rename to bindings/c/testbed/examples3d/debug_thin_cube_on_mesh3.c
diff --git a/c/testbed/examples3d/debug_triangle3.c b/bindings/c/testbed/examples3d/debug_triangle3.c
similarity index 100%
rename from c/testbed/examples3d/debug_triangle3.c
rename to bindings/c/testbed/examples3d/debug_triangle3.c
diff --git a/c/testbed/examples3d/debug_trimesh3.c b/bindings/c/testbed/examples3d/debug_trimesh3.c
similarity index 100%
rename from c/testbed/examples3d/debug_trimesh3.c
rename to bindings/c/testbed/examples3d/debug_trimesh3.c
diff --git a/c/testbed/examples3d/debug_two_cubes3.c b/bindings/c/testbed/examples3d/debug_two_cubes3.c
similarity index 100%
rename from c/testbed/examples3d/debug_two_cubes3.c
rename to bindings/c/testbed/examples3d/debug_two_cubes3.c
diff --git a/c/testbed/examples3d/domino3.c b/bindings/c/testbed/examples3d/domino3.c
similarity index 100%
rename from c/testbed/examples3d/domino3.c
rename to bindings/c/testbed/examples3d/domino3.c
diff --git a/c/testbed/examples3d/dynamic_trimesh3.c b/bindings/c/testbed/examples3d/dynamic_trimesh3.c
similarity index 100%
rename from c/testbed/examples3d/dynamic_trimesh3.c
rename to bindings/c/testbed/examples3d/dynamic_trimesh3.c
diff --git a/c/testbed/examples3d/fountain3.c b/bindings/c/testbed/examples3d/fountain3.c
similarity index 100%
rename from c/testbed/examples3d/fountain3.c
rename to bindings/c/testbed/examples3d/fountain3.c
diff --git a/c/testbed/examples3d/gyroscopic3.c b/bindings/c/testbed/examples3d/gyroscopic3.c
similarity index 100%
rename from c/testbed/examples3d/gyroscopic3.c
rename to bindings/c/testbed/examples3d/gyroscopic3.c
diff --git a/c/testbed/examples3d/heightfield3.c b/bindings/c/testbed/examples3d/heightfield3.c
similarity index 100%
rename from c/testbed/examples3d/heightfield3.c
rename to bindings/c/testbed/examples3d/heightfield3.c
diff --git a/c/testbed/examples3d/inverse_kinematics3.c b/bindings/c/testbed/examples3d/inverse_kinematics3.c
similarity index 100%
rename from c/testbed/examples3d/inverse_kinematics3.c
rename to bindings/c/testbed/examples3d/inverse_kinematics3.c
diff --git a/c/testbed/examples3d/joint_motor_position3.c b/bindings/c/testbed/examples3d/joint_motor_position3.c
similarity index 100%
rename from c/testbed/examples3d/joint_motor_position3.c
rename to bindings/c/testbed/examples3d/joint_motor_position3.c
diff --git a/c/testbed/examples3d/joints3.c b/bindings/c/testbed/examples3d/joints3.c
similarity index 100%
rename from c/testbed/examples3d/joints3.c
rename to bindings/c/testbed/examples3d/joints3.c
diff --git a/c/testbed/examples3d/joints3_run_impulse_joints.c b/bindings/c/testbed/examples3d/joints3_run_impulse_joints.c
similarity index 100%
rename from c/testbed/examples3d/joints3_run_impulse_joints.c
rename to bindings/c/testbed/examples3d/joints3_run_impulse_joints.c
diff --git a/c/testbed/examples3d/joints3_run_multibody_joints.c b/bindings/c/testbed/examples3d/joints3_run_multibody_joints.c
similarity index 100%
rename from c/testbed/examples3d/joints3_run_multibody_joints.c
rename to bindings/c/testbed/examples3d/joints3_run_multibody_joints.c
diff --git a/c/testbed/examples3d/keva3.c b/bindings/c/testbed/examples3d/keva3.c
similarity index 100%
rename from c/testbed/examples3d/keva3.c
rename to bindings/c/testbed/examples3d/keva3.c
diff --git a/c/testbed/examples3d/locked_rotations3.c b/bindings/c/testbed/examples3d/locked_rotations3.c
similarity index 100%
rename from c/testbed/examples3d/locked_rotations3.c
rename to bindings/c/testbed/examples3d/locked_rotations3.c
diff --git a/c/testbed/examples3d/mjcf3.c b/bindings/c/testbed/examples3d/mjcf3.c
similarity index 100%
rename from c/testbed/examples3d/mjcf3.c
rename to bindings/c/testbed/examples3d/mjcf3.c
diff --git a/c/testbed/examples3d/mujoco_menagerie3.c b/bindings/c/testbed/examples3d/mujoco_menagerie3.c
similarity index 100%
rename from c/testbed/examples3d/mujoco_menagerie3.c
rename to bindings/c/testbed/examples3d/mujoco_menagerie3.c
diff --git a/c/testbed/examples3d/newton_cradle3.c b/bindings/c/testbed/examples3d/newton_cradle3.c
similarity index 100%
rename from c/testbed/examples3d/newton_cradle3.c
rename to bindings/c/testbed/examples3d/newton_cradle3.c
diff --git a/c/testbed/examples3d/one_way_platforms3.c b/bindings/c/testbed/examples3d/one_way_platforms3.c
similarity index 100%
rename from c/testbed/examples3d/one_way_platforms3.c
rename to bindings/c/testbed/examples3d/one_way_platforms3.c
diff --git a/c/testbed/examples3d/platform3.c b/bindings/c/testbed/examples3d/platform3.c
similarity index 100%
rename from c/testbed/examples3d/platform3.c
rename to bindings/c/testbed/examples3d/platform3.c
diff --git a/c/testbed/examples3d/primitives3.c b/bindings/c/testbed/examples3d/primitives3.c
similarity index 100%
rename from c/testbed/examples3d/primitives3.c
rename to bindings/c/testbed/examples3d/primitives3.c
diff --git a/c/testbed/examples3d/restitution3.c b/bindings/c/testbed/examples3d/restitution3.c
similarity index 100%
rename from c/testbed/examples3d/restitution3.c
rename to bindings/c/testbed/examples3d/restitution3.c
diff --git a/c/testbed/examples3d/rope_joints3.c b/bindings/c/testbed/examples3d/rope_joints3.c
similarity index 100%
rename from c/testbed/examples3d/rope_joints3.c
rename to bindings/c/testbed/examples3d/rope_joints3.c
diff --git a/c/testbed/examples3d/sensor3.c b/bindings/c/testbed/examples3d/sensor3.c
similarity index 100%
rename from c/testbed/examples3d/sensor3.c
rename to bindings/c/testbed/examples3d/sensor3.c
diff --git a/c/testbed/examples3d/soft_bodies3.c b/bindings/c/testbed/examples3d/soft_bodies3.c
similarity index 100%
rename from c/testbed/examples3d/soft_bodies3.c
rename to bindings/c/testbed/examples3d/soft_bodies3.c
diff --git a/c/testbed/examples3d/soft_cloth3.c b/bindings/c/testbed/examples3d/soft_cloth3.c
similarity index 100%
rename from c/testbed/examples3d/soft_cloth3.c
rename to bindings/c/testbed/examples3d/soft_cloth3.c
diff --git a/c/testbed/examples3d/soft_cloth_stress3.c b/bindings/c/testbed/examples3d/soft_cloth_stress3.c
similarity index 100%
rename from c/testbed/examples3d/soft_cloth_stress3.c
rename to bindings/c/testbed/examples3d/soft_cloth_stress3.c
diff --git a/c/testbed/examples3d/soft_dress3.c b/bindings/c/testbed/examples3d/soft_dress3.c
similarity index 100%
rename from c/testbed/examples3d/soft_dress3.c
rename to bindings/c/testbed/examples3d/soft_dress3.c
diff --git a/c/testbed/examples3d/soft_fem3.c b/bindings/c/testbed/examples3d/soft_fem3.c
similarity index 100%
rename from c/testbed/examples3d/soft_fem3.c
rename to bindings/c/testbed/examples3d/soft_fem3.c
diff --git a/c/testbed/examples3d/soft_jelly3.c b/bindings/c/testbed/examples3d/soft_jelly3.c
similarity index 100%
rename from c/testbed/examples3d/soft_jelly3.c
rename to bindings/c/testbed/examples3d/soft_jelly3.c
diff --git a/c/testbed/examples3d/soft_joints3.c b/bindings/c/testbed/examples3d/soft_joints3.c
similarity index 100%
rename from c/testbed/examples3d/soft_joints3.c
rename to bindings/c/testbed/examples3d/soft_joints3.c
diff --git a/c/testbed/examples3d/soft_meshes3.c b/bindings/c/testbed/examples3d/soft_meshes3.c
similarity index 100%
rename from c/testbed/examples3d/soft_meshes3.c
rename to bindings/c/testbed/examples3d/soft_meshes3.c
diff --git a/c/testbed/examples3d/soft_pile3.c b/bindings/c/testbed/examples3d/soft_pile3.c
similarity index 100%
rename from c/testbed/examples3d/soft_pile3.c
rename to bindings/c/testbed/examples3d/soft_pile3.c
diff --git a/c/testbed/examples3d/soft_plasticity3.c b/bindings/c/testbed/examples3d/soft_plasticity3.c
similarity index 100%
rename from c/testbed/examples3d/soft_plasticity3.c
rename to bindings/c/testbed/examples3d/soft_plasticity3.c
diff --git a/c/testbed/examples3d/soft_surface3.c b/bindings/c/testbed/examples3d/soft_surface3.c
similarity index 100%
rename from c/testbed/examples3d/soft_surface3.c
rename to bindings/c/testbed/examples3d/soft_surface3.c
diff --git a/c/testbed/examples3d/soft_tearing3.c b/bindings/c/testbed/examples3d/soft_tearing3.c
similarity index 100%
rename from c/testbed/examples3d/soft_tearing3.c
rename to bindings/c/testbed/examples3d/soft_tearing3.c
diff --git a/c/testbed/examples3d/soft_thin_features3.c b/bindings/c/testbed/examples3d/soft_thin_features3.c
similarity index 100%
rename from c/testbed/examples3d/soft_thin_features3.c
rename to bindings/c/testbed/examples3d/soft_thin_features3.c
diff --git a/c/testbed/examples3d/soft_trimesh3.c b/bindings/c/testbed/examples3d/soft_trimesh3.c
similarity index 100%
rename from c/testbed/examples3d/soft_trimesh3.c
rename to bindings/c/testbed/examples3d/soft_trimesh3.c
diff --git a/c/testbed/examples3d/spring_joints3.c b/bindings/c/testbed/examples3d/spring_joints3.c
similarity index 100%
rename from c/testbed/examples3d/spring_joints3.c
rename to bindings/c/testbed/examples3d/spring_joints3.c
diff --git a/c/testbed/examples3d/stress_tests/balls3.c b/bindings/c/testbed/examples3d/stress_tests/balls3.c
similarity index 100%
rename from c/testbed/examples3d/stress_tests/balls3.c
rename to bindings/c/testbed/examples3d/stress_tests/balls3.c
diff --git a/c/testbed/examples3d/stress_tests/boxes3.c b/bindings/c/testbed/examples3d/stress_tests/boxes3.c
similarity index 100%
rename from c/testbed/examples3d/stress_tests/boxes3.c
rename to bindings/c/testbed/examples3d/stress_tests/boxes3.c
diff --git a/c/testbed/examples3d/stress_tests/capsules3.c b/bindings/c/testbed/examples3d/stress_tests/capsules3.c
similarity index 100%
rename from c/testbed/examples3d/stress_tests/capsules3.c
rename to bindings/c/testbed/examples3d/stress_tests/capsules3.c
diff --git a/c/testbed/examples3d/stress_tests/ccd3.c b/bindings/c/testbed/examples3d/stress_tests/ccd3.c
similarity index 100%
rename from c/testbed/examples3d/stress_tests/ccd3.c
rename to bindings/c/testbed/examples3d/stress_tests/ccd3.c
diff --git a/c/testbed/examples3d/stress_tests/compound3.c b/bindings/c/testbed/examples3d/stress_tests/compound3.c
similarity index 100%
rename from c/testbed/examples3d/stress_tests/compound3.c
rename to bindings/c/testbed/examples3d/stress_tests/compound3.c
diff --git a/c/testbed/examples3d/stress_tests/convex_polyhedron3.c b/bindings/c/testbed/examples3d/stress_tests/convex_polyhedron3.c
similarity index 100%
rename from c/testbed/examples3d/stress_tests/convex_polyhedron3.c
rename to bindings/c/testbed/examples3d/stress_tests/convex_polyhedron3.c
diff --git a/c/testbed/examples3d/stress_tests/heightfield3.c b/bindings/c/testbed/examples3d/stress_tests/heightfield3.c
similarity index 100%
rename from c/testbed/examples3d/stress_tests/heightfield3.c
rename to bindings/c/testbed/examples3d/stress_tests/heightfield3.c
diff --git a/c/testbed/examples3d/stress_tests/joint_ball3.c b/bindings/c/testbed/examples3d/stress_tests/joint_ball3.c
similarity index 100%
rename from c/testbed/examples3d/stress_tests/joint_ball3.c
rename to bindings/c/testbed/examples3d/stress_tests/joint_ball3.c
diff --git a/c/testbed/examples3d/stress_tests/joint_fixed3.c b/bindings/c/testbed/examples3d/stress_tests/joint_fixed3.c
similarity index 100%
rename from c/testbed/examples3d/stress_tests/joint_fixed3.c
rename to bindings/c/testbed/examples3d/stress_tests/joint_fixed3.c
diff --git a/c/testbed/examples3d/stress_tests/joint_prismatic3.c b/bindings/c/testbed/examples3d/stress_tests/joint_prismatic3.c
similarity index 100%
rename from c/testbed/examples3d/stress_tests/joint_prismatic3.c
rename to bindings/c/testbed/examples3d/stress_tests/joint_prismatic3.c
diff --git a/c/testbed/examples3d/stress_tests/joint_revolute3.c b/bindings/c/testbed/examples3d/stress_tests/joint_revolute3.c
similarity index 100%
rename from c/testbed/examples3d/stress_tests/joint_revolute3.c
rename to bindings/c/testbed/examples3d/stress_tests/joint_revolute3.c
diff --git a/c/testbed/examples3d/stress_tests/keva3.c b/bindings/c/testbed/examples3d/stress_tests/keva3.c
similarity index 100%
rename from c/testbed/examples3d/stress_tests/keva3.c
rename to bindings/c/testbed/examples3d/stress_tests/keva3.c
diff --git a/c/testbed/examples3d/stress_tests/many_kinematics3.c b/bindings/c/testbed/examples3d/stress_tests/many_kinematics3.c
similarity index 100%
rename from c/testbed/examples3d/stress_tests/many_kinematics3.c
rename to bindings/c/testbed/examples3d/stress_tests/many_kinematics3.c
diff --git a/c/testbed/examples3d/stress_tests/many_pyramids3.c b/bindings/c/testbed/examples3d/stress_tests/many_pyramids3.c
similarity index 100%
rename from c/testbed/examples3d/stress_tests/many_pyramids3.c
rename to bindings/c/testbed/examples3d/stress_tests/many_pyramids3.c
diff --git a/c/testbed/examples3d/stress_tests/many_sleep3.c b/bindings/c/testbed/examples3d/stress_tests/many_sleep3.c
similarity index 100%
rename from c/testbed/examples3d/stress_tests/many_sleep3.c
rename to bindings/c/testbed/examples3d/stress_tests/many_sleep3.c
diff --git a/c/testbed/examples3d/stress_tests/many_static3.c b/bindings/c/testbed/examples3d/stress_tests/many_static3.c
similarity index 100%
rename from c/testbed/examples3d/stress_tests/many_static3.c
rename to bindings/c/testbed/examples3d/stress_tests/many_static3.c
diff --git a/c/testbed/examples3d/stress_tests/pyramid3.c b/bindings/c/testbed/examples3d/stress_tests/pyramid3.c
similarity index 100%
rename from c/testbed/examples3d/stress_tests/pyramid3.c
rename to bindings/c/testbed/examples3d/stress_tests/pyramid3.c
diff --git a/c/testbed/examples3d/stress_tests/ragdolls3.c b/bindings/c/testbed/examples3d/stress_tests/ragdolls3.c
similarity index 100%
rename from c/testbed/examples3d/stress_tests/ragdolls3.c
rename to bindings/c/testbed/examples3d/stress_tests/ragdolls3.c
diff --git a/c/testbed/examples3d/stress_tests/ray_cast3.c b/bindings/c/testbed/examples3d/stress_tests/ray_cast3.c
similarity index 100%
rename from c/testbed/examples3d/stress_tests/ray_cast3.c
rename to bindings/c/testbed/examples3d/stress_tests/ray_cast3.c
diff --git a/c/testbed/examples3d/stress_tests/ropes3.c b/bindings/c/testbed/examples3d/stress_tests/ropes3.c
similarity index 100%
rename from c/testbed/examples3d/stress_tests/ropes3.c
rename to bindings/c/testbed/examples3d/stress_tests/ropes3.c
diff --git a/c/testbed/examples3d/stress_tests/soft_blobs3.c b/bindings/c/testbed/examples3d/stress_tests/soft_blobs3.c
similarity index 100%
rename from c/testbed/examples3d/stress_tests/soft_blobs3.c
rename to bindings/c/testbed/examples3d/stress_tests/soft_blobs3.c
diff --git a/c/testbed/examples3d/stress_tests/soft_cloth_drape3.c b/bindings/c/testbed/examples3d/stress_tests/soft_cloth_drape3.c
similarity index 100%
rename from c/testbed/examples3d/stress_tests/soft_cloth_drape3.c
rename to bindings/c/testbed/examples3d/stress_tests/soft_cloth_drape3.c
diff --git a/c/testbed/examples3d/stress_tests/soft_cloth_keva3.c b/bindings/c/testbed/examples3d/stress_tests/soft_cloth_keva3.c
similarity index 100%
rename from c/testbed/examples3d/stress_tests/soft_cloth_keva3.c
rename to bindings/c/testbed/examples3d/stress_tests/soft_cloth_keva3.c
diff --git a/c/testbed/examples3d/stress_tests/soft_fem_beams3.c b/bindings/c/testbed/examples3d/stress_tests/soft_fem_beams3.c
similarity index 100%
rename from c/testbed/examples3d/stress_tests/soft_fem_beams3.c
rename to bindings/c/testbed/examples3d/stress_tests/soft_fem_beams3.c
diff --git a/c/testbed/examples3d/stress_tests/soft_jellies3.c b/bindings/c/testbed/examples3d/stress_tests/soft_jellies3.c
similarity index 100%
rename from c/testbed/examples3d/stress_tests/soft_jellies3.c
rename to bindings/c/testbed/examples3d/stress_tests/soft_jellies3.c
diff --git a/c/testbed/examples3d/stress_tests/soft_ropes3.c b/bindings/c/testbed/examples3d/stress_tests/soft_ropes3.c
similarity index 100%
rename from c/testbed/examples3d/stress_tests/soft_ropes3.c
rename to bindings/c/testbed/examples3d/stress_tests/soft_ropes3.c
diff --git a/c/testbed/examples3d/stress_tests/soft_slab3.c b/bindings/c/testbed/examples3d/stress_tests/soft_slab3.c
similarity index 100%
rename from c/testbed/examples3d/stress_tests/soft_slab3.c
rename to bindings/c/testbed/examples3d/stress_tests/soft_slab3.c
diff --git a/c/testbed/examples3d/stress_tests/stacks3.c b/bindings/c/testbed/examples3d/stress_tests/stacks3.c
similarity index 100%
rename from c/testbed/examples3d/stress_tests/stacks3.c
rename to bindings/c/testbed/examples3d/stress_tests/stacks3.c
diff --git a/c/testbed/examples3d/stress_tests/trimesh3.c b/bindings/c/testbed/examples3d/stress_tests/trimesh3.c
similarity index 100%
rename from c/testbed/examples3d/stress_tests/trimesh3.c
rename to bindings/c/testbed/examples3d/stress_tests/trimesh3.c
diff --git a/c/testbed/examples3d/trimesh3.c b/bindings/c/testbed/examples3d/trimesh3.c
similarity index 100%
rename from c/testbed/examples3d/trimesh3.c
rename to bindings/c/testbed/examples3d/trimesh3.c
diff --git a/c/testbed/examples3d/urdf3.c b/bindings/c/testbed/examples3d/urdf3.c
similarity index 100%
rename from c/testbed/examples3d/urdf3.c
rename to bindings/c/testbed/examples3d/urdf3.c
diff --git a/c/testbed/examples3d/utils/character.h b/bindings/c/testbed/examples3d/utils/character.h
similarity index 100%
rename from c/testbed/examples3d/utils/character.h
rename to bindings/c/testbed/examples3d/utils/character.h
diff --git a/c/testbed/examples3d/utils/files.h b/bindings/c/testbed/examples3d/utils/files.h
similarity index 100%
rename from c/testbed/examples3d/utils/files.h
rename to bindings/c/testbed/examples3d/utils/files.h
diff --git a/c/testbed/examples3d/utils/obj.h b/bindings/c/testbed/examples3d/utils/obj.h
similarity index 100%
rename from c/testbed/examples3d/utils/obj.h
rename to bindings/c/testbed/examples3d/utils/obj.h
diff --git a/c/testbed/examples3d/vehicle_controller3.c b/bindings/c/testbed/examples3d/vehicle_controller3.c
similarity index 100%
rename from c/testbed/examples3d/vehicle_controller3.c
rename to bindings/c/testbed/examples3d/vehicle_controller3.c
diff --git a/c/testbed/examples3d/vehicle_joints3.c b/bindings/c/testbed/examples3d/vehicle_joints3.c
similarity index 100%
rename from c/testbed/examples3d/vehicle_joints3.c
rename to bindings/c/testbed/examples3d/vehicle_joints3.c
diff --git a/c/testbed/examples3d/voxels3.c b/bindings/c/testbed/examples3d/voxels3.c
similarity index 100%
rename from c/testbed/examples3d/voxels3.c
rename to bindings/c/testbed/examples3d/voxels3.c
diff --git a/c/testbed/font_data.h.in b/bindings/c/testbed/font_data.h.in
similarity index 100%
rename from c/testbed/font_data.h.in
rename to bindings/c/testbed/font_data.h.in
diff --git a/c/testbed/grab.c b/bindings/c/testbed/grab.c
similarity index 100%
rename from c/testbed/grab.c
rename to bindings/c/testbed/grab.c
diff --git a/c/testbed/grab.h b/bindings/c/testbed/grab.h
similarity index 100%
rename from c/testbed/grab.h
rename to bindings/c/testbed/grab.h
diff --git a/c/testbed/graphics.c b/bindings/c/testbed/graphics.c
similarity index 100%
rename from c/testbed/graphics.c
rename to bindings/c/testbed/graphics.c
diff --git a/c/testbed/graphics.h b/bindings/c/testbed/graphics.h
similarity index 100%
rename from c/testbed/graphics.h
rename to bindings/c/testbed/graphics.h
diff --git a/c/testbed/gui.c b/bindings/c/testbed/gui.c
similarity index 100%
rename from c/testbed/gui.c
rename to bindings/c/testbed/gui.c
diff --git a/c/testbed/headless.c b/bindings/c/testbed/headless.c
similarity index 100%
rename from c/testbed/headless.c
rename to bindings/c/testbed/headless.c
diff --git a/c/testbed/headless_main.c b/bindings/c/testbed/headless_main.c
similarity index 100%
rename from c/testbed/headless_main.c
rename to bindings/c/testbed/headless_main.c
diff --git a/c/testbed/licenses/Apache-2.0.txt b/bindings/c/testbed/licenses/Apache-2.0.txt
similarity index 100%
rename from c/testbed/licenses/Apache-2.0.txt
rename to bindings/c/testbed/licenses/Apache-2.0.txt
diff --git a/c/testbed/licenses/CC0-1.0.txt b/bindings/c/testbed/licenses/CC0-1.0.txt
similarity index 100%
rename from c/testbed/licenses/CC0-1.0.txt
rename to bindings/c/testbed/licenses/CC0-1.0.txt
diff --git a/c/testbed/licenses/FiraSans-LICENSE.txt b/bindings/c/testbed/licenses/FiraSans-LICENSE.txt
similarity index 100%
rename from c/testbed/licenses/FiraSans-LICENSE.txt
rename to bindings/c/testbed/licenses/FiraSans-LICENSE.txt
diff --git a/c/testbed/licenses/GLAD.txt b/bindings/c/testbed/licenses/GLAD.txt
similarity index 100%
rename from c/testbed/licenses/GLAD.txt
rename to bindings/c/testbed/licenses/GLAD.txt
diff --git a/c/testbed/licenses/LGPL-2.1.txt b/bindings/c/testbed/licenses/LGPL-2.1.txt
similarity index 100%
rename from c/testbed/licenses/LGPL-2.1.txt
rename to bindings/c/testbed/licenses/LGPL-2.1.txt
diff --git a/c/testbed/licenses/MIT.txt b/bindings/c/testbed/licenses/MIT.txt
similarity index 100%
rename from c/testbed/licenses/MIT.txt
rename to bindings/c/testbed/licenses/MIT.txt
diff --git a/c/testbed/licenses/SOURCES.md b/bindings/c/testbed/licenses/SOURCES.md
similarity index 100%
rename from c/testbed/licenses/SOURCES.md
rename to bindings/c/testbed/licenses/SOURCES.md
diff --git a/c/testbed/licenses/WTFPL.txt b/bindings/c/testbed/licenses/WTFPL.txt
similarity index 100%
rename from c/testbed/licenses/WTFPL.txt
rename to bindings/c/testbed/licenses/WTFPL.txt
diff --git a/c/testbed/registry2.c b/bindings/c/testbed/registry2.c
similarity index 100%
rename from c/testbed/registry2.c
rename to bindings/c/testbed/registry2.c
diff --git a/c/testbed/registry3.c b/bindings/c/testbed/registry3.c
similarity index 100%
rename from c/testbed/registry3.c
rename to bindings/c/testbed/registry3.c
diff --git a/c/testbed/testbed.c b/bindings/c/testbed/testbed.c
similarity index 100%
rename from c/testbed/testbed.c
rename to bindings/c/testbed/testbed.c
diff --git a/c/testbed/testbed.h b/bindings/c/testbed/testbed.h
similarity index 100%
rename from c/testbed/testbed.h
rename to bindings/c/testbed/testbed.h
diff --git a/c/testbed/testbed_internal.h b/bindings/c/testbed/testbed_internal.h
similarity index 100%
rename from c/testbed/testbed_internal.h
rename to bindings/c/testbed/testbed_internal.h
diff --git a/c/testbed/tests/errors.c b/bindings/c/testbed/tests/errors.c
similarity index 100%
rename from c/testbed/tests/errors.c
rename to bindings/c/testbed/tests/errors.c
diff --git a/c/testbed/tests/errors.cmake b/bindings/c/testbed/tests/errors.cmake
similarity index 100%
rename from c/testbed/tests/errors.cmake
rename to bindings/c/testbed/tests/errors.cmake
diff --git a/c/testbed/tests/grab.c b/bindings/c/testbed/tests/grab.c
similarity index 100%
rename from c/testbed/tests/grab.c
rename to bindings/c/testbed/tests/grab.c
diff --git a/c/testbed/tests/interactive.c b/bindings/c/testbed/tests/interactive.c
similarity index 100%
rename from c/testbed/tests/interactive.c
rename to bindings/c/testbed/tests/interactive.c
diff --git a/c/testbed/tests/soft_render.c b/bindings/c/testbed/tests/soft_render.c
similarity index 100%
rename from c/testbed/tests/soft_render.c
rename to bindings/c/testbed/tests/soft_render.c
diff --git a/c/testbed/tests/threading.c b/bindings/c/testbed/tests/threading.c
similarity index 100%
rename from c/testbed/tests/threading.c
rename to bindings/c/testbed/tests/threading.c
diff --git a/c/testbed/tests/ui.c b/bindings/c/testbed/tests/ui.c
similarity index 100%
rename from c/testbed/tests/ui.c
rename to bindings/c/testbed/tests/ui.c
diff --git a/c/testbed/tools/README.md b/bindings/c/testbed/tools/README.md
similarity index 93%
rename from c/testbed/tools/README.md
rename to bindings/c/testbed/tools/README.md
index 273da62bc..3596a7a4e 100644
--- a/c/testbed/tools/README.md
+++ b/bindings/c/testbed/tools/README.md
@@ -1,7 +1,7 @@
 # Comparing C and native Rust step costs
 
 `step_benchmark.c` runs the same C examples and their own physics loops as the
-viewer, using a headless frame function to record timings and snapshots. `c/examples/compare_steps.rs` replays the C world's initial snapshot with
+viewer, using a headless frame function to record timings and snapshots. `bindings/c/examples/compare_steps.rs` replays the C world's initial snapshot with
 native `PhysicsWorld::step`. Both use one worker, disable sleeping, discard 120
 warmup steps, and measure the next 300 steps. Setup, rendering, and serialization
 are outside the measured region. Native Rust checks every final rigid-body pose
@@ -11,7 +11,7 @@ awake. Use only trusted snapshots from the same checkout/configuration.
 From the repository root, on a quiet machine:
 
 ```sh
-cmake -S c -B build/compare3 -DRAPIER_BUILD_TESTBED=ON \
+cmake -S bindings/c -B build/compare3 -DRAPIER_BUILD_TESTBED=ON \
   -DRAPIER_TESTBED_GRAPHICS=OFF -DRAPIER_PROFILE=release \
   -DCMAKE_BUILD_TYPE=Release -DRAPIER_ENABLE_PARALLEL=ON -DRAPIER_SIMD_LANES=4
 cmake --build build/compare3 --config Release --target rapier_testbed_step_benchmark
diff --git a/c/testbed/tools/logo-mesh/Cargo.toml b/bindings/c/testbed/tools/logo-mesh/Cargo.toml
similarity index 70%
rename from c/testbed/tools/logo-mesh/Cargo.toml
rename to bindings/c/testbed/tools/logo-mesh/Cargo.toml
index ccab60dbd..fd0986ff9 100644
--- a/c/testbed/tools/logo-mesh/Cargo.toml
+++ b/bindings/c/testbed/tools/logo-mesh/Cargo.toml
@@ -5,6 +5,6 @@ edition = "2024"
 publish = false
 
 [dependencies]
-rapier2d = { path = "../../../../crates/rapier2d" }
+rapier2d = { path = "../../../../../crates/rapier2d" }
 lyon = "0.17"
 usvg = "0.14"
diff --git a/c/testbed/tools/logo-mesh/src/main.rs b/bindings/c/testbed/tools/logo-mesh/src/main.rs
similarity index 96%
rename from c/testbed/tools/logo-mesh/src/main.rs
rename to bindings/c/testbed/tools/logo-mesh/src/main.rs
index d82793150..830653cf5 100644
--- a/c/testbed/tools/logo-mesh/src/main.rs
+++ b/bindings/c/testbed/tools/logo-mesh/src/main.rs
@@ -1,5 +1,5 @@
 //! Regenerate examples2d/utils/logo_mesh.h with the Rust demo's exact SVG tessellation.
-#[path = "../../../../../examples2d/utils/svg.rs"]
+#[path = "../../../../../../examples2d/utils/svg.rs"]
 mod svg;
 
 fn main() {
diff --git a/c/testbed/tools/step_benchmark.c b/bindings/c/testbed/tools/step_benchmark.c
similarity index 100%
rename from c/testbed/tools/step_benchmark.c
rename to bindings/c/testbed/tools/step_benchmark.c
diff --git a/c/testbed/update_catalog.py b/bindings/c/testbed/update_catalog.py
similarity index 96%
rename from c/testbed/update_catalog.py
rename to bindings/c/testbed/update_catalog.py
index ca27173d1..2c4299527 100644
--- a/c/testbed/update_catalog.py
+++ b/bindings/c/testbed/update_catalog.py
@@ -2,8 +2,8 @@
 """Regenerate the example registry and audit coverage against the Rust testbed."""
 from pathlib import Path
 import re, json
-root=Path(__file__).resolve().parents[2]
-target=root/'c/testbed'
+root=Path(__file__).resolve().parents[3]
+target=root/'bindings/c/testbed'
 entries=[]
 for dim in [2,3]:
     src=(root/f'examples{dim}d/all_examples{dim}.rs').read_text()
diff --git a/c/tests/array_views.c b/bindings/c/tests/array_views.c
similarity index 100%
rename from c/tests/array_views.c
rename to bindings/c/tests/array_views.c
diff --git a/c/tests/array_views.cpp b/bindings/c/tests/array_views.cpp
similarity index 100%
rename from c/tests/array_views.cpp
rename to bindings/c/tests/array_views.cpp
diff --git a/c/tests/consumer/CMakeLists.txt b/bindings/c/tests/consumer/CMakeLists.txt
similarity index 100%
rename from c/tests/consumer/CMakeLists.txt
rename to bindings/c/tests/consumer/CMakeLists.txt
diff --git a/c/tests/consumer/main.cpp b/bindings/c/tests/consumer/main.cpp
similarity index 100%
rename from c/tests/consumer/main.cpp
rename to bindings/c/tests/consumer/main.cpp
diff --git a/c/tests/cpp.cpp b/bindings/c/tests/cpp.cpp
similarity index 100%
rename from c/tests/cpp.cpp
rename to bindings/c/tests/cpp.cpp
diff --git a/c/tests/handles.c b/bindings/c/tests/handles.c
similarity index 100%
rename from c/tests/handles.c
rename to bindings/c/tests/handles.c
diff --git a/c/tests/initializers.c b/bindings/c/tests/initializers.c
similarity index 100%
rename from c/tests/initializers.c
rename to bindings/c/tests/initializers.c
diff --git a/c/tests/initializers.cpp b/bindings/c/tests/initializers.cpp
similarity index 100%
rename from c/tests/initializers.cpp
rename to bindings/c/tests/initializers.cpp
diff --git a/c/tests/integration.c b/bindings/c/tests/integration.c
similarity index 100%
rename from c/tests/integration.c
rename to bindings/c/tests/integration.c
diff --git a/c/tests/pod.c b/bindings/c/tests/pod.c
similarity index 100%
rename from c/tests/pod.c
rename to bindings/c/tests/pod.c
diff --git a/c/tools/export_names.py b/bindings/c/tools/export_names.py
similarity index 94%
rename from c/tools/export_names.py
rename to bindings/c/tools/export_names.py
index 986e222db..74943dd8f 100644
--- a/c/tools/export_names.py
+++ b/bindings/c/tools/export_names.py
@@ -2,7 +2,7 @@
 from pathlib import Path
 import re
 
-ROOT = Path(__file__).resolve().parents[2]
+ROOT = Path(__file__).resolve().parents[3]
 EXPORT_ATTRIBUTE = r"#\[rapier_export(?:\(([a-z][a-z0-9_]*)\))?\]"
 DECLARATION = r'pub (?:unsafe )?extern "C" fn (rpr_[a-z0-9_]+)'
 
@@ -28,7 +28,7 @@ def read_exports():
     exports = {}
     # Attributes may be followed by cfg attributes and documentation comments.
     pattern = EXPORT_ATTRIBUTE + r"(?:(?!#\[rapier_export)[\s\S])*?" + DECLARATION
-    for source in sorted((ROOT / "c/src").glob("*.rs")):
+    for source in sorted((ROOT / "bindings/c/src").glob("*.rs")):
         text = source.read_text()
         declarations = set(re.findall(DECLARATION, text))
         annotated = set()
diff --git a/c/tools/generate-header.py b/bindings/c/tools/generate-header.py
similarity index 94%
rename from c/tools/generate-header.py
rename to bindings/c/tools/generate-header.py
index 987c9e6ff..e6237094a 100644
--- a/c/tools/generate-header.py
+++ b/bindings/c/tools/generate-header.py
@@ -8,8 +8,8 @@
 
 from export_names import EXPORT_ATTRIBUTE, c_name
 
-ROOT = Path(__file__).resolve().parents[2]
-DESTINATION = Path(sys.argv[1]) if len(sys.argv) > 1 else ROOT / "c/include/rapier.h"
+ROOT = Path(__file__).resolve().parents[3]
+DESTINATION = Path(sys.argv[1]) if len(sys.argv) > 1 else ROOT / "bindings/c/include/rapier.h"
 
 
 with tempfile.TemporaryDirectory(prefix="rapier-header-") as tmp:
@@ -19,7 +19,7 @@
     # cbindgen parses source without expanding custom attributes. Give it a
     # temporary declaration view where our export marker is the standard one.
     # Signatures, docs, types, and feature gates all come from the real source.
-    sources = sorted((ROOT / "c/src").glob("*.rs"))
+    sources = sorted((ROOT / "bindings/c/src").glob("*.rs"))
     for source in sources:
         text = re.sub(EXPORT_ATTRIBUTE, "#[unsafe(no_mangle)]", source.read_text())
         (source_dir / source.name).write_text(text)
@@ -40,7 +40,7 @@
 ''')
     raw = project / "rapier.h"
     subprocess.run([
-        "cbindgen", "--config", str(ROOT / "c/cbindgen.toml"),
+        "cbindgen", "--config", str(ROOT / "bindings/c/cbindgen.toml"),
         "--crate", "rapier-c-header", "--output", str(raw),
     ], cwd=project, check=True)
     text = raw.read_text()
diff --git a/c/tools/generate-header.sh b/bindings/c/tools/generate-header.sh
similarity index 100%
rename from c/tools/generate-header.sh
rename to bindings/c/tools/generate-header.sh
diff --git a/c/tools/test-native.py b/bindings/c/tools/test-native.py
similarity index 87%
rename from c/tools/test-native.py
rename to bindings/c/tools/test-native.py
index aede9c0c0..c2c6e5fd4 100644
--- a/c/tools/test-native.py
+++ b/bindings/c/tools/test-native.py
@@ -12,8 +12,8 @@
 
 from export_names import EXPORTS, c_name
 
-ROOT = Path(__file__).resolve().parents[2]
-VERSION = (ROOT / "c/VERSION").read_text().strip()
+ROOT = Path(__file__).resolve().parents[3]
+VERSION = (ROOT / "bindings/c/VERSION").read_text().strip()
 CC = shlex.split(os.environ.get("CC", "cc"))
 CXX = shlex.split(os.environ.get("CXX", "c++"))
 VARIANTS = [(d, p) for d in (2, 3) for p in (32, 64)]
@@ -39,11 +39,11 @@ def link_flags(libraries, linkage):
     temp = Path(directory)
     for (dim, precision), package in zip(VARIANTS, PACKAGES):
         library = package.replace("-", "_")
-        flags = ["-Wall", "-Wextra", "-Werror", "-UNDEBUG", "-I", str(ROOT / "c/include"),
+        flags = ["-Wall", "-Wextra", "-Werror", "-UNDEBUG", "-I", str(ROOT / "bindings/c/include"),
                  f"-DRAPIER_DIM{dim}", f"-DRAPIER_F{precision}",
                  f'-DRAPIER_EXPECTED_VERSION="{VERSION}"']
         header = subprocess.check_output([*CC, "-E", "-P", "-x", "c", *flags,
-                                          str(ROOT / "c/include/rapier.h")], text=True)
+                                          str(ROOT / "bindings/c/include/rapier.h")], text=True)
         symbols = set(re.findall(r"\b(r[23][A-Z]\w*)\s*\(", header))
         assert symbols and all(name.startswith(f"r{dim}") for name in symbols)
         assert f"r{dim}InsertRigidBody" in symbols
@@ -72,7 +72,7 @@ def link_flags(libraries, linkage):
         assert not re.search(r"\brpr_\w+\s*\(", header)
         assert not re.search(r"\b(?:Rpr\w*|RPR_\w+|R" + str(5 - dim) + r"[A-Z_]\w*)\b", header)
         macros = subprocess.check_output([*CC, "-E", "-dM", "-x", "c", *flags,
-                                          str(ROOT / "c/include/rapier.h")], text=True)
+                                          str(ROOT / "bindings/c/include/rapier.h")], text=True)
         assert re.search(rf"^#define R{dim}_OK 0$", macros, re.M)
         assert re.search(rf"^#define R{dim}_ABI_VERSION 1$", macros, re.M)
         assert not re.search(r"^#define (?:RPR_|R" + str(5 - dim) + r"_)", macros, re.M)
@@ -113,14 +113,14 @@ def link_flags(libraries, linkage):
             + "};\nint main(void) { for (unsigned i = 0; i < sizeof(symbols)/sizeof(symbols[0]); ++i) "
               "if (!symbols[i]) return 1; return 0; }\n")
         for linkage in ("shared", "static"):
-            for source, compiler, standard in [(ROOT / "c/tests/integration.c", CC, "c11"),
-                                                (ROOT / "c/tests/cpp.cpp", CXX, "c++17"),
-                                                (ROOT / "c/tests/pod.c", CC, "c11"),
-                                                (ROOT / "c/tests/handles.c", CC, "c11"),
-                                                (ROOT / "c/tests/initializers.c", CC, "c11"),
-                                                (ROOT / "c/tests/initializers.cpp", CXX, "c++17"),
-                                                (ROOT / "c/tests/array_views.c", CC, "c11"),
-                                                (ROOT / "c/tests/array_views.cpp", CXX, "c++17"),
+            for source, compiler, standard in [(ROOT / "bindings/c/tests/integration.c", CC, "c11"),
+                                                (ROOT / "bindings/c/tests/cpp.cpp", CXX, "c++17"),
+                                                (ROOT / "bindings/c/tests/pod.c", CC, "c11"),
+                                                (ROOT / "bindings/c/tests/handles.c", CC, "c11"),
+                                                (ROOT / "bindings/c/tests/initializers.c", CC, "c11"),
+                                                (ROOT / "bindings/c/tests/initializers.cpp", CXX, "c++17"),
+                                                (ROOT / "bindings/c/tests/array_views.c", CC, "c11"),
+                                                (ROOT / "bindings/c/tests/array_views.cpp", CXX, "c++17"),
                                                 (symbol_source, CC, "c11")]:
                 output = temp / f"{source.stem}-{library}-{linkage}"
                 subprocess.run([*compiler, f"-std={standard}", *flags, str(source),
@@ -147,7 +147,7 @@ def link_flags(libraries, linkage):
 }}
 ''')
             subprocess.run([*CC, "-std=c11", "-Wall", "-Wextra", "-Werror",
-                            f"-DRAPIER_DIM{dim}", f"-DRAPIER_F{precision}", "-I", str(ROOT / "c/include"),
+                            f"-DRAPIER_DIM{dim}", f"-DRAPIER_F{precision}", "-I", str(ROOT / "bindings/c/include"),
                             "-c", str(source), "-o", str(obj)], check=True)
             objects.append(str(obj))
             libraries.append(f"rapier{dim}d" + ("_f64" if precision == 64 else "") + "_ffi")
diff --git a/python/README.md b/bindings/python/README.md
similarity index 77%
rename from python/README.md
rename to bindings/python/README.md
index 7d871225e..d97804d88 100644
--- a/python/README.md
+++ b/bindings/python/README.md
@@ -4,9 +4,9 @@ The Rapier physics engine exposed to Python via [PyO3](https://pyo3.rs/) and
 [maturin](https://www.maturin.rs/). The bindings ship as a single PyPI
 package wrapping the 3D, `f32` engine:
 
-| PyPI dist     | import name    | crate (`python/…`) | dim | scalar |
-| ------------- | -------------- | ------------------ | --- | ------ |
-| `rapier3d`    | `rapier3d`     | `rapier-py-3d`     | 3D  | f32    |
+| PyPI dist     | import name    | crate (`bindings/python/…`) | dim | scalar |
+| ------------- | -------------- | --------------------------- | --- | ------ |
+| `rapier3d`    | `rapier3d`     | `rapier-py-3d`              | 3D  | f32    |
 
 The Panda3D visual testbed lives in the separate `rapier-testbed` package.
 
@@ -38,17 +38,17 @@ pip install maturin
 
 ## Quick start
 
-[`python/dev.sh`](dev.sh) does everything below in one command — builds the
+[`bindings/python/dev.sh`](dev.sh) does everything below in one command — builds the
 package, runs the test suite, builds the docs, and smoke-tests the testbed. It
 creates and manages a `.venv` at the repo root on first run:
 
 ```bash
-python/dev.sh                 # build + test + docs + testbed (headless smoke)
-python/dev.sh build           # just build the package
-python/dev.sh test            # build + run the test suite
-python/dev.sh docs            # build + build the docs
-python/dev.sh testbed         # build + install testbed, open the picker
-python/dev.sh --help          # all commands and options (e.g. PROFILE=debug)
+bindings/python/dev.sh                 # build + test + docs + testbed (headless smoke)
+bindings/python/dev.sh build           # just build the package
+bindings/python/dev.sh test            # build + run the test suite
+bindings/python/dev.sh docs            # build + build the docs
+bindings/python/dev.sh testbed         # build + install testbed, open the picker
+bindings/python/dev.sh --help          # all commands and options (e.g. PROFILE=debug)
 ```
 
 The sections below are the manual equivalents.
@@ -59,7 +59,7 @@ Build the package, editable, with `maturin develop` (add `--release` for an
 optimized build — slower to compile, much faster at runtime):
 
 ```bash
-maturin develop -m python/rapier-py-3d/Cargo.toml      # 3D f32 -> import rapier3d
+maturin develop -m bindings/python/rapier-py-3d/Cargo.toml      # 3D f32 -> import rapier3d
 ```
 
 ```bash
@@ -91,9 +91,9 @@ another thread raises `RuntimeError`.
 ### Run the test suite
 
 ```bash
-maturin develop --release -m python/rapier-py-3d/Cargo.toml
+maturin develop --release -m bindings/python/rapier-py-3d/Cargo.toml
 pip install pytest pytest-timeout hypothesis numpy matplotlib
-python -m pytest python/tests
+python -m pytest bindings/python/tests
 ```
 
 ## 2. Build and open the docs
@@ -103,7 +103,7 @@ The docs use Sphinx autodoc, so the engine package must be **built first**
 
 ```bash
 pip install sphinx furo sphinx-autodoc-typehints
-cd python/docs
+cd bindings/python/docs
 sphinx-build -b html . _build/html
 open _build/html/index.html          # macOS; Linux: xdg-open; Windows: start
 ```
@@ -118,12 +118,12 @@ examples ported from the Rust `examples3d/`. It drives the 3D engine.
 The testbed depends on `rapier3d`. To run it against your local build, build
 the package first (step 1 above), then install the testbed with `--no-deps` so
 pip uses your local build instead of fetching the published one.
-Run this **from the repository root** (the `./python/...` path is relative to
+Run this **from the repository root** (the `./bindings/python/...` path is relative to
 it, like the build steps above):
 
 ```bash
 pip install panda3d numpy
-pip install --no-deps -e ./python/rapier-testbed
+pip install --no-deps -e ./bindings/python/rapier-testbed
 ```
 
 The `-e` (editable) install means edits to the testbed — examples, camera, etc.
@@ -152,8 +152,8 @@ To walk through **every** example in turn — each opens in a window, and
 closing it launches the next (Ctrl-C to stop):
 
 ```bash
-python python/examples_tour.py          # every 3D example; accepts --start NAME
-python/dev.sh tour                      # same, but builds + installs the testbed first
+python bindings/python/examples_tour.py          # every 3D example; accepts --start NAME
+bindings/python/dev.sh tour                      # same, but builds + installs the testbed first
 ```
 
 ### Controls (in the viewer window)
@@ -169,7 +169,7 @@ python/dev.sh tour                      # same, but builds + installs the testbe
 The examples span categories such as Collisions, Dynamics, Joints, Controls,
 Robotics, Stress Tests, Debug, and Misc. The picker lists them all; each
 example's module name (for direct launch) matches its file under
-`python/rapier-testbed/rapier_testbed/examples3/`.
+`bindings/python/rapier-testbed/rapier_testbed/examples3/`.
 
 ## License
 
diff --git a/python/dev.sh b/bindings/python/dev.sh
similarity index 76%
rename from python/dev.sh
rename to bindings/python/dev.sh
index c102073b7..26101ad37 100755
--- a/python/dev.sh
+++ b/bindings/python/dev.sh
@@ -1,18 +1,18 @@
 #!/usr/bin/env bash
 #
 # dev.sh — build, test, document, and run the Rapier Python bindings from a
-# checkout. One entry point for everything in python/README.md.
+# checkout. One entry point for everything in bindings/python/README.md.
 #
 # Usage (run from anywhere; paths are resolved relative to the repo):
-#   python/dev.sh                 # all: build + test + docs + testbed (headless smoke)
-#   python/dev.sh build           # build the rapier3d engine package (editable)
-#   python/dev.sh test            # build, then run the full test suite
-#   python/dev.sh docs            # build, then build the HTML docs
-#   python/dev.sh testbed         # build + install testbed, open the picker
-#   python/dev.sh testbed examples3.domino3   # build + install testbed, run one example
-#   python/dev.sh tour            # build + install testbed, run every example in turn
+#   bindings/python/dev.sh                 # all: build + test + docs + testbed (headless smoke)
+#   bindings/python/dev.sh build           # build the rapier3d engine package (editable)
+#   bindings/python/dev.sh test            # build, then run the full test suite
+#   bindings/python/dev.sh docs            # build, then build the HTML docs
+#   bindings/python/dev.sh testbed         # build + install testbed, open the picker
+#   bindings/python/dev.sh testbed examples3.domino3   # build + install testbed, run one example
+#   bindings/python/dev.sh tour            # build + install testbed, run every example in turn
 #                                 #   (close a window to advance; accepts --start NAME)
-#   python/dev.sh clean           # remove build artifacts + the managed venv
+#   bindings/python/dev.sh clean           # remove build artifacts + the managed venv
 #
 # Environment:
 #   PROFILE=debug        # faster compiles, slower runtime (default: release)
@@ -21,7 +21,7 @@
 #
 set -euo pipefail
 
-REPO_ROOT="$(cd "$(dirname "${BASH_SOURCE[0]}")/.." && pwd)"
+REPO_ROOT="$(cd "$(dirname "${BASH_SOURCE[0]}")/../.." && pwd)"
 cd "$REPO_ROOT"
 
 PROFILE="${PROFILE:-release}"
@@ -63,7 +63,7 @@ build_all() {
     pip_install maturin
     for c in "${CRATES[@]}"; do
         log "Building $c ($PROFILE)"
-        maturin_develop "python/$c/Cargo.toml"
+        maturin_develop "bindings/python/$c/Cargo.toml"
     done
     python -c "import rapier3d as _; print('built rapier3d, version', _.__version__)"
 }
@@ -71,14 +71,14 @@ build_all() {
 run_tests() {
     pip_install pytest pytest-timeout hypothesis numpy matplotlib
     log "Running the test suite"
-    python -m pytest python/tests -q --timeout=120
+    python -m pytest bindings/python/tests -q --timeout=120
 }
 
 build_docs() {
     pip_install sphinx furo sphinx-autodoc-typehints
     log "Building the HTML docs"
-    ( cd python/docs && sphinx-build -q -b html . _build/html )
-    note "Docs: $REPO_ROOT/python/docs/_build/html/index.html"
+    ( cd bindings/python/docs && sphinx-build -q -b html . _build/html )
+    note "Docs: $REPO_ROOT/bindings/python/docs/_build/html/index.html"
 }
 
 install_testbed() {
@@ -87,7 +87,7 @@ install_testbed() {
     # picked up by `python -m rapier_testbed` without reinstalling. --no-deps
     # because its rapier3d dep is the local build from build_all.
     # Note: --no-deps must precede -e, else pip reads it as the -e target.
-    pip_install --no-deps -e "$REPO_ROOT/python/rapier-testbed"
+    pip_install --no-deps -e "$REPO_ROOT/bindings/python/rapier-testbed"
 }
 
 # --- commands --------------------------------------------------------------
@@ -113,7 +113,7 @@ cmd_tour() {
     # Extra args (--start NAME) pass through to examples_tour.py.
     ensure_venv; build_all; install_testbed
     log "Touring all examples (close each window to advance; Ctrl-C to stop)"
-    python "$REPO_ROOT/python/examples_tour.py" "$@"
+    python "$REPO_ROOT/bindings/python/examples_tour.py" "$@"
 }
 
 cmd_all() {
@@ -128,7 +128,7 @@ cmd_all() {
     cat <<EOF
 
 $(printf '\033[1;32mAll done.\033[0m')
-  • Docs:     open $REPO_ROOT/python/docs/_build/html/index.html
+  • Docs:     open $REPO_ROOT/bindings/python/docs/_build/html/index.html
   • Testbed:  python -m rapier_testbed                      # interactive picker
               python -m rapier_testbed.examples3.domino3    # one example
   • Activate the venv in new shells:  source ${VENV}/bin/activate
@@ -137,7 +137,7 @@ EOF
 
 cmd_clean() {
     log "Removing build artifacts and managed venv"
-    rm -rf "$VENV" python/docs/_build target/wheels
+    rm -rf "$VENV" bindings/python/docs/_build target/wheels
     find python -name '__pycache__' -type d -prune -exec rm -rf {} + 2>/dev/null || true
     find python -name '*.abi3.so' -delete 2>/dev/null || true
     note "done (run a 'cargo clean' yourself if you also want to wipe target/)"
diff --git a/python/docs/Makefile b/bindings/python/docs/Makefile
similarity index 100%
rename from python/docs/Makefile
rename to bindings/python/docs/Makefile
diff --git a/python/docs/api/controllers.rst b/bindings/python/docs/api/controllers.rst
similarity index 100%
rename from python/docs/api/controllers.rst
rename to bindings/python/docs/api/controllers.rst
diff --git a/python/docs/api/debug_render.rst b/bindings/python/docs/api/debug_render.rst
similarity index 100%
rename from python/docs/api/debug_render.rst
rename to bindings/python/docs/api/debug_render.rst
diff --git a/python/docs/api/dynamics.rst b/bindings/python/docs/api/dynamics.rst
similarity index 100%
rename from python/docs/api/dynamics.rst
rename to bindings/python/docs/api/dynamics.rst
diff --git a/python/docs/api/errors.rst b/bindings/python/docs/api/errors.rst
similarity index 100%
rename from python/docs/api/errors.rst
rename to bindings/python/docs/api/errors.rst
diff --git a/python/docs/api/events_hooks.rst b/bindings/python/docs/api/events_hooks.rst
similarity index 100%
rename from python/docs/api/events_hooks.rst
rename to bindings/python/docs/api/events_hooks.rst
diff --git a/python/docs/api/geometry.rst b/bindings/python/docs/api/geometry.rst
similarity index 100%
rename from python/docs/api/geometry.rst
rename to bindings/python/docs/api/geometry.rst
diff --git a/python/docs/api/joints.rst b/bindings/python/docs/api/joints.rst
similarity index 100%
rename from python/docs/api/joints.rst
rename to bindings/python/docs/api/joints.rst
diff --git a/python/docs/api/loaders.rst b/bindings/python/docs/api/loaders.rst
similarity index 100%
rename from python/docs/api/loaders.rst
rename to bindings/python/docs/api/loaders.rst
diff --git a/python/docs/api/math.rst b/bindings/python/docs/api/math.rst
similarity index 100%
rename from python/docs/api/math.rst
rename to bindings/python/docs/api/math.rst
diff --git a/python/docs/api/pipeline.rst b/bindings/python/docs/api/pipeline.rst
similarity index 100%
rename from python/docs/api/pipeline.rst
rename to bindings/python/docs/api/pipeline.rst
diff --git a/python/docs/api/serde.rst b/bindings/python/docs/api/serde.rst
similarity index 100%
rename from python/docs/api/serde.rst
rename to bindings/python/docs/api/serde.rst
diff --git a/python/docs/api/soft_bodies.rst b/bindings/python/docs/api/soft_bodies.rst
similarity index 100%
rename from python/docs/api/soft_bodies.rst
rename to bindings/python/docs/api/soft_bodies.rst
diff --git a/python/docs/api/world.rst b/bindings/python/docs/api/world.rst
similarity index 100%
rename from python/docs/api/world.rst
rename to bindings/python/docs/api/world.rst
diff --git a/python/docs/changelog.rst b/bindings/python/docs/changelog.rst
similarity index 100%
rename from python/docs/changelog.rst
rename to bindings/python/docs/changelog.rst
diff --git a/python/docs/conf.py b/bindings/python/docs/conf.py
similarity index 93%
rename from python/docs/conf.py
rename to bindings/python/docs/conf.py
index b84235852..a47e316d1 100644
--- a/python/docs/conf.py
+++ b/bindings/python/docs/conf.py
@@ -2,8 +2,8 @@
 
 These docs cover the ``rapier3d`` engine package (3D / f32).
 
-Build from the ``python/docs/`` directory after the engine package is
-installed (``pip install ./python/rapier-py-3d``, or ``maturin develop``
+Build from the ``bindings/python/docs/`` directory after the engine package is
+installed (``pip install ./bindings/python/rapier-py-3d``, or ``maturin develop``
 in the crate)::
 
     sphinx-build -b html . _build/html
@@ -43,7 +43,7 @@
     warnings.warn(
         f"Could not import `rapier3d` to read __version__ ({_import_err!r}); "
         "falling back to '0.32.0'. Did you install the engine packages "
-        "(e.g. `maturin develop` in python/rapier-py-3d)?",
+        "(e.g. `maturin develop` in bindings/python/rapier-py-3d)?",
         stacklevel=1,
     )
     version = "0.32.0"
diff --git a/python/docs/getting_started.rst b/bindings/python/docs/getting_started.rst
similarity index 92%
rename from python/docs/getting_started.rst
rename to bindings/python/docs/getting_started.rst
index 205bbd36d..810cefd6c 100644
--- a/python/docs/getting_started.rst
+++ b/bindings/python/docs/getting_started.rst
@@ -16,13 +16,13 @@ To build from a `Rapier checkout <https://github.com/dimforge/rapier>`_
 instead — e.g. to develop against local engine changes — use ``maturin``
 on the relevant crate::
 
-    maturin develop --release -m python/rapier-py-3d/Cargo.toml   # editable install
-    maturin build   --release -m python/rapier-py-3d/Cargo.toml   # produces a .whl
+    maturin develop --release -m bindings/python/rapier-py-3d/Cargo.toml   # editable install
+    maturin build   --release -m bindings/python/rapier-py-3d/Cargo.toml   # produces a .whl
 
 For deterministic builds (libm-based transcendentals for cross-platform
 bit-reproducibility) add ``-F determinism``::
 
-    maturin build --release -F determinism -m python/rapier-py-3d/Cargo.toml
+    maturin build --release -F determinism -m bindings/python/rapier-py-3d/Cargo.toml
 
 You can also export ``RAPIER_PY_DETERMINISM=1`` before importing the
 package; note this is informational unless the ``determinism`` feature was
diff --git a/python/docs/index.rst b/bindings/python/docs/index.rst
similarity index 100%
rename from python/docs/index.rst
rename to bindings/python/docs/index.rst
diff --git a/python/rapier-py-3d/python/rapier3d/py.typed b/bindings/python/examples/.gitkeep
similarity index 100%
rename from python/rapier-py-3d/python/rapier3d/py.typed
rename to bindings/python/examples/.gitkeep
diff --git a/python/examples/character/stairs.py b/bindings/python/examples/character/stairs.py
similarity index 97%
rename from python/examples/character/stairs.py
rename to bindings/python/examples/character/stairs.py
index 6e6126e97..476b5d44f 100644
--- a/python/examples/character/stairs.py
+++ b/bindings/python/examples/character/stairs.py
@@ -6,7 +6,7 @@
 
 Run::
 
-    python python/examples/character/stairs.py
+    python bindings/python/examples/character/stairs.py
 """
 
 from __future__ import annotations
diff --git a/python/examples/hello_world.py b/bindings/python/examples/hello_world.py
similarity index 92%
rename from python/examples/hello_world.py
rename to bindings/python/examples/hello_world.py
index b9dad2907..07fd652dd 100644
--- a/python/examples/hello_world.py
+++ b/bindings/python/examples/hello_world.py
@@ -2,7 +2,7 @@
 
 Run::
 
-    python python/examples/hello_world.py
+    python bindings/python/examples/hello_world.py
 """
 
 from __future__ import annotations
diff --git a/python/examples/joints/pendulum.py b/bindings/python/examples/joints/pendulum.py
similarity index 96%
rename from python/examples/joints/pendulum.py
rename to bindings/python/examples/joints/pendulum.py
index 6bffefc82..96034ccb6 100644
--- a/python/examples/joints/pendulum.py
+++ b/bindings/python/examples/joints/pendulum.py
@@ -6,7 +6,7 @@
 
 Run::
 
-    python python/examples/joints/pendulum.py
+    python bindings/python/examples/joints/pendulum.py
 """
 
 from __future__ import annotations
diff --git a/python/examples/joints/six_dof_motor.py b/bindings/python/examples/joints/six_dof_motor.py
similarity index 95%
rename from python/examples/joints/six_dof_motor.py
rename to bindings/python/examples/joints/six_dof_motor.py
index 6509f8bea..ea86c3fd9 100644
--- a/python/examples/joints/six_dof_motor.py
+++ b/bindings/python/examples/joints/six_dof_motor.py
@@ -6,7 +6,7 @@
 
 Run::
 
-    python python/examples/joints/six_dof_motor.py
+    python bindings/python/examples/joints/six_dof_motor.py
 """
 
 from __future__ import annotations
diff --git a/python/examples/parity/balls3.py b/bindings/python/examples/parity/balls3.py
similarity index 95%
rename from python/examples/parity/balls3.py
rename to bindings/python/examples/parity/balls3.py
index 8a31278c9..7377bb198 100644
--- a/python/examples/parity/balls3.py
+++ b/bindings/python/examples/parity/balls3.py
@@ -11,14 +11,14 @@
 
 1. ``cargo run --release -p rapier-testbed3d --bin all_examples3 -- debug_balls3``
    from the workspace root.
-2. ``python python/examples/parity/balls3.py``.
+2. ``python bindings/python/examples/parity/balls3.py``.
 3. Both runs should observe the dynamic balls settle on top of the fixed
    ones in roughly the same configuration. The Python script prints three
    probe positions; the Rust example shows the same scene visually.
 
 Run::
 
-    python python/examples/parity/balls3.py
+    python bindings/python/examples/parity/balls3.py
 """
 
 from __future__ import annotations
diff --git a/python/examples/perf/many_bodies.py b/bindings/python/examples/perf/many_bodies.py
similarity index 95%
rename from python/examples/perf/many_bodies.py
rename to bindings/python/examples/perf/many_bodies.py
index 049b962f6..8c12bc631 100644
--- a/python/examples/perf/many_bodies.py
+++ b/bindings/python/examples/perf/many_bodies.py
@@ -5,7 +5,7 @@
 
 Run::
 
-    python python/examples/perf/many_bodies.py
+    python bindings/python/examples/perf/many_bodies.py
 """
 
 from __future__ import annotations
diff --git a/python/examples/render/matplotlib_animation.py b/bindings/python/examples/render/matplotlib_animation.py
similarity index 97%
rename from python/examples/render/matplotlib_animation.py
rename to bindings/python/examples/render/matplotlib_animation.py
index 8981a36bb..44342636a 100644
--- a/python/examples/render/matplotlib_animation.py
+++ b/bindings/python/examples/render/matplotlib_animation.py
@@ -7,7 +7,7 @@
 
 Run::
 
-    python python/examples/render/matplotlib_animation.py
+    python bindings/python/examples/render/matplotlib_animation.py
 """
 
 from __future__ import annotations
diff --git a/python/examples/serde/snapshot_restore.py b/bindings/python/examples/serde/snapshot_restore.py
similarity index 94%
rename from python/examples/serde/snapshot_restore.py
rename to bindings/python/examples/serde/snapshot_restore.py
index 08761cab6..2779ccefd 100644
--- a/python/examples/serde/snapshot_restore.py
+++ b/bindings/python/examples/serde/snapshot_restore.py
@@ -4,7 +4,7 @@
 
 Run::
 
-    python python/examples/serde/snapshot_restore.py
+    python bindings/python/examples/serde/snapshot_restore.py
 """
 
 from __future__ import annotations
diff --git a/python/examples/soft/cloth_drop.py b/bindings/python/examples/soft/cloth_drop.py
similarity index 100%
rename from python/examples/soft/cloth_drop.py
rename to bindings/python/examples/soft/cloth_drop.py
diff --git a/python/examples/urdf/load_simple.py b/bindings/python/examples/urdf/load_simple.py
similarity index 96%
rename from python/examples/urdf/load_simple.py
rename to bindings/python/examples/urdf/load_simple.py
index b9da8e378..e979ddfc9 100644
--- a/python/examples/urdf/load_simple.py
+++ b/bindings/python/examples/urdf/load_simple.py
@@ -5,7 +5,7 @@
 
 Run::
 
-    python python/examples/urdf/load_simple.py
+    python bindings/python/examples/urdf/load_simple.py
 """
 
 from __future__ import annotations
diff --git a/python/examples/vehicle/drive.py b/bindings/python/examples/vehicle/drive.py
similarity index 97%
rename from python/examples/vehicle/drive.py
rename to bindings/python/examples/vehicle/drive.py
index a4f5a1858..10547b348 100644
--- a/python/examples/vehicle/drive.py
+++ b/bindings/python/examples/vehicle/drive.py
@@ -6,7 +6,7 @@
 
 Run::
 
-    python python/examples/vehicle/drive.py
+    python bindings/python/examples/vehicle/drive.py
 """
 
 from __future__ import annotations
diff --git a/python/examples_tour.py b/bindings/python/examples_tour.py
similarity index 85%
rename from python/examples_tour.py
rename to bindings/python/examples_tour.py
index f968d4a89..3164f88e4 100755
--- a/python/examples_tour.py
+++ b/bindings/python/examples_tour.py
@@ -5,13 +5,13 @@
 window's close button) and the next example launches automatically. Press
 ``Ctrl-C`` in this terminal to stop the tour.
 
-Requires the testbed to be installed (``python/dev.sh testbed``, or
-``pip install --no-deps -e ./python/rapier-testbed``).
+Requires the testbed to be installed (``bindings/python/dev.sh testbed``, or
+``pip install --no-deps -e ./bindings/python/rapier-testbed``).
 
 Usage:
-    python python/examples_tour.py            # all (3D) examples
-    python python/examples_tour.py --list     # print the example modules and exit
-    python python/examples_tour.py --start NAME   # begin at the first module
+    python bindings/python/examples_tour.py            # all (3D) examples
+    python bindings/python/examples_tour.py --list     # print the example modules and exit
+    python bindings/python/examples_tour.py --start NAME   # begin at the first module
                                                   # whose name contains NAME
 """
 from __future__ import annotations
@@ -61,8 +61,8 @@ def main(argv: list[str]) -> int:
     except ModuleNotFoundError:
         print(
             "rapier_testbed is not installed.\n"
-            "  Run:  python/dev.sh testbed\n"
-            "  or:   pip install --no-deps -e ./python/rapier-testbed",
+            "  Run:  bindings/python/dev.sh testbed\n"
+            "  or:   pip install --no-deps -e ./bindings/python/rapier-testbed",
             file=sys.stderr,
         )
         return 1
diff --git a/python/rapier-py-3d/Cargo.toml b/bindings/python/rapier-py-3d/Cargo.toml
similarity index 100%
rename from python/rapier-py-3d/Cargo.toml
rename to bindings/python/rapier-py-3d/Cargo.toml
diff --git a/python/rapier-py-3d/README.md b/bindings/python/rapier-py-3d/README.md
similarity index 100%
rename from python/rapier-py-3d/README.md
rename to bindings/python/rapier-py-3d/README.md
diff --git a/python/rapier-py-3d/build.rs b/bindings/python/rapier-py-3d/build.rs
similarity index 100%
rename from python/rapier-py-3d/build.rs
rename to bindings/python/rapier-py-3d/build.rs
diff --git a/python/rapier-py-3d/pyproject.toml b/bindings/python/rapier-py-3d/pyproject.toml
similarity index 100%
rename from python/rapier-py-3d/pyproject.toml
rename to bindings/python/rapier-py-3d/pyproject.toml
diff --git a/python/rapier-py-3d/python/rapier3d/__init__.py b/bindings/python/rapier-py-3d/python/rapier3d/__init__.py
similarity index 100%
rename from python/rapier-py-3d/python/rapier3d/__init__.py
rename to bindings/python/rapier-py-3d/python/rapier3d/__init__.py
diff --git a/python/rapier-py-3d/python/rapier3d/__init__.pyi b/bindings/python/rapier-py-3d/python/rapier3d/__init__.pyi
similarity index 100%
rename from python/rapier-py-3d/python/rapier3d/__init__.pyi
rename to bindings/python/rapier-py-3d/python/rapier3d/__init__.pyi
diff --git a/python/rapier-py-3d/python/rapier3d/_debug_render.py b/bindings/python/rapier-py-3d/python/rapier3d/_debug_render.py
similarity index 100%
rename from python/rapier-py-3d/python/rapier3d/_debug_render.py
rename to bindings/python/rapier-py-3d/python/rapier3d/_debug_render.py
diff --git a/python/rapier-py-3d/python/rapier3d/_event_handler.py b/bindings/python/rapier-py-3d/python/rapier3d/_event_handler.py
similarity index 100%
rename from python/rapier-py-3d/python/rapier3d/_event_handler.py
rename to bindings/python/rapier-py-3d/python/rapier3d/_event_handler.py
diff --git a/python/rapier-py-3d/python/rapier3d/_math_helpers.py b/bindings/python/rapier-py-3d/python/rapier3d/_math_helpers.py
similarity index 100%
rename from python/rapier-py-3d/python/rapier3d/_math_helpers.py
rename to bindings/python/rapier-py-3d/python/rapier3d/_math_helpers.py
diff --git a/python/rapier-py-3d/python/rapier3d/_pickle_setup.py b/bindings/python/rapier-py-3d/python/rapier3d/_pickle_setup.py
similarity index 100%
rename from python/rapier-py-3d/python/rapier3d/_pickle_setup.py
rename to bindings/python/rapier-py-3d/python/rapier3d/_pickle_setup.py
diff --git a/python/rapier-py-3d/python/rapier3d/_rapier3d.pyi b/bindings/python/rapier-py-3d/python/rapier3d/_rapier3d.pyi
similarity index 100%
rename from python/rapier-py-3d/python/rapier3d/_rapier3d.pyi
rename to bindings/python/rapier-py-3d/python/rapier3d/_rapier3d.pyi
diff --git a/python/rapier-py-3d/python/rapier3d/loaders/__init__.py b/bindings/python/rapier-py-3d/python/rapier3d/loaders/__init__.py
similarity index 100%
rename from python/rapier-py-3d/python/rapier3d/loaders/__init__.py
rename to bindings/python/rapier-py-3d/python/rapier3d/loaders/__init__.py
diff --git a/python/rapier-py-3d/python/rapier3d/loaders/mesh.py b/bindings/python/rapier-py-3d/python/rapier3d/loaders/mesh.py
similarity index 100%
rename from python/rapier-py-3d/python/rapier3d/loaders/mesh.py
rename to bindings/python/rapier-py-3d/python/rapier3d/loaders/mesh.py
diff --git a/python/rapier-py-3d/python/rapier3d/loaders/mjcf.py b/bindings/python/rapier-py-3d/python/rapier3d/loaders/mjcf.py
similarity index 100%
rename from python/rapier-py-3d/python/rapier3d/loaders/mjcf.py
rename to bindings/python/rapier-py-3d/python/rapier3d/loaders/mjcf.py
diff --git a/python/rapier-py-3d/python/rapier3d/loaders/urdf.py b/bindings/python/rapier-py-3d/python/rapier3d/loaders/urdf.py
similarity index 100%
rename from python/rapier-py-3d/python/rapier3d/loaders/urdf.py
rename to bindings/python/rapier-py-3d/python/rapier3d/loaders/urdf.py
diff --git a/python/rapier-py-3d/python/rapier3d/math.py b/bindings/python/rapier-py-3d/python/rapier3d/math.py
similarity index 100%
rename from python/rapier-py-3d/python/rapier3d/math.py
rename to bindings/python/rapier-py-3d/python/rapier3d/math.py
diff --git a/python/rapier-py-3d/python/rapier3d/math.pyi b/bindings/python/rapier-py-3d/python/rapier3d/math.pyi
similarity index 100%
rename from python/rapier-py-3d/python/rapier3d/math.pyi
rename to bindings/python/rapier-py-3d/python/rapier3d/math.pyi
diff --git a/bindings/python/rapier-py-3d/python/rapier3d/py.typed b/bindings/python/rapier-py-3d/python/rapier3d/py.typed
new file mode 100644
index 000000000..e69de29bb
diff --git a/python/rapier-py-3d/src/build_info.rs b/bindings/python/rapier-py-3d/src/build_info.rs
similarity index 100%
rename from python/rapier-py-3d/src/build_info.rs
rename to bindings/python/rapier-py-3d/src/build_info.rs
diff --git a/python/rapier-py-3d/src/controllers.rs b/bindings/python/rapier-py-3d/src/controllers.rs
similarity index 100%
rename from python/rapier-py-3d/src/controllers.rs
rename to bindings/python/rapier-py-3d/src/controllers.rs
diff --git a/python/rapier-py-3d/src/conv.rs b/bindings/python/rapier-py-3d/src/conv.rs
similarity index 100%
rename from python/rapier-py-3d/src/conv.rs
rename to bindings/python/rapier-py-3d/src/conv.rs
diff --git a/python/rapier-py-3d/src/debug_render.rs b/bindings/python/rapier-py-3d/src/debug_render.rs
similarity index 100%
rename from python/rapier-py-3d/src/debug_render.rs
rename to bindings/python/rapier-py-3d/src/debug_render.rs
diff --git a/python/rapier-py-3d/src/dynamics.rs b/bindings/python/rapier-py-3d/src/dynamics.rs
similarity index 100%
rename from python/rapier-py-3d/src/dynamics.rs
rename to bindings/python/rapier-py-3d/src/dynamics.rs
diff --git a/python/rapier-py-3d/src/errors.rs b/bindings/python/rapier-py-3d/src/errors.rs
similarity index 100%
rename from python/rapier-py-3d/src/errors.rs
rename to bindings/python/rapier-py-3d/src/errors.rs
diff --git a/python/rapier-py-3d/src/events_hooks.rs b/bindings/python/rapier-py-3d/src/events_hooks.rs
similarity index 100%
rename from python/rapier-py-3d/src/events_hooks.rs
rename to bindings/python/rapier-py-3d/src/events_hooks.rs
diff --git a/python/rapier-py-3d/src/geometry.rs b/bindings/python/rapier-py-3d/src/geometry.rs
similarity index 100%
rename from python/rapier-py-3d/src/geometry.rs
rename to bindings/python/rapier-py-3d/src/geometry.rs
diff --git a/python/rapier-py-3d/src/joints.rs b/bindings/python/rapier-py-3d/src/joints.rs
similarity index 100%
rename from python/rapier-py-3d/src/joints.rs
rename to bindings/python/rapier-py-3d/src/joints.rs
diff --git a/python/rapier-py-3d/src/lib.rs b/bindings/python/rapier-py-3d/src/lib.rs
similarity index 100%
rename from python/rapier-py-3d/src/lib.rs
rename to bindings/python/rapier-py-3d/src/lib.rs
diff --git a/python/rapier-py-3d/src/loaders.rs b/bindings/python/rapier-py-3d/src/loaders.rs
similarity index 100%
rename from python/rapier-py-3d/src/loaders.rs
rename to bindings/python/rapier-py-3d/src/loaders.rs
diff --git a/python/rapier-py-3d/src/math.rs b/bindings/python/rapier-py-3d/src/math.rs
similarity index 100%
rename from python/rapier-py-3d/src/math.rs
rename to bindings/python/rapier-py-3d/src/math.rs
diff --git a/python/rapier-py-3d/src/pipeline.rs b/bindings/python/rapier-py-3d/src/pipeline.rs
similarity index 100%
rename from python/rapier-py-3d/src/pipeline.rs
rename to bindings/python/rapier-py-3d/src/pipeline.rs
diff --git a/python/rapier-py-3d/src/serde_glue.rs b/bindings/python/rapier-py-3d/src/serde_glue.rs
similarity index 100%
rename from python/rapier-py-3d/src/serde_glue.rs
rename to bindings/python/rapier-py-3d/src/serde_glue.rs
diff --git a/python/rapier-py-3d/src/serde_io.rs b/bindings/python/rapier-py-3d/src/serde_io.rs
similarity index 100%
rename from python/rapier-py-3d/src/serde_io.rs
rename to bindings/python/rapier-py-3d/src/serde_io.rs
diff --git a/python/rapier-py-3d/src/soft_body.rs b/bindings/python/rapier-py-3d/src/soft_body.rs
similarity index 100%
rename from python/rapier-py-3d/src/soft_body.rs
rename to bindings/python/rapier-py-3d/src/soft_body.rs
diff --git a/python/rapier-testbed/README.md b/bindings/python/rapier-testbed/README.md
similarity index 90%
rename from python/rapier-testbed/README.md
rename to bindings/python/rapier-testbed/README.md
index 9be559c8e..cdf373b76 100644
--- a/python/rapier-testbed/README.md
+++ b/bindings/python/rapier-testbed/README.md
@@ -14,11 +14,11 @@ pip install rapier-testbed
 From a checkout of the [Rapier repo](https://github.com/dimforge/rapier) (the
 engine packages aren't on PyPI yet — build them first, then install the testbed
 without re-resolving them). Run this **from the repository root** (the
-`./python/...` path is relative to it):
+`./bindings/python/...` path is relative to it):
 
 ```bash
 pip install panda3d numpy
-pip install --no-deps -e ./python/rapier-testbed   # -e: edits picked up without reinstalling
+pip install --no-deps -e ./bindings/python/rapier-testbed   # -e: edits picked up without reinstalling
 ```
 
 ## Run
diff --git a/python/rapier-testbed/pyproject.toml b/bindings/python/rapier-testbed/pyproject.toml
similarity index 100%
rename from python/rapier-testbed/pyproject.toml
rename to bindings/python/rapier-testbed/pyproject.toml
diff --git a/python/rapier-testbed/rapier_testbed/__init__.py b/bindings/python/rapier-testbed/rapier_testbed/__init__.py
similarity index 100%
rename from python/rapier-testbed/rapier_testbed/__init__.py
rename to bindings/python/rapier-testbed/rapier_testbed/__init__.py
diff --git a/python/rapier-testbed/rapier_testbed/__main__.py b/bindings/python/rapier-testbed/rapier_testbed/__main__.py
similarity index 100%
rename from python/rapier-testbed/rapier_testbed/__main__.py
rename to bindings/python/rapier-testbed/rapier_testbed/__main__.py
diff --git a/python/rapier-testbed/rapier_testbed/_meshes.py b/bindings/python/rapier-testbed/rapier_testbed/_meshes.py
similarity index 100%
rename from python/rapier-testbed/rapier_testbed/_meshes.py
rename to bindings/python/rapier-testbed/rapier_testbed/_meshes.py
diff --git a/python/rapier-testbed/rapier_testbed/_obj.py b/bindings/python/rapier-testbed/rapier_testbed/_obj.py
similarity index 100%
rename from python/rapier-testbed/rapier_testbed/_obj.py
rename to bindings/python/rapier-testbed/rapier_testbed/_obj.py
diff --git a/python/rapier-testbed/rapier_testbed/_picker.py b/bindings/python/rapier-testbed/rapier_testbed/_picker.py
similarity index 100%
rename from python/rapier-testbed/rapier_testbed/_picker.py
rename to bindings/python/rapier-testbed/rapier_testbed/_picker.py
diff --git a/python/rapier-testbed/rapier_testbed/_registry.py b/bindings/python/rapier-testbed/rapier_testbed/_registry.py
similarity index 100%
rename from python/rapier-testbed/rapier_testbed/_registry.py
rename to bindings/python/rapier-testbed/rapier_testbed/_registry.py
diff --git a/python/rapier-testbed/rapier_testbed/_testbed.py b/bindings/python/rapier-testbed/rapier_testbed/_testbed.py
similarity index 100%
rename from python/rapier-testbed/rapier_testbed/_testbed.py
rename to bindings/python/rapier-testbed/rapier_testbed/_testbed.py
diff --git a/python/rapier-testbed/rapier_testbed/examples3/__init__.py b/bindings/python/rapier-testbed/rapier_testbed/examples3/__init__.py
similarity index 100%
rename from python/rapier-testbed/rapier_testbed/examples3/__init__.py
rename to bindings/python/rapier-testbed/rapier_testbed/examples3/__init__.py
diff --git a/python/rapier-testbed/rapier_testbed/examples3/ccd3.py b/bindings/python/rapier-testbed/rapier_testbed/examples3/ccd3.py
similarity index 100%
rename from python/rapier-testbed/rapier_testbed/examples3/ccd3.py
rename to bindings/python/rapier-testbed/rapier_testbed/examples3/ccd3.py
diff --git a/python/rapier-testbed/rapier_testbed/examples3/character_controller3.py b/bindings/python/rapier-testbed/rapier_testbed/examples3/character_controller3.py
similarity index 100%
rename from python/rapier-testbed/rapier_testbed/examples3/character_controller3.py
rename to bindings/python/rapier-testbed/rapier_testbed/examples3/character_controller3.py
diff --git a/python/rapier-testbed/rapier_testbed/examples3/collision_groups3.py b/bindings/python/rapier-testbed/rapier_testbed/examples3/collision_groups3.py
similarity index 100%
rename from python/rapier-testbed/rapier_testbed/examples3/collision_groups3.py
rename to bindings/python/rapier-testbed/rapier_testbed/examples3/collision_groups3.py
diff --git a/python/rapier-testbed/rapier_testbed/examples3/compound3.py b/bindings/python/rapier-testbed/rapier_testbed/examples3/compound3.py
similarity index 100%
rename from python/rapier-testbed/rapier_testbed/examples3/compound3.py
rename to bindings/python/rapier-testbed/rapier_testbed/examples3/compound3.py
diff --git a/python/rapier-testbed/rapier_testbed/examples3/convex_decomposition3.py b/bindings/python/rapier-testbed/rapier_testbed/examples3/convex_decomposition3.py
similarity index 100%
rename from python/rapier-testbed/rapier_testbed/examples3/convex_decomposition3.py
rename to bindings/python/rapier-testbed/rapier_testbed/examples3/convex_decomposition3.py
diff --git a/python/rapier-testbed/rapier_testbed/examples3/convex_polyhedron3.py b/bindings/python/rapier-testbed/rapier_testbed/examples3/convex_polyhedron3.py
similarity index 100%
rename from python/rapier-testbed/rapier_testbed/examples3/convex_polyhedron3.py
rename to bindings/python/rapier-testbed/rapier_testbed/examples3/convex_polyhedron3.py
diff --git a/python/rapier-testbed/rapier_testbed/examples3/damping3.py b/bindings/python/rapier-testbed/rapier_testbed/examples3/damping3.py
similarity index 100%
rename from python/rapier-testbed/rapier_testbed/examples3/damping3.py
rename to bindings/python/rapier-testbed/rapier_testbed/examples3/damping3.py
diff --git a/python/rapier-testbed/rapier_testbed/examples3/domino3.py b/bindings/python/rapier-testbed/rapier_testbed/examples3/domino3.py
similarity index 100%
rename from python/rapier-testbed/rapier_testbed/examples3/domino3.py
rename to bindings/python/rapier-testbed/rapier_testbed/examples3/domino3.py
diff --git a/python/rapier-testbed/rapier_testbed/examples3/dynamic_trimesh3.py b/bindings/python/rapier-testbed/rapier_testbed/examples3/dynamic_trimesh3.py
similarity index 100%
rename from python/rapier-testbed/rapier_testbed/examples3/dynamic_trimesh3.py
rename to bindings/python/rapier-testbed/rapier_testbed/examples3/dynamic_trimesh3.py
diff --git a/python/rapier-testbed/rapier_testbed/examples3/fountain3.py b/bindings/python/rapier-testbed/rapier_testbed/examples3/fountain3.py
similarity index 100%
rename from python/rapier-testbed/rapier_testbed/examples3/fountain3.py
rename to bindings/python/rapier-testbed/rapier_testbed/examples3/fountain3.py
diff --git a/python/rapier-testbed/rapier_testbed/examples3/gyroscopic3.py b/bindings/python/rapier-testbed/rapier_testbed/examples3/gyroscopic3.py
similarity index 100%
rename from python/rapier-testbed/rapier_testbed/examples3/gyroscopic3.py
rename to bindings/python/rapier-testbed/rapier_testbed/examples3/gyroscopic3.py
diff --git a/python/rapier-testbed/rapier_testbed/examples3/harness_capsules3.py b/bindings/python/rapier-testbed/rapier_testbed/examples3/harness_capsules3.py
similarity index 100%
rename from python/rapier-testbed/rapier_testbed/examples3/harness_capsules3.py
rename to bindings/python/rapier-testbed/rapier_testbed/examples3/harness_capsules3.py
diff --git a/python/rapier-testbed/rapier_testbed/examples3/heightfield3.py b/bindings/python/rapier-testbed/rapier_testbed/examples3/heightfield3.py
similarity index 100%
rename from python/rapier-testbed/rapier_testbed/examples3/heightfield3.py
rename to bindings/python/rapier-testbed/rapier_testbed/examples3/heightfield3.py
diff --git a/python/rapier-testbed/rapier_testbed/examples3/inverse_kinematics3.py b/bindings/python/rapier-testbed/rapier_testbed/examples3/inverse_kinematics3.py
similarity index 100%
rename from python/rapier-testbed/rapier_testbed/examples3/inverse_kinematics3.py
rename to bindings/python/rapier-testbed/rapier_testbed/examples3/inverse_kinematics3.py
diff --git a/python/rapier-testbed/rapier_testbed/examples3/joint_motor_position3.py b/bindings/python/rapier-testbed/rapier_testbed/examples3/joint_motor_position3.py
similarity index 100%
rename from python/rapier-testbed/rapier_testbed/examples3/joint_motor_position3.py
rename to bindings/python/rapier-testbed/rapier_testbed/examples3/joint_motor_position3.py
diff --git a/python/rapier-testbed/rapier_testbed/examples3/joints3.py b/bindings/python/rapier-testbed/rapier_testbed/examples3/joints3.py
similarity index 100%
rename from python/rapier-testbed/rapier_testbed/examples3/joints3.py
rename to bindings/python/rapier-testbed/rapier_testbed/examples3/joints3.py
diff --git a/python/rapier-testbed/rapier_testbed/examples3/keva3.py b/bindings/python/rapier-testbed/rapier_testbed/examples3/keva3.py
similarity index 100%
rename from python/rapier-testbed/rapier_testbed/examples3/keva3.py
rename to bindings/python/rapier-testbed/rapier_testbed/examples3/keva3.py
diff --git a/python/rapier-testbed/rapier_testbed/examples3/locked_rotations3.py b/bindings/python/rapier-testbed/rapier_testbed/examples3/locked_rotations3.py
similarity index 100%
rename from python/rapier-testbed/rapier_testbed/examples3/locked_rotations3.py
rename to bindings/python/rapier-testbed/rapier_testbed/examples3/locked_rotations3.py
diff --git a/python/rapier-testbed/rapier_testbed/examples3/mjcf3.py b/bindings/python/rapier-testbed/rapier_testbed/examples3/mjcf3.py
similarity index 100%
rename from python/rapier-testbed/rapier_testbed/examples3/mjcf3.py
rename to bindings/python/rapier-testbed/rapier_testbed/examples3/mjcf3.py
diff --git a/python/rapier-testbed/rapier_testbed/examples3/newton_cradle3.py b/bindings/python/rapier-testbed/rapier_testbed/examples3/newton_cradle3.py
similarity index 100%
rename from python/rapier-testbed/rapier_testbed/examples3/newton_cradle3.py
rename to bindings/python/rapier-testbed/rapier_testbed/examples3/newton_cradle3.py
diff --git a/python/rapier-testbed/rapier_testbed/examples3/one_way_platforms3.py b/bindings/python/rapier-testbed/rapier_testbed/examples3/one_way_platforms3.py
similarity index 100%
rename from python/rapier-testbed/rapier_testbed/examples3/one_way_platforms3.py
rename to bindings/python/rapier-testbed/rapier_testbed/examples3/one_way_platforms3.py
diff --git a/python/rapier-testbed/rapier_testbed/examples3/platform3.py b/bindings/python/rapier-testbed/rapier_testbed/examples3/platform3.py
similarity index 100%
rename from python/rapier-testbed/rapier_testbed/examples3/platform3.py
rename to bindings/python/rapier-testbed/rapier_testbed/examples3/platform3.py
diff --git a/python/rapier-testbed/rapier_testbed/examples3/primitives3.py b/bindings/python/rapier-testbed/rapier_testbed/examples3/primitives3.py
similarity index 100%
rename from python/rapier-testbed/rapier_testbed/examples3/primitives3.py
rename to bindings/python/rapier-testbed/rapier_testbed/examples3/primitives3.py
diff --git a/python/rapier-testbed/rapier_testbed/examples3/restitution3.py b/bindings/python/rapier-testbed/rapier_testbed/examples3/restitution3.py
similarity index 100%
rename from python/rapier-testbed/rapier_testbed/examples3/restitution3.py
rename to bindings/python/rapier-testbed/rapier_testbed/examples3/restitution3.py
diff --git a/python/rapier-testbed/rapier_testbed/examples3/rope_joints3.py b/bindings/python/rapier-testbed/rapier_testbed/examples3/rope_joints3.py
similarity index 100%
rename from python/rapier-testbed/rapier_testbed/examples3/rope_joints3.py
rename to bindings/python/rapier-testbed/rapier_testbed/examples3/rope_joints3.py
diff --git a/python/rapier-testbed/rapier_testbed/examples3/sensor3.py b/bindings/python/rapier-testbed/rapier_testbed/examples3/sensor3.py
similarity index 100%
rename from python/rapier-testbed/rapier_testbed/examples3/sensor3.py
rename to bindings/python/rapier-testbed/rapier_testbed/examples3/sensor3.py
diff --git a/python/rapier-testbed/rapier_testbed/examples3/soft_bodies3.py b/bindings/python/rapier-testbed/rapier_testbed/examples3/soft_bodies3.py
similarity index 100%
rename from python/rapier-testbed/rapier_testbed/examples3/soft_bodies3.py
rename to bindings/python/rapier-testbed/rapier_testbed/examples3/soft_bodies3.py
diff --git a/python/rapier-testbed/rapier_testbed/examples3/soft_tearing3.py b/bindings/python/rapier-testbed/rapier_testbed/examples3/soft_tearing3.py
similarity index 100%
rename from python/rapier-testbed/rapier_testbed/examples3/soft_tearing3.py
rename to bindings/python/rapier-testbed/rapier_testbed/examples3/soft_tearing3.py
diff --git a/python/rapier-testbed/rapier_testbed/examples3/spring_joints3.py b/bindings/python/rapier-testbed/rapier_testbed/examples3/spring_joints3.py
similarity index 100%
rename from python/rapier-testbed/rapier_testbed/examples3/spring_joints3.py
rename to bindings/python/rapier-testbed/rapier_testbed/examples3/spring_joints3.py
diff --git a/python/rapier-testbed/rapier_testbed/examples3/stress_tests/__init__.py b/bindings/python/rapier-testbed/rapier_testbed/examples3/stress_tests/__init__.py
similarity index 100%
rename from python/rapier-testbed/rapier_testbed/examples3/stress_tests/__init__.py
rename to bindings/python/rapier-testbed/rapier_testbed/examples3/stress_tests/__init__.py
diff --git a/python/rapier-testbed/rapier_testbed/examples3/stress_tests/balls3.py b/bindings/python/rapier-testbed/rapier_testbed/examples3/stress_tests/balls3.py
similarity index 100%
rename from python/rapier-testbed/rapier_testbed/examples3/stress_tests/balls3.py
rename to bindings/python/rapier-testbed/rapier_testbed/examples3/stress_tests/balls3.py
diff --git a/python/rapier-testbed/rapier_testbed/examples3/stress_tests/boxes3.py b/bindings/python/rapier-testbed/rapier_testbed/examples3/stress_tests/boxes3.py
similarity index 100%
rename from python/rapier-testbed/rapier_testbed/examples3/stress_tests/boxes3.py
rename to bindings/python/rapier-testbed/rapier_testbed/examples3/stress_tests/boxes3.py
diff --git a/python/rapier-testbed/rapier_testbed/examples3/stress_tests/capsules3.py b/bindings/python/rapier-testbed/rapier_testbed/examples3/stress_tests/capsules3.py
similarity index 100%
rename from python/rapier-testbed/rapier_testbed/examples3/stress_tests/capsules3.py
rename to bindings/python/rapier-testbed/rapier_testbed/examples3/stress_tests/capsules3.py
diff --git a/python/rapier-testbed/rapier_testbed/examples3/stress_tests/ccd3.py b/bindings/python/rapier-testbed/rapier_testbed/examples3/stress_tests/ccd3.py
similarity index 100%
rename from python/rapier-testbed/rapier_testbed/examples3/stress_tests/ccd3.py
rename to bindings/python/rapier-testbed/rapier_testbed/examples3/stress_tests/ccd3.py
diff --git a/python/rapier-testbed/rapier_testbed/examples3/stress_tests/compound3.py b/bindings/python/rapier-testbed/rapier_testbed/examples3/stress_tests/compound3.py
similarity index 100%
rename from python/rapier-testbed/rapier_testbed/examples3/stress_tests/compound3.py
rename to bindings/python/rapier-testbed/rapier_testbed/examples3/stress_tests/compound3.py
diff --git a/python/rapier-testbed/rapier_testbed/examples3/stress_tests/convex_polyhedron3.py b/bindings/python/rapier-testbed/rapier_testbed/examples3/stress_tests/convex_polyhedron3.py
similarity index 100%
rename from python/rapier-testbed/rapier_testbed/examples3/stress_tests/convex_polyhedron3.py
rename to bindings/python/rapier-testbed/rapier_testbed/examples3/stress_tests/convex_polyhedron3.py
diff --git a/python/rapier-testbed/rapier_testbed/examples3/stress_tests/heightfield3.py b/bindings/python/rapier-testbed/rapier_testbed/examples3/stress_tests/heightfield3.py
similarity index 100%
rename from python/rapier-testbed/rapier_testbed/examples3/stress_tests/heightfield3.py
rename to bindings/python/rapier-testbed/rapier_testbed/examples3/stress_tests/heightfield3.py
diff --git a/python/rapier-testbed/rapier_testbed/examples3/stress_tests/joint_ball3.py b/bindings/python/rapier-testbed/rapier_testbed/examples3/stress_tests/joint_ball3.py
similarity index 100%
rename from python/rapier-testbed/rapier_testbed/examples3/stress_tests/joint_ball3.py
rename to bindings/python/rapier-testbed/rapier_testbed/examples3/stress_tests/joint_ball3.py
diff --git a/python/rapier-testbed/rapier_testbed/examples3/stress_tests/joint_fixed3.py b/bindings/python/rapier-testbed/rapier_testbed/examples3/stress_tests/joint_fixed3.py
similarity index 100%
rename from python/rapier-testbed/rapier_testbed/examples3/stress_tests/joint_fixed3.py
rename to bindings/python/rapier-testbed/rapier_testbed/examples3/stress_tests/joint_fixed3.py
diff --git a/python/rapier-testbed/rapier_testbed/examples3/stress_tests/joint_prismatic3.py b/bindings/python/rapier-testbed/rapier_testbed/examples3/stress_tests/joint_prismatic3.py
similarity index 100%
rename from python/rapier-testbed/rapier_testbed/examples3/stress_tests/joint_prismatic3.py
rename to bindings/python/rapier-testbed/rapier_testbed/examples3/stress_tests/joint_prismatic3.py
diff --git a/python/rapier-testbed/rapier_testbed/examples3/stress_tests/joint_revolute3.py b/bindings/python/rapier-testbed/rapier_testbed/examples3/stress_tests/joint_revolute3.py
similarity index 100%
rename from python/rapier-testbed/rapier_testbed/examples3/stress_tests/joint_revolute3.py
rename to bindings/python/rapier-testbed/rapier_testbed/examples3/stress_tests/joint_revolute3.py
diff --git a/python/rapier-testbed/rapier_testbed/examples3/stress_tests/keva3.py b/bindings/python/rapier-testbed/rapier_testbed/examples3/stress_tests/keva3.py
similarity index 100%
rename from python/rapier-testbed/rapier_testbed/examples3/stress_tests/keva3.py
rename to bindings/python/rapier-testbed/rapier_testbed/examples3/stress_tests/keva3.py
diff --git a/python/rapier-testbed/rapier_testbed/examples3/stress_tests/many_kinematics3.py b/bindings/python/rapier-testbed/rapier_testbed/examples3/stress_tests/many_kinematics3.py
similarity index 100%
rename from python/rapier-testbed/rapier_testbed/examples3/stress_tests/many_kinematics3.py
rename to bindings/python/rapier-testbed/rapier_testbed/examples3/stress_tests/many_kinematics3.py
diff --git a/python/rapier-testbed/rapier_testbed/examples3/stress_tests/many_pyramids3.py b/bindings/python/rapier-testbed/rapier_testbed/examples3/stress_tests/many_pyramids3.py
similarity index 100%
rename from python/rapier-testbed/rapier_testbed/examples3/stress_tests/many_pyramids3.py
rename to bindings/python/rapier-testbed/rapier_testbed/examples3/stress_tests/many_pyramids3.py
diff --git a/python/rapier-testbed/rapier_testbed/examples3/stress_tests/many_sleep3.py b/bindings/python/rapier-testbed/rapier_testbed/examples3/stress_tests/many_sleep3.py
similarity index 100%
rename from python/rapier-testbed/rapier_testbed/examples3/stress_tests/many_sleep3.py
rename to bindings/python/rapier-testbed/rapier_testbed/examples3/stress_tests/many_sleep3.py
diff --git a/python/rapier-testbed/rapier_testbed/examples3/stress_tests/many_static3.py b/bindings/python/rapier-testbed/rapier_testbed/examples3/stress_tests/many_static3.py
similarity index 100%
rename from python/rapier-testbed/rapier_testbed/examples3/stress_tests/many_static3.py
rename to bindings/python/rapier-testbed/rapier_testbed/examples3/stress_tests/many_static3.py
diff --git a/python/rapier-testbed/rapier_testbed/examples3/stress_tests/pyramid3.py b/bindings/python/rapier-testbed/rapier_testbed/examples3/stress_tests/pyramid3.py
similarity index 100%
rename from python/rapier-testbed/rapier_testbed/examples3/stress_tests/pyramid3.py
rename to bindings/python/rapier-testbed/rapier_testbed/examples3/stress_tests/pyramid3.py
diff --git a/python/rapier-testbed/rapier_testbed/examples3/stress_tests/ray_cast3.py b/bindings/python/rapier-testbed/rapier_testbed/examples3/stress_tests/ray_cast3.py
similarity index 100%
rename from python/rapier-testbed/rapier_testbed/examples3/stress_tests/ray_cast3.py
rename to bindings/python/rapier-testbed/rapier_testbed/examples3/stress_tests/ray_cast3.py
diff --git a/python/rapier-testbed/rapier_testbed/examples3/stress_tests/stacks3.py b/bindings/python/rapier-testbed/rapier_testbed/examples3/stress_tests/stacks3.py
similarity index 100%
rename from python/rapier-testbed/rapier_testbed/examples3/stress_tests/stacks3.py
rename to bindings/python/rapier-testbed/rapier_testbed/examples3/stress_tests/stacks3.py
diff --git a/python/rapier-testbed/rapier_testbed/examples3/stress_tests/trimesh3.py b/bindings/python/rapier-testbed/rapier_testbed/examples3/stress_tests/trimesh3.py
similarity index 100%
rename from python/rapier-testbed/rapier_testbed/examples3/stress_tests/trimesh3.py
rename to bindings/python/rapier-testbed/rapier_testbed/examples3/stress_tests/trimesh3.py
diff --git a/python/rapier-testbed/rapier_testbed/examples3/trimesh3.py b/bindings/python/rapier-testbed/rapier_testbed/examples3/trimesh3.py
similarity index 100%
rename from python/rapier-testbed/rapier_testbed/examples3/trimesh3.py
rename to bindings/python/rapier-testbed/rapier_testbed/examples3/trimesh3.py
diff --git a/python/rapier-testbed/rapier_testbed/examples3/urdf3.py b/bindings/python/rapier-testbed/rapier_testbed/examples3/urdf3.py
similarity index 100%
rename from python/rapier-testbed/rapier_testbed/examples3/urdf3.py
rename to bindings/python/rapier-testbed/rapier_testbed/examples3/urdf3.py
diff --git a/python/rapier-testbed/rapier_testbed/examples3/utils/__init__.py b/bindings/python/rapier-testbed/rapier_testbed/examples3/utils/__init__.py
similarity index 100%
rename from python/rapier-testbed/rapier_testbed/examples3/utils/__init__.py
rename to bindings/python/rapier-testbed/rapier_testbed/examples3/utils/__init__.py
diff --git a/python/rapier-testbed/rapier_testbed/examples3/utils/character.py b/bindings/python/rapier-testbed/rapier_testbed/examples3/utils/character.py
similarity index 100%
rename from python/rapier-testbed/rapier_testbed/examples3/utils/character.py
rename to bindings/python/rapier-testbed/rapier_testbed/examples3/utils/character.py
diff --git a/python/rapier-testbed/rapier_testbed/examples3/vehicle_controller3.py b/bindings/python/rapier-testbed/rapier_testbed/examples3/vehicle_controller3.py
similarity index 100%
rename from python/rapier-testbed/rapier_testbed/examples3/vehicle_controller3.py
rename to bindings/python/rapier-testbed/rapier_testbed/examples3/vehicle_controller3.py
diff --git a/python/rapier-testbed/rapier_testbed/examples3/vehicle_joints3.py b/bindings/python/rapier-testbed/rapier_testbed/examples3/vehicle_joints3.py
similarity index 100%
rename from python/rapier-testbed/rapier_testbed/examples3/vehicle_joints3.py
rename to bindings/python/rapier-testbed/rapier_testbed/examples3/vehicle_joints3.py
diff --git a/python/rapier-testbed/rapier_testbed/examples3/voxels3.py b/bindings/python/rapier-testbed/rapier_testbed/examples3/voxels3.py
similarity index 100%
rename from python/rapier-testbed/rapier_testbed/examples3/voxels3.py
rename to bindings/python/rapier-testbed/rapier_testbed/examples3/voxels3.py
diff --git a/python/tests/test_bodies_colliders.py b/bindings/python/tests/test_bodies_colliders.py
similarity index 100%
rename from python/tests/test_bodies_colliders.py
rename to bindings/python/tests/test_bodies_colliders.py
diff --git a/python/tests/test_controllers.py b/bindings/python/tests/test_controllers.py
similarity index 100%
rename from python/tests/test_controllers.py
rename to bindings/python/tests/test_controllers.py
diff --git a/python/tests/test_debug_render.py b/bindings/python/tests/test_debug_render.py
similarity index 100%
rename from python/tests/test_debug_render.py
rename to bindings/python/tests/test_debug_render.py
diff --git a/python/tests/test_deferred_bindings.py b/bindings/python/tests/test_deferred_bindings.py
similarity index 100%
rename from python/tests/test_deferred_bindings.py
rename to bindings/python/tests/test_deferred_bindings.py
diff --git a/python/tests/test_dynamics.py b/bindings/python/tests/test_dynamics.py
similarity index 100%
rename from python/tests/test_dynamics.py
rename to bindings/python/tests/test_dynamics.py
diff --git a/python/tests/test_events_hooks.py b/bindings/python/tests/test_events_hooks.py
similarity index 100%
rename from python/tests/test_events_hooks.py
rename to bindings/python/tests/test_events_hooks.py
diff --git a/python/tests/test_examples.py b/bindings/python/tests/test_examples.py
similarity index 100%
rename from python/tests/test_examples.py
rename to bindings/python/tests/test_examples.py
diff --git a/python/tests/test_geometry.py b/bindings/python/tests/test_geometry.py
similarity index 100%
rename from python/tests/test_geometry.py
rename to bindings/python/tests/test_geometry.py
diff --git a/python/tests/test_joints.py b/bindings/python/tests/test_joints.py
similarity index 100%
rename from python/tests/test_joints.py
rename to bindings/python/tests/test_joints.py
diff --git a/python/tests/test_loaders.py b/bindings/python/tests/test_loaders.py
similarity index 100%
rename from python/tests/test_loaders.py
rename to bindings/python/tests/test_loaders.py
diff --git a/python/tests/test_math.py b/bindings/python/tests/test_math.py
similarity index 100%
rename from python/tests/test_math.py
rename to bindings/python/tests/test_math.py
diff --git a/python/tests/test_multibody.py b/bindings/python/tests/test_multibody.py
similarity index 100%
rename from python/tests/test_multibody.py
rename to bindings/python/tests/test_multibody.py
diff --git a/python/tests/test_new_bindings.py b/bindings/python/tests/test_new_bindings.py
similarity index 100%
rename from python/tests/test_new_bindings.py
rename to bindings/python/tests/test_new_bindings.py
diff --git a/python/tests/test_obj_loader.py b/bindings/python/tests/test_obj_loader.py
similarity index 94%
rename from python/tests/test_obj_loader.py
rename to bindings/python/tests/test_obj_loader.py
index ee206020f..60fdf75d7 100644
--- a/python/tests/test_obj_loader.py
+++ b/bindings/python/tests/test_obj_loader.py
@@ -1,7 +1,7 @@
 """Tests for the testbed's minimal OBJ loader (``rapier_testbed._obj``).
 
 Skipped unless the testbed package is installed (it isn't part of the engine
-test flow); install with ``pip install --no-deps -e ./python/rapier-testbed``.
+test flow); install with ``pip install --no-deps -e ./bindings/python/rapier-testbed``.
 """
 import numpy as np
 import pytest
diff --git a/python/tests/test_pipeline.py b/bindings/python/tests/test_pipeline.py
similarity index 100%
rename from python/tests/test_pipeline.py
rename to bindings/python/tests/test_pipeline.py
diff --git a/python/tests/test_proxy_persistence.py b/bindings/python/tests/test_proxy_persistence.py
similarity index 100%
rename from python/tests/test_proxy_persistence.py
rename to bindings/python/tests/test_proxy_persistence.py
diff --git a/python/tests/test_queries.py b/bindings/python/tests/test_queries.py
similarity index 100%
rename from python/tests/test_queries.py
rename to bindings/python/tests/test_queries.py
diff --git a/python/tests/test_serde.py b/bindings/python/tests/test_serde.py
similarity index 100%
rename from python/tests/test_serde.py
rename to bindings/python/tests/test_serde.py
diff --git a/python/tests/test_shapes.py b/bindings/python/tests/test_shapes.py
similarity index 100%
rename from python/tests/test_shapes.py
rename to bindings/python/tests/test_shapes.py
diff --git a/python/tests/test_smoke.py b/bindings/python/tests/test_smoke.py
similarity index 100%
rename from python/tests/test_smoke.py
rename to bindings/python/tests/test_smoke.py
diff --git a/python/tests/test_soft_bodies.py b/bindings/python/tests/test_soft_bodies.py
similarity index 100%
rename from python/tests/test_soft_bodies.py
rename to bindings/python/tests/test_soft_bodies.py
diff --git a/python/tests/test_stubs.py b/bindings/python/tests/test_stubs.py
similarity index 100%
rename from python/tests/test_stubs.py
rename to bindings/python/tests/test_stubs.py
diff --git a/python/tests/test_world.py b/bindings/python/tests/test_world.py
similarity index 100%
rename from python/tests/test_world.py
rename to bindings/python/tests/test_world.py
diff --git a/typescript/.gitignore b/bindings/typescript/.gitignore
similarity index 100%
rename from typescript/.gitignore
rename to bindings/typescript/.gitignore
diff --git a/typescript/.prettierignore b/bindings/typescript/.prettierignore
similarity index 100%
rename from typescript/.prettierignore
rename to bindings/typescript/.prettierignore
diff --git a/typescript/.prettierrc b/bindings/typescript/.prettierrc
similarity index 100%
rename from typescript/.prettierrc
rename to bindings/typescript/.prettierrc
diff --git a/typescript/CHANGELOG.md b/bindings/typescript/CHANGELOG.md
similarity index 100%
rename from typescript/CHANGELOG.md
rename to bindings/typescript/CHANGELOG.md
diff --git a/typescript/Cargo.toml b/bindings/typescript/Cargo.toml
similarity index 83%
rename from typescript/Cargo.toml
rename to bindings/typescript/Cargo.toml
index d7a8b8b40..d4ea70a89 100644
--- a/typescript/Cargo.toml
+++ b/bindings/typescript/Cargo.toml
@@ -14,11 +14,11 @@ strip = true # Workaround for https://github.com/bevyengine/bevy/issues/16030 (t
 # with the engine they ship alongside. The build crates' `rapier{2,3}d`
 # dependency requirement (see builds/prepare_builds/templates/Cargo.toml.tera)
 # must stay semver-compatible with the in-repo crate version for this to apply.
-rapier2d = { path = "../crates/rapier2d" }
-rapier3d = { path = "../crates/rapier3d" }
+rapier2d = { path = "../../crates/rapier2d" }
+rapier3d = { path = "../../crates/rapier3d" }
 
 # nalgebra and simba are still pulled from crates.io, matching the versions the
 # in-repo rapier crates depend on. Uncomment to build against local checkouts
 # placed next to this repository during development.
-#nalgebra = { path = "../../nalgebra" }
-#simba = { path = "../../simba" }
+#nalgebra = { path = "../../../nalgebra" }
+#simba = { path = "../../../simba" }
diff --git a/typescript/LICENSE b/bindings/typescript/LICENSE
similarity index 100%
rename from typescript/LICENSE
rename to bindings/typescript/LICENSE
diff --git a/typescript/README.md b/bindings/typescript/README.md
similarity index 84%
rename from typescript/README.md
rename to bindings/typescript/README.md
index d04cc4bf4..69d74d9c4 100644
--- a/typescript/README.md
+++ b/bindings/typescript/README.md
@@ -5,8 +5,8 @@
     <a href="https://discord.gg/vt9DJSW">
         <img src="https://img.shields.io/discord/507548572338880513.svg?logo=discord&colorB=7289DA">
     </a>
-    <a href="https://github.com/dimforge/rapier.js/actions">
-        <img src="https://github.com/dimforge/rapier.js/workflows/main/badge.svg" alt="Build status">
+    <a href="https://github.com/dimforge/rapier/actions/workflows/typescript-bindings.yml">
+        <img src="https://github.com/dimforge/rapier/actions/workflows/typescript-bindings.yml/badge.svg" alt="Build status">
     </a>
     <a href="https://opensource.org/licenses/Apache-2.0">
         <img src="https://img.shields.io/badge/License-Apache%202.0-blue.svg">
@@ -15,8 +15,8 @@
 <p align = "center">
     <strong>
         <a href="https://rapier.rs">Website</a> | <a href="https://rapier.rs/docs/">Documentation</a> |
-        <a href="https://github.com/dimforge/rapier.js/tree/master/testbed2d/src/demos">2D examples (sources)</a> | 
-        <a href="https://github.com/dimforge/rapier.js/tree/master/testbed3d/src/demos">3D examples (sources)</a>
+        <a href="https://github.com/dimforge/rapier/tree/master/bindings/typescript/testbed2d/src/demos">2D examples (sources)</a> | 
+        <a href="https://github.com/dimforge/rapier/tree/master/bindings/typescript/testbed3d/src/demos">3D examples (sources)</a>
     </strong>
 </p>
 
@@ -31,7 +31,7 @@
 
 ## Building packages manually
 
-From the root of the repository, run:
+From the `bindings/typescript` directory of the repository, run:
 
 ```shell
 ./builds/prepare_builds/prepare_all_projects.sh
@@ -76,7 +76,7 @@ Just append `-compat` to the build you are interested in:
 
 ## Nightly builds
 
-Each time a new Pull Request is merged to the `main` branch of the [`rapier.js` repository](https://github.com/dimforge/rapier.js),
+Each time a new Pull Request is merged to the `master` branch of the [`rapier` repository](https://github.com/dimforge/rapier),
 an automatic _canary_ build is triggered. Builds published to npmjs under the _canary_ tag does not come with any
 stability guarantee and does not follow semver versioning. But it can be a useful solution to try out the latest
 features until a proper release is cut.
\ No newline at end of file
diff --git a/typescript/builds/prepare_builds/Cargo.toml b/bindings/typescript/builds/prepare_builds/Cargo.toml
similarity index 100%
rename from typescript/builds/prepare_builds/Cargo.toml
rename to bindings/typescript/builds/prepare_builds/Cargo.toml
diff --git a/typescript/builds/prepare_builds/README.md b/bindings/typescript/builds/prepare_builds/README.md
similarity index 100%
rename from typescript/builds/prepare_builds/README.md
rename to bindings/typescript/builds/prepare_builds/README.md
diff --git a/typescript/builds/prepare_builds/build_all_projects.sh b/bindings/typescript/builds/prepare_builds/build_all_projects.sh
similarity index 100%
rename from typescript/builds/prepare_builds/build_all_projects.sh
rename to bindings/typescript/builds/prepare_builds/build_all_projects.sh
diff --git a/typescript/builds/prepare_builds/prepare_all_projects.sh b/bindings/typescript/builds/prepare_builds/prepare_all_projects.sh
similarity index 100%
rename from typescript/builds/prepare_builds/prepare_all_projects.sh
rename to bindings/typescript/builds/prepare_builds/prepare_all_projects.sh
diff --git a/typescript/builds/prepare_builds/src/main.rs b/bindings/typescript/builds/prepare_builds/src/main.rs
similarity index 100%
rename from typescript/builds/prepare_builds/src/main.rs
rename to bindings/typescript/builds/prepare_builds/src/main.rs
diff --git a/typescript/builds/prepare_builds/templates/Cargo.toml.tera b/bindings/typescript/builds/prepare_builds/templates/Cargo.toml.tera
similarity index 100%
rename from typescript/builds/prepare_builds/templates/Cargo.toml.tera
rename to bindings/typescript/builds/prepare_builds/templates/Cargo.toml.tera
diff --git a/typescript/builds/prepare_builds/templates/LICENSE b/bindings/typescript/builds/prepare_builds/templates/LICENSE
similarity index 100%
rename from typescript/builds/prepare_builds/templates/LICENSE
rename to bindings/typescript/builds/prepare_builds/templates/LICENSE
diff --git a/typescript/builds/prepare_builds/templates/README.md.tera b/bindings/typescript/builds/prepare_builds/templates/README.md.tera
similarity index 90%
rename from typescript/builds/prepare_builds/templates/README.md.tera
rename to bindings/typescript/builds/prepare_builds/templates/README.md.tera
index 3455eab2b..8262fb9f0 100644
--- a/typescript/builds/prepare_builds/templates/README.md.tera
+++ b/bindings/typescript/builds/prepare_builds/templates/README.md.tera
@@ -5,8 +5,8 @@
     <a href="https://discord.gg/vt9DJSW">
         <img src="https://img.shields.io/discord/507548572338880513.svg?logo=discord&colorB=7289DA">
     </a>
-    <a href="https://github.com/dimforge/rapier.js/actions">
-        <img src="https://github.com/dimforge/rapier.js/workflows/main/badge.svg" alt="Build status">
+    <a href="https://github.com/dimforge/rapier/actions/workflows/typescript-bindings.yml">
+        <img src="https://github.com/dimforge/rapier/actions/workflows/typescript-bindings.yml/badge.svg" alt="Build status">
     </a>
     <a href="https://crates.io/crates/rapier{{ dimension }}d">
          <img src="https://img.shields.io/crates/v/rapier{{ dimension }}d.svg?style=flat-square" alt="crates.io">
@@ -64,7 +64,7 @@ Just append `-compat` to the build you are interested in:
 
 ## Nightly builds
 
-Each time a new Pull Request is merged to the `main` branch of the [`rapier.js` repository](https://github.com/dimforge/rapier.js),
+Each time a new Pull Request is merged to the `master` branch of the [`rapier` repository](https://github.com/dimforge/rapier),
 an automatic _canary_ build is triggered. Builds published to npmjs under the _canary_ tag does not come with any
 stability guarantee and does not follow semver versioning. But it can be a useful solution to try out the latest
 features until a proper release is cut.
\ No newline at end of file
diff --git a/typescript/builds/prepare_builds/templates/build_rust.sh.tera b/bindings/typescript/builds/prepare_builds/templates/build_rust.sh.tera
similarity index 100%
rename from typescript/builds/prepare_builds/templates/build_rust.sh.tera
rename to bindings/typescript/builds/prepare_builds/templates/build_rust.sh.tera
diff --git a/typescript/builds/prepare_builds/templates/build_typescript.sh.tera b/bindings/typescript/builds/prepare_builds/templates/build_typescript.sh.tera
similarity index 100%
rename from typescript/builds/prepare_builds/templates/build_typescript.sh.tera
rename to bindings/typescript/builds/prepare_builds/templates/build_typescript.sh.tera
diff --git a/typescript/builds/prepare_builds/templates/package.json.tera b/bindings/typescript/builds/prepare_builds/templates/package.json.tera
similarity index 100%
rename from typescript/builds/prepare_builds/templates/package.json.tera
rename to bindings/typescript/builds/prepare_builds/templates/package.json.tera
diff --git a/typescript/builds/prepare_builds/templates/tsconfig.json b/bindings/typescript/builds/prepare_builds/templates/tsconfig.json
similarity index 100%
rename from typescript/builds/prepare_builds/templates/tsconfig.json
rename to bindings/typescript/builds/prepare_builds/templates/tsconfig.json
diff --git a/typescript/builds/prepare_builds/templates/tsconfig_typedoc.json b/bindings/typescript/builds/prepare_builds/templates/tsconfig_typedoc.json
similarity index 100%
rename from typescript/builds/prepare_builds/templates/tsconfig_typedoc.json
rename to bindings/typescript/builds/prepare_builds/templates/tsconfig_typedoc.json
diff --git a/typescript/builds/prepare_builds/templates/typedoc.json.tera b/bindings/typescript/builds/prepare_builds/templates/typedoc.json.tera
similarity index 100%
rename from typescript/builds/prepare_builds/templates/typedoc.json.tera
rename to bindings/typescript/builds/prepare_builds/templates/typedoc.json.tera
diff --git a/typescript/package-lock.json b/bindings/typescript/package-lock.json
similarity index 100%
rename from typescript/package-lock.json
rename to bindings/typescript/package-lock.json
diff --git a/typescript/package.json b/bindings/typescript/package.json
similarity index 100%
rename from typescript/package.json
rename to bindings/typescript/package.json
diff --git a/typescript/publish_all_canary.sh b/bindings/typescript/publish_all_canary.sh
similarity index 100%
rename from typescript/publish_all_canary.sh
rename to bindings/typescript/publish_all_canary.sh
diff --git a/typescript/publish_all_prod.sh b/bindings/typescript/publish_all_prod.sh
similarity index 100%
rename from typescript/publish_all_prod.sh
rename to bindings/typescript/publish_all_prod.sh
diff --git a/typescript/rapier-compat/README.md b/bindings/typescript/rapier-compat/README.md
similarity index 100%
rename from typescript/rapier-compat/README.md
rename to bindings/typescript/rapier-compat/README.md
diff --git a/typescript/rapier-compat/build-rust.sh b/bindings/typescript/rapier-compat/build-rust.sh
similarity index 100%
rename from typescript/rapier-compat/build-rust.sh
rename to bindings/typescript/rapier-compat/build-rust.sh
diff --git a/typescript/rapier-compat/fix_raw_file.sh b/bindings/typescript/rapier-compat/fix_raw_file.sh
similarity index 100%
rename from typescript/rapier-compat/fix_raw_file.sh
rename to bindings/typescript/rapier-compat/fix_raw_file.sh
diff --git a/typescript/rapier-compat/gen_src.sh b/bindings/typescript/rapier-compat/gen_src.sh
similarity index 100%
rename from typescript/rapier-compat/gen_src.sh
rename to bindings/typescript/rapier-compat/gen_src.sh
diff --git a/typescript/rapier-compat/package-lock.json b/bindings/typescript/rapier-compat/package-lock.json
similarity index 100%
rename from typescript/rapier-compat/package-lock.json
rename to bindings/typescript/rapier-compat/package-lock.json
diff --git a/typescript/rapier-compat/package.json b/bindings/typescript/rapier-compat/package.json
similarity index 100%
rename from typescript/rapier-compat/package.json
rename to bindings/typescript/rapier-compat/package.json
diff --git a/typescript/rapier-compat/rollup.config.js b/bindings/typescript/rapier-compat/rollup.config.js
similarity index 100%
rename from typescript/rapier-compat/rollup.config.js
rename to bindings/typescript/rapier-compat/rollup.config.js
diff --git a/typescript/rapier-compat/src2d/init.ts b/bindings/typescript/rapier-compat/src2d/init.ts
similarity index 100%
rename from typescript/rapier-compat/src2d/init.ts
rename to bindings/typescript/rapier-compat/src2d/init.ts
diff --git a/typescript/rapier-compat/src2d/raw.ts b/bindings/typescript/rapier-compat/src2d/raw.ts
similarity index 100%
rename from typescript/rapier-compat/src2d/raw.ts
rename to bindings/typescript/rapier-compat/src2d/raw.ts
diff --git a/typescript/rapier-compat/src3d/init.ts b/bindings/typescript/rapier-compat/src3d/init.ts
similarity index 100%
rename from typescript/rapier-compat/src3d/init.ts
rename to bindings/typescript/rapier-compat/src3d/init.ts
diff --git a/typescript/rapier-compat/src3d/raw.ts b/bindings/typescript/rapier-compat/src3d/raw.ts
similarity index 100%
rename from typescript/rapier-compat/src3d/raw.ts
rename to bindings/typescript/rapier-compat/src3d/raw.ts
diff --git a/typescript/rapier-compat/tests/World2d.test.ts b/bindings/typescript/rapier-compat/tests/World2d.test.ts
similarity index 100%
rename from typescript/rapier-compat/tests/World2d.test.ts
rename to bindings/typescript/rapier-compat/tests/World2d.test.ts
diff --git a/typescript/rapier-compat/tests/World3d.test.ts b/bindings/typescript/rapier-compat/tests/World3d.test.ts
similarity index 100%
rename from typescript/rapier-compat/tests/World3d.test.ts
rename to bindings/typescript/rapier-compat/tests/World3d.test.ts
diff --git a/typescript/rapier-compat/tests/math2d.test.ts b/bindings/typescript/rapier-compat/tests/math2d.test.ts
similarity index 100%
rename from typescript/rapier-compat/tests/math2d.test.ts
rename to bindings/typescript/rapier-compat/tests/math2d.test.ts
diff --git a/typescript/rapier-compat/tests/math3d.test.ts b/bindings/typescript/rapier-compat/tests/math3d.test.ts
similarity index 100%
rename from typescript/rapier-compat/tests/math3d.test.ts
rename to bindings/typescript/rapier-compat/tests/math3d.test.ts
diff --git a/typescript/rapier-compat/tsconfig.common.json b/bindings/typescript/rapier-compat/tsconfig.common.json
similarity index 100%
rename from typescript/rapier-compat/tsconfig.common.json
rename to bindings/typescript/rapier-compat/tsconfig.common.json
diff --git a/typescript/rapier-compat/tsconfig.json b/bindings/typescript/rapier-compat/tsconfig.json
similarity index 100%
rename from typescript/rapier-compat/tsconfig.json
rename to bindings/typescript/rapier-compat/tsconfig.json
diff --git a/typescript/rapier-compat/tsconfig.pkg2d.json b/bindings/typescript/rapier-compat/tsconfig.pkg2d.json
similarity index 100%
rename from typescript/rapier-compat/tsconfig.pkg2d.json
rename to bindings/typescript/rapier-compat/tsconfig.pkg2d.json
diff --git a/typescript/rapier-compat/tsconfig.pkg3d.json b/bindings/typescript/rapier-compat/tsconfig.pkg3d.json
similarity index 100%
rename from typescript/rapier-compat/tsconfig.pkg3d.json
rename to bindings/typescript/rapier-compat/tsconfig.pkg3d.json
diff --git a/typescript/src.ts/coarena.ts b/bindings/typescript/src.ts/coarena.ts
similarity index 100%
rename from typescript/src.ts/coarena.ts
rename to bindings/typescript/src.ts/coarena.ts
diff --git a/typescript/src.ts/control/character_controller.ts b/bindings/typescript/src.ts/control/character_controller.ts
similarity index 100%
rename from typescript/src.ts/control/character_controller.ts
rename to bindings/typescript/src.ts/control/character_controller.ts
diff --git a/typescript/src.ts/control/index.ts b/bindings/typescript/src.ts/control/index.ts
similarity index 100%
rename from typescript/src.ts/control/index.ts
rename to bindings/typescript/src.ts/control/index.ts
diff --git a/typescript/src.ts/control/pid_controller.ts b/bindings/typescript/src.ts/control/pid_controller.ts
similarity index 100%
rename from typescript/src.ts/control/pid_controller.ts
rename to bindings/typescript/src.ts/control/pid_controller.ts
diff --git a/typescript/src.ts/control/ray_cast_vehicle_controller.ts b/bindings/typescript/src.ts/control/ray_cast_vehicle_controller.ts
similarity index 100%
rename from typescript/src.ts/control/ray_cast_vehicle_controller.ts
rename to bindings/typescript/src.ts/control/ray_cast_vehicle_controller.ts
diff --git a/typescript/src.ts/dynamics/ccd_solver.ts b/bindings/typescript/src.ts/dynamics/ccd_solver.ts
similarity index 100%
rename from typescript/src.ts/dynamics/ccd_solver.ts
rename to bindings/typescript/src.ts/dynamics/ccd_solver.ts
diff --git a/typescript/src.ts/dynamics/coefficient_combine_rule.ts b/bindings/typescript/src.ts/dynamics/coefficient_combine_rule.ts
similarity index 100%
rename from typescript/src.ts/dynamics/coefficient_combine_rule.ts
rename to bindings/typescript/src.ts/dynamics/coefficient_combine_rule.ts
diff --git a/typescript/src.ts/dynamics/impulse_joint.ts b/bindings/typescript/src.ts/dynamics/impulse_joint.ts
similarity index 100%
rename from typescript/src.ts/dynamics/impulse_joint.ts
rename to bindings/typescript/src.ts/dynamics/impulse_joint.ts
diff --git a/typescript/src.ts/dynamics/impulse_joint_set.ts b/bindings/typescript/src.ts/dynamics/impulse_joint_set.ts
similarity index 100%
rename from typescript/src.ts/dynamics/impulse_joint_set.ts
rename to bindings/typescript/src.ts/dynamics/impulse_joint_set.ts
diff --git a/typescript/src.ts/dynamics/index.ts b/bindings/typescript/src.ts/dynamics/index.ts
similarity index 100%
rename from typescript/src.ts/dynamics/index.ts
rename to bindings/typescript/src.ts/dynamics/index.ts
diff --git a/typescript/src.ts/dynamics/integration_parameters.ts b/bindings/typescript/src.ts/dynamics/integration_parameters.ts
similarity index 100%
rename from typescript/src.ts/dynamics/integration_parameters.ts
rename to bindings/typescript/src.ts/dynamics/integration_parameters.ts
diff --git a/typescript/src.ts/dynamics/island_manager.ts b/bindings/typescript/src.ts/dynamics/island_manager.ts
similarity index 100%
rename from typescript/src.ts/dynamics/island_manager.ts
rename to bindings/typescript/src.ts/dynamics/island_manager.ts
diff --git a/typescript/src.ts/dynamics/multibody_joint.ts b/bindings/typescript/src.ts/dynamics/multibody_joint.ts
similarity index 100%
rename from typescript/src.ts/dynamics/multibody_joint.ts
rename to bindings/typescript/src.ts/dynamics/multibody_joint.ts
diff --git a/typescript/src.ts/dynamics/multibody_joint_set.ts b/bindings/typescript/src.ts/dynamics/multibody_joint_set.ts
similarity index 100%
rename from typescript/src.ts/dynamics/multibody_joint_set.ts
rename to bindings/typescript/src.ts/dynamics/multibody_joint_set.ts
diff --git a/typescript/src.ts/dynamics/rigid_body.ts b/bindings/typescript/src.ts/dynamics/rigid_body.ts
similarity index 100%
rename from typescript/src.ts/dynamics/rigid_body.ts
rename to bindings/typescript/src.ts/dynamics/rigid_body.ts
diff --git a/typescript/src.ts/dynamics/rigid_body_set.ts b/bindings/typescript/src.ts/dynamics/rigid_body_set.ts
similarity index 100%
rename from typescript/src.ts/dynamics/rigid_body_set.ts
rename to bindings/typescript/src.ts/dynamics/rigid_body_set.ts
diff --git a/typescript/src.ts/dynamics/soft_body.ts b/bindings/typescript/src.ts/dynamics/soft_body.ts
similarity index 100%
rename from typescript/src.ts/dynamics/soft_body.ts
rename to bindings/typescript/src.ts/dynamics/soft_body.ts
diff --git a/typescript/src.ts/dynamics/soft_body_set.ts b/bindings/typescript/src.ts/dynamics/soft_body_set.ts
similarity index 100%
rename from typescript/src.ts/dynamics/soft_body_set.ts
rename to bindings/typescript/src.ts/dynamics/soft_body_set.ts
diff --git a/typescript/src.ts/exports.ts b/bindings/typescript/src.ts/exports.ts
similarity index 100%
rename from typescript/src.ts/exports.ts
rename to bindings/typescript/src.ts/exports.ts
diff --git a/typescript/src.ts/geometry/broad_phase.ts b/bindings/typescript/src.ts/geometry/broad_phase.ts
similarity index 100%
rename from typescript/src.ts/geometry/broad_phase.ts
rename to bindings/typescript/src.ts/geometry/broad_phase.ts
diff --git a/typescript/src.ts/geometry/collider.ts b/bindings/typescript/src.ts/geometry/collider.ts
similarity index 100%
rename from typescript/src.ts/geometry/collider.ts
rename to bindings/typescript/src.ts/geometry/collider.ts
diff --git a/typescript/src.ts/geometry/collider_set.ts b/bindings/typescript/src.ts/geometry/collider_set.ts
similarity index 100%
rename from typescript/src.ts/geometry/collider_set.ts
rename to bindings/typescript/src.ts/geometry/collider_set.ts
diff --git a/typescript/src.ts/geometry/contact.ts b/bindings/typescript/src.ts/geometry/contact.ts
similarity index 100%
rename from typescript/src.ts/geometry/contact.ts
rename to bindings/typescript/src.ts/geometry/contact.ts
diff --git a/typescript/src.ts/geometry/feature.ts b/bindings/typescript/src.ts/geometry/feature.ts
similarity index 100%
rename from typescript/src.ts/geometry/feature.ts
rename to bindings/typescript/src.ts/geometry/feature.ts
diff --git a/typescript/src.ts/geometry/index.ts b/bindings/typescript/src.ts/geometry/index.ts
similarity index 100%
rename from typescript/src.ts/geometry/index.ts
rename to bindings/typescript/src.ts/geometry/index.ts
diff --git a/typescript/src.ts/geometry/interaction_groups.ts b/bindings/typescript/src.ts/geometry/interaction_groups.ts
similarity index 100%
rename from typescript/src.ts/geometry/interaction_groups.ts
rename to bindings/typescript/src.ts/geometry/interaction_groups.ts
diff --git a/typescript/src.ts/geometry/narrow_phase.ts b/bindings/typescript/src.ts/geometry/narrow_phase.ts
similarity index 100%
rename from typescript/src.ts/geometry/narrow_phase.ts
rename to bindings/typescript/src.ts/geometry/narrow_phase.ts
diff --git a/typescript/src.ts/geometry/point.ts b/bindings/typescript/src.ts/geometry/point.ts
similarity index 100%
rename from typescript/src.ts/geometry/point.ts
rename to bindings/typescript/src.ts/geometry/point.ts
diff --git a/typescript/src.ts/geometry/ray.ts b/bindings/typescript/src.ts/geometry/ray.ts
similarity index 100%
rename from typescript/src.ts/geometry/ray.ts
rename to bindings/typescript/src.ts/geometry/ray.ts
diff --git a/typescript/src.ts/geometry/shape.ts b/bindings/typescript/src.ts/geometry/shape.ts
similarity index 100%
rename from typescript/src.ts/geometry/shape.ts
rename to bindings/typescript/src.ts/geometry/shape.ts
diff --git a/typescript/src.ts/geometry/toi.ts b/bindings/typescript/src.ts/geometry/toi.ts
similarity index 100%
rename from typescript/src.ts/geometry/toi.ts
rename to bindings/typescript/src.ts/geometry/toi.ts
diff --git a/typescript/src.ts/init.ts b/bindings/typescript/src.ts/init.ts
similarity index 100%
rename from typescript/src.ts/init.ts
rename to bindings/typescript/src.ts/init.ts
diff --git a/typescript/src.ts/math.ts b/bindings/typescript/src.ts/math.ts
similarity index 100%
rename from typescript/src.ts/math.ts
rename to bindings/typescript/src.ts/math.ts
diff --git a/typescript/src.ts/pipeline/debug_render_pipeline.ts b/bindings/typescript/src.ts/pipeline/debug_render_pipeline.ts
similarity index 100%
rename from typescript/src.ts/pipeline/debug_render_pipeline.ts
rename to bindings/typescript/src.ts/pipeline/debug_render_pipeline.ts
diff --git a/typescript/src.ts/pipeline/event_queue.ts b/bindings/typescript/src.ts/pipeline/event_queue.ts
similarity index 100%
rename from typescript/src.ts/pipeline/event_queue.ts
rename to bindings/typescript/src.ts/pipeline/event_queue.ts
diff --git a/typescript/src.ts/pipeline/index.ts b/bindings/typescript/src.ts/pipeline/index.ts
similarity index 100%
rename from typescript/src.ts/pipeline/index.ts
rename to bindings/typescript/src.ts/pipeline/index.ts
diff --git a/typescript/src.ts/pipeline/physics_hooks.ts b/bindings/typescript/src.ts/pipeline/physics_hooks.ts
similarity index 100%
rename from typescript/src.ts/pipeline/physics_hooks.ts
rename to bindings/typescript/src.ts/pipeline/physics_hooks.ts
diff --git a/typescript/src.ts/pipeline/physics_pipeline.ts b/bindings/typescript/src.ts/pipeline/physics_pipeline.ts
similarity index 100%
rename from typescript/src.ts/pipeline/physics_pipeline.ts
rename to bindings/typescript/src.ts/pipeline/physics_pipeline.ts
diff --git a/typescript/src.ts/pipeline/query_pipeline.ts b/bindings/typescript/src.ts/pipeline/query_pipeline.ts
similarity index 100%
rename from typescript/src.ts/pipeline/query_pipeline.ts
rename to bindings/typescript/src.ts/pipeline/query_pipeline.ts
diff --git a/typescript/src.ts/pipeline/serialization_pipeline.ts b/bindings/typescript/src.ts/pipeline/serialization_pipeline.ts
similarity index 100%
rename from typescript/src.ts/pipeline/serialization_pipeline.ts
rename to bindings/typescript/src.ts/pipeline/serialization_pipeline.ts
diff --git a/typescript/src.ts/pipeline/world.ts b/bindings/typescript/src.ts/pipeline/world.ts
similarity index 100%
rename from typescript/src.ts/pipeline/world.ts
rename to bindings/typescript/src.ts/pipeline/world.ts
diff --git a/typescript/src.ts/rapier.ts b/bindings/typescript/src.ts/rapier.ts
similarity index 100%
rename from typescript/src.ts/rapier.ts
rename to bindings/typescript/src.ts/rapier.ts
diff --git a/typescript/src.ts/raw.ts b/bindings/typescript/src.ts/raw.ts
similarity index 100%
rename from typescript/src.ts/raw.ts
rename to bindings/typescript/src.ts/raw.ts
diff --git a/typescript/src/control/character_controller.rs b/bindings/typescript/src/control/character_controller.rs
similarity index 100%
rename from typescript/src/control/character_controller.rs
rename to bindings/typescript/src/control/character_controller.rs
diff --git a/typescript/src/control/mod.rs b/bindings/typescript/src/control/mod.rs
similarity index 100%
rename from typescript/src/control/mod.rs
rename to bindings/typescript/src/control/mod.rs
diff --git a/typescript/src/control/pid_controller.rs b/bindings/typescript/src/control/pid_controller.rs
similarity index 100%
rename from typescript/src/control/pid_controller.rs
rename to bindings/typescript/src/control/pid_controller.rs
diff --git a/typescript/src/control/ray_cast_vehicle_controller.rs b/bindings/typescript/src/control/ray_cast_vehicle_controller.rs
similarity index 100%
rename from typescript/src/control/ray_cast_vehicle_controller.rs
rename to bindings/typescript/src/control/ray_cast_vehicle_controller.rs
diff --git a/typescript/src/dynamics/ccd_solver.rs b/bindings/typescript/src/dynamics/ccd_solver.rs
similarity index 100%
rename from typescript/src/dynamics/ccd_solver.rs
rename to bindings/typescript/src/dynamics/ccd_solver.rs
diff --git a/typescript/src/dynamics/impulse_joint.rs b/bindings/typescript/src/dynamics/impulse_joint.rs
similarity index 100%
rename from typescript/src/dynamics/impulse_joint.rs
rename to bindings/typescript/src/dynamics/impulse_joint.rs
diff --git a/typescript/src/dynamics/impulse_joint_set.rs b/bindings/typescript/src/dynamics/impulse_joint_set.rs
similarity index 100%
rename from typescript/src/dynamics/impulse_joint_set.rs
rename to bindings/typescript/src/dynamics/impulse_joint_set.rs
diff --git a/typescript/src/dynamics/integration_parameters.rs b/bindings/typescript/src/dynamics/integration_parameters.rs
similarity index 100%
rename from typescript/src/dynamics/integration_parameters.rs
rename to bindings/typescript/src/dynamics/integration_parameters.rs
diff --git a/typescript/src/dynamics/island_manager.rs b/bindings/typescript/src/dynamics/island_manager.rs
similarity index 100%
rename from typescript/src/dynamics/island_manager.rs
rename to bindings/typescript/src/dynamics/island_manager.rs
diff --git a/typescript/src/dynamics/joint.rs b/bindings/typescript/src/dynamics/joint.rs
similarity index 100%
rename from typescript/src/dynamics/joint.rs
rename to bindings/typescript/src/dynamics/joint.rs
diff --git a/typescript/src/dynamics/mod.rs b/bindings/typescript/src/dynamics/mod.rs
similarity index 100%
rename from typescript/src/dynamics/mod.rs
rename to bindings/typescript/src/dynamics/mod.rs
diff --git a/typescript/src/dynamics/multibody_joint.rs b/bindings/typescript/src/dynamics/multibody_joint.rs
similarity index 100%
rename from typescript/src/dynamics/multibody_joint.rs
rename to bindings/typescript/src/dynamics/multibody_joint.rs
diff --git a/typescript/src/dynamics/multibody_joint_set.rs b/bindings/typescript/src/dynamics/multibody_joint_set.rs
similarity index 100%
rename from typescript/src/dynamics/multibody_joint_set.rs
rename to bindings/typescript/src/dynamics/multibody_joint_set.rs
diff --git a/typescript/src/dynamics/rigid_body.rs b/bindings/typescript/src/dynamics/rigid_body.rs
similarity index 100%
rename from typescript/src/dynamics/rigid_body.rs
rename to bindings/typescript/src/dynamics/rigid_body.rs
diff --git a/typescript/src/dynamics/rigid_body_set.rs b/bindings/typescript/src/dynamics/rigid_body_set.rs
similarity index 100%
rename from typescript/src/dynamics/rigid_body_set.rs
rename to bindings/typescript/src/dynamics/rigid_body_set.rs
diff --git a/typescript/src/dynamics/soft_body.rs b/bindings/typescript/src/dynamics/soft_body.rs
similarity index 100%
rename from typescript/src/dynamics/soft_body.rs
rename to bindings/typescript/src/dynamics/soft_body.rs
diff --git a/typescript/src/geometry/broad_phase.rs b/bindings/typescript/src/geometry/broad_phase.rs
similarity index 100%
rename from typescript/src/geometry/broad_phase.rs
rename to bindings/typescript/src/geometry/broad_phase.rs
diff --git a/typescript/src/geometry/collider.rs b/bindings/typescript/src/geometry/collider.rs
similarity index 100%
rename from typescript/src/geometry/collider.rs
rename to bindings/typescript/src/geometry/collider.rs
diff --git a/typescript/src/geometry/collider_set.rs b/bindings/typescript/src/geometry/collider_set.rs
similarity index 100%
rename from typescript/src/geometry/collider_set.rs
rename to bindings/typescript/src/geometry/collider_set.rs
diff --git a/typescript/src/geometry/contact.rs b/bindings/typescript/src/geometry/contact.rs
similarity index 100%
rename from typescript/src/geometry/contact.rs
rename to bindings/typescript/src/geometry/contact.rs
diff --git a/typescript/src/geometry/feature.rs b/bindings/typescript/src/geometry/feature.rs
similarity index 100%
rename from typescript/src/geometry/feature.rs
rename to bindings/typescript/src/geometry/feature.rs
diff --git a/typescript/src/geometry/mod.rs b/bindings/typescript/src/geometry/mod.rs
similarity index 100%
rename from typescript/src/geometry/mod.rs
rename to bindings/typescript/src/geometry/mod.rs
diff --git a/typescript/src/geometry/narrow_phase.rs b/bindings/typescript/src/geometry/narrow_phase.rs
similarity index 100%
rename from typescript/src/geometry/narrow_phase.rs
rename to bindings/typescript/src/geometry/narrow_phase.rs
diff --git a/typescript/src/geometry/point.rs b/bindings/typescript/src/geometry/point.rs
similarity index 100%
rename from typescript/src/geometry/point.rs
rename to bindings/typescript/src/geometry/point.rs
diff --git a/typescript/src/geometry/ray.rs b/bindings/typescript/src/geometry/ray.rs
similarity index 100%
rename from typescript/src/geometry/ray.rs
rename to bindings/typescript/src/geometry/ray.rs
diff --git a/typescript/src/geometry/shape.rs b/bindings/typescript/src/geometry/shape.rs
similarity index 100%
rename from typescript/src/geometry/shape.rs
rename to bindings/typescript/src/geometry/shape.rs
diff --git a/typescript/src/geometry/toi.rs b/bindings/typescript/src/geometry/toi.rs
similarity index 100%
rename from typescript/src/geometry/toi.rs
rename to bindings/typescript/src/geometry/toi.rs
diff --git a/typescript/src/lib.rs b/bindings/typescript/src/lib.rs
similarity index 100%
rename from typescript/src/lib.rs
rename to bindings/typescript/src/lib.rs
diff --git a/typescript/src/math.rs b/bindings/typescript/src/math.rs
similarity index 100%
rename from typescript/src/math.rs
rename to bindings/typescript/src/math.rs
diff --git a/typescript/src/pipeline/debug_render_pipeline.rs b/bindings/typescript/src/pipeline/debug_render_pipeline.rs
similarity index 100%
rename from typescript/src/pipeline/debug_render_pipeline.rs
rename to bindings/typescript/src/pipeline/debug_render_pipeline.rs
diff --git a/typescript/src/pipeline/event_queue.rs b/bindings/typescript/src/pipeline/event_queue.rs
similarity index 100%
rename from typescript/src/pipeline/event_queue.rs
rename to bindings/typescript/src/pipeline/event_queue.rs
diff --git a/typescript/src/pipeline/mod.rs b/bindings/typescript/src/pipeline/mod.rs
similarity index 100%
rename from typescript/src/pipeline/mod.rs
rename to bindings/typescript/src/pipeline/mod.rs
diff --git a/typescript/src/pipeline/physics_hooks.rs b/bindings/typescript/src/pipeline/physics_hooks.rs
similarity index 100%
rename from typescript/src/pipeline/physics_hooks.rs
rename to bindings/typescript/src/pipeline/physics_hooks.rs
diff --git a/typescript/src/pipeline/physics_pipeline.rs b/bindings/typescript/src/pipeline/physics_pipeline.rs
similarity index 100%
rename from typescript/src/pipeline/physics_pipeline.rs
rename to bindings/typescript/src/pipeline/physics_pipeline.rs
diff --git a/typescript/src/pipeline/serialization_pipeline.rs b/bindings/typescript/src/pipeline/serialization_pipeline.rs
similarity index 100%
rename from typescript/src/pipeline/serialization_pipeline.rs
rename to bindings/typescript/src/pipeline/serialization_pipeline.rs
diff --git a/typescript/src/utils.rs b/bindings/typescript/src/utils.rs
similarity index 100%
rename from typescript/src/utils.rs
rename to bindings/typescript/src/utils.rs
diff --git a/typescript/testbed2d/.npmignore b/bindings/typescript/testbed2d/.npmignore
similarity index 100%
rename from typescript/testbed2d/.npmignore
rename to bindings/typescript/testbed2d/.npmignore
diff --git a/typescript/testbed2d/package-lock.json b/bindings/typescript/testbed2d/package-lock.json
similarity index 100%
rename from typescript/testbed2d/package-lock.json
rename to bindings/typescript/testbed2d/package-lock.json
diff --git a/typescript/testbed2d/package.json b/bindings/typescript/testbed2d/package.json
similarity index 100%
rename from typescript/testbed2d/package.json
rename to bindings/typescript/testbed2d/package.json
diff --git a/typescript/testbed2d/publish.sh b/bindings/typescript/testbed2d/publish.sh
similarity index 100%
rename from typescript/testbed2d/publish.sh
rename to bindings/typescript/testbed2d/publish.sh
diff --git a/typescript/testbed2d/src/Graphics.ts b/bindings/typescript/testbed2d/src/Graphics.ts
similarity index 100%
rename from typescript/testbed2d/src/Graphics.ts
rename to bindings/typescript/testbed2d/src/Graphics.ts
diff --git a/typescript/testbed2d/src/Gui.ts b/bindings/typescript/testbed2d/src/Gui.ts
similarity index 100%
rename from typescript/testbed2d/src/Gui.ts
rename to bindings/typescript/testbed2d/src/Gui.ts
diff --git a/typescript/testbed2d/src/Testbed.ts b/bindings/typescript/testbed2d/src/Testbed.ts
similarity index 100%
rename from typescript/testbed2d/src/Testbed.ts
rename to bindings/typescript/testbed2d/src/Testbed.ts
diff --git a/typescript/testbed2d/src/demos/characterController.ts b/bindings/typescript/testbed2d/src/demos/characterController.ts
similarity index 100%
rename from typescript/testbed2d/src/demos/characterController.ts
rename to bindings/typescript/testbed2d/src/demos/characterController.ts
diff --git a/typescript/testbed2d/src/demos/collisionGroups.ts b/bindings/typescript/testbed2d/src/demos/collisionGroups.ts
similarity index 100%
rename from typescript/testbed2d/src/demos/collisionGroups.ts
rename to bindings/typescript/testbed2d/src/demos/collisionGroups.ts
diff --git a/typescript/testbed2d/src/demos/convexPolygons.ts b/bindings/typescript/testbed2d/src/demos/convexPolygons.ts
similarity index 100%
rename from typescript/testbed2d/src/demos/convexPolygons.ts
rename to bindings/typescript/testbed2d/src/demos/convexPolygons.ts
diff --git a/typescript/testbed2d/src/demos/cubes.ts b/bindings/typescript/testbed2d/src/demos/cubes.ts
similarity index 100%
rename from typescript/testbed2d/src/demos/cubes.ts
rename to bindings/typescript/testbed2d/src/demos/cubes.ts
diff --git a/typescript/testbed2d/src/demos/heightfield.ts b/bindings/typescript/testbed2d/src/demos/heightfield.ts
similarity index 100%
rename from typescript/testbed2d/src/demos/heightfield.ts
rename to bindings/typescript/testbed2d/src/demos/heightfield.ts
diff --git a/typescript/testbed2d/src/demos/keva.ts b/bindings/typescript/testbed2d/src/demos/keva.ts
similarity index 100%
rename from typescript/testbed2d/src/demos/keva.ts
rename to bindings/typescript/testbed2d/src/demos/keva.ts
diff --git a/typescript/testbed2d/src/demos/lockedRotations.ts b/bindings/typescript/testbed2d/src/demos/lockedRotations.ts
similarity index 100%
rename from typescript/testbed2d/src/demos/lockedRotations.ts
rename to bindings/typescript/testbed2d/src/demos/lockedRotations.ts
diff --git a/typescript/testbed2d/src/demos/pidController.ts b/bindings/typescript/testbed2d/src/demos/pidController.ts
similarity index 100%
rename from typescript/testbed2d/src/demos/pidController.ts
rename to bindings/typescript/testbed2d/src/demos/pidController.ts
diff --git a/typescript/testbed2d/src/demos/polyline.ts b/bindings/typescript/testbed2d/src/demos/polyline.ts
similarity index 100%
rename from typescript/testbed2d/src/demos/polyline.ts
rename to bindings/typescript/testbed2d/src/demos/polyline.ts
diff --git a/typescript/testbed2d/src/demos/revoluteJoints.ts b/bindings/typescript/testbed2d/src/demos/revoluteJoints.ts
similarity index 100%
rename from typescript/testbed2d/src/demos/revoluteJoints.ts
rename to bindings/typescript/testbed2d/src/demos/revoluteJoints.ts
diff --git a/typescript/testbed2d/src/demos/softBodies.ts b/bindings/typescript/testbed2d/src/demos/softBodies.ts
similarity index 100%
rename from typescript/testbed2d/src/demos/softBodies.ts
rename to bindings/typescript/testbed2d/src/demos/softBodies.ts
diff --git a/typescript/testbed2d/src/demos/voxels.ts b/bindings/typescript/testbed2d/src/demos/voxels.ts
similarity index 100%
rename from typescript/testbed2d/src/demos/voxels.ts
rename to bindings/typescript/testbed2d/src/demos/voxels.ts
diff --git a/typescript/testbed2d/src/index.ts b/bindings/typescript/testbed2d/src/index.ts
similarity index 100%
rename from typescript/testbed2d/src/index.ts
rename to bindings/typescript/testbed2d/src/index.ts
diff --git a/typescript/testbed2d/static/.htaccess b/bindings/typescript/testbed2d/static/.htaccess
similarity index 100%
rename from typescript/testbed2d/static/.htaccess
rename to bindings/typescript/testbed2d/static/.htaccess
diff --git a/typescript/testbed2d/static/index.html b/bindings/typescript/testbed2d/static/index.html
similarity index 100%
rename from typescript/testbed2d/static/index.html
rename to bindings/typescript/testbed2d/static/index.html
diff --git a/typescript/testbed2d/tsconfig.json b/bindings/typescript/testbed2d/tsconfig.json
similarity index 100%
rename from typescript/testbed2d/tsconfig.json
rename to bindings/typescript/testbed2d/tsconfig.json
diff --git a/typescript/testbed2d/webpack.config.js b/bindings/typescript/testbed2d/webpack.config.js
similarity index 100%
rename from typescript/testbed2d/webpack.config.js
rename to bindings/typescript/testbed2d/webpack.config.js
diff --git a/typescript/testbed3d/.npmignore b/bindings/typescript/testbed3d/.npmignore
similarity index 100%
rename from typescript/testbed3d/.npmignore
rename to bindings/typescript/testbed3d/.npmignore
diff --git a/typescript/testbed3d/package-lock.json b/bindings/typescript/testbed3d/package-lock.json
similarity index 100%
rename from typescript/testbed3d/package-lock.json
rename to bindings/typescript/testbed3d/package-lock.json
diff --git a/typescript/testbed3d/package.json b/bindings/typescript/testbed3d/package.json
similarity index 100%
rename from typescript/testbed3d/package.json
rename to bindings/typescript/testbed3d/package.json
diff --git a/typescript/testbed3d/publish.sh b/bindings/typescript/testbed3d/publish.sh
similarity index 100%
rename from typescript/testbed3d/publish.sh
rename to bindings/typescript/testbed3d/publish.sh
diff --git a/typescript/testbed3d/src/Graphics.ts b/bindings/typescript/testbed3d/src/Graphics.ts
similarity index 100%
rename from typescript/testbed3d/src/Graphics.ts
rename to bindings/typescript/testbed3d/src/Graphics.ts
diff --git a/typescript/testbed3d/src/Gui.ts b/bindings/typescript/testbed3d/src/Gui.ts
similarity index 100%
rename from typescript/testbed3d/src/Gui.ts
rename to bindings/typescript/testbed3d/src/Gui.ts
diff --git a/typescript/testbed3d/src/Testbed.ts b/bindings/typescript/testbed3d/src/Testbed.ts
similarity index 100%
rename from typescript/testbed3d/src/Testbed.ts
rename to bindings/typescript/testbed3d/src/Testbed.ts
diff --git a/typescript/testbed3d/src/demos/ccd.ts b/bindings/typescript/testbed3d/src/demos/ccd.ts
similarity index 100%
rename from typescript/testbed3d/src/demos/ccd.ts
rename to bindings/typescript/testbed3d/src/demos/ccd.ts
diff --git a/typescript/testbed3d/src/demos/characterController.ts b/bindings/typescript/testbed3d/src/demos/characterController.ts
similarity index 100%
rename from typescript/testbed3d/src/demos/characterController.ts
rename to bindings/typescript/testbed3d/src/demos/characterController.ts
diff --git a/typescript/testbed3d/src/demos/collisionGroups.ts b/bindings/typescript/testbed3d/src/demos/collisionGroups.ts
similarity index 100%
rename from typescript/testbed3d/src/demos/collisionGroups.ts
rename to bindings/typescript/testbed3d/src/demos/collisionGroups.ts
diff --git a/typescript/testbed3d/src/demos/compoundShapes.ts b/bindings/typescript/testbed3d/src/demos/compoundShapes.ts
similarity index 100%
rename from typescript/testbed3d/src/demos/compoundShapes.ts
rename to bindings/typescript/testbed3d/src/demos/compoundShapes.ts
diff --git a/typescript/testbed3d/src/demos/convexDecomposition.ts b/bindings/typescript/testbed3d/src/demos/convexDecomposition.ts
similarity index 100%
rename from typescript/testbed3d/src/demos/convexDecomposition.ts
rename to bindings/typescript/testbed3d/src/demos/convexDecomposition.ts
diff --git a/typescript/testbed3d/src/demos/convexPolyhedron.ts b/bindings/typescript/testbed3d/src/demos/convexPolyhedron.ts
similarity index 100%
rename from typescript/testbed3d/src/demos/convexPolyhedron.ts
rename to bindings/typescript/testbed3d/src/demos/convexPolyhedron.ts
diff --git a/typescript/testbed3d/src/demos/damping.ts b/bindings/typescript/testbed3d/src/demos/damping.ts
similarity index 100%
rename from typescript/testbed3d/src/demos/damping.ts
rename to bindings/typescript/testbed3d/src/demos/damping.ts
diff --git a/typescript/testbed3d/src/demos/fountain.ts b/bindings/typescript/testbed3d/src/demos/fountain.ts
similarity index 100%
rename from typescript/testbed3d/src/demos/fountain.ts
rename to bindings/typescript/testbed3d/src/demos/fountain.ts
diff --git a/typescript/testbed3d/src/demos/glbToTrimesh.ts b/bindings/typescript/testbed3d/src/demos/glbToTrimesh.ts
similarity index 100%
rename from typescript/testbed3d/src/demos/glbToTrimesh.ts
rename to bindings/typescript/testbed3d/src/demos/glbToTrimesh.ts
diff --git a/typescript/testbed3d/src/demos/glbtoConvexHull.ts b/bindings/typescript/testbed3d/src/demos/glbtoConvexHull.ts
similarity index 100%
rename from typescript/testbed3d/src/demos/glbtoConvexHull.ts
rename to bindings/typescript/testbed3d/src/demos/glbtoConvexHull.ts
diff --git a/typescript/testbed3d/src/demos/heightfield.ts b/bindings/typescript/testbed3d/src/demos/heightfield.ts
similarity index 100%
rename from typescript/testbed3d/src/demos/heightfield.ts
rename to bindings/typescript/testbed3d/src/demos/heightfield.ts
diff --git a/typescript/testbed3d/src/demos/joints.ts b/bindings/typescript/testbed3d/src/demos/joints.ts
similarity index 100%
rename from typescript/testbed3d/src/demos/joints.ts
rename to bindings/typescript/testbed3d/src/demos/joints.ts
diff --git a/typescript/testbed3d/src/demos/keva.ts b/bindings/typescript/testbed3d/src/demos/keva.ts
similarity index 100%
rename from typescript/testbed3d/src/demos/keva.ts
rename to bindings/typescript/testbed3d/src/demos/keva.ts
diff --git a/typescript/testbed3d/src/demos/lockedRotations.ts b/bindings/typescript/testbed3d/src/demos/lockedRotations.ts
similarity index 100%
rename from typescript/testbed3d/src/demos/lockedRotations.ts
rename to bindings/typescript/testbed3d/src/demos/lockedRotations.ts
diff --git a/typescript/testbed3d/src/demos/pidController.ts b/bindings/typescript/testbed3d/src/demos/pidController.ts
similarity index 100%
rename from typescript/testbed3d/src/demos/pidController.ts
rename to bindings/typescript/testbed3d/src/demos/pidController.ts
diff --git a/typescript/testbed3d/src/demos/platform.ts b/bindings/typescript/testbed3d/src/demos/platform.ts
similarity index 100%
rename from typescript/testbed3d/src/demos/platform.ts
rename to bindings/typescript/testbed3d/src/demos/platform.ts
diff --git a/typescript/testbed3d/src/demos/pyramid.ts b/bindings/typescript/testbed3d/src/demos/pyramid.ts
similarity index 100%
rename from typescript/testbed3d/src/demos/pyramid.ts
rename to bindings/typescript/testbed3d/src/demos/pyramid.ts
diff --git a/typescript/testbed3d/src/demos/softBodies.ts b/bindings/typescript/testbed3d/src/demos/softBodies.ts
similarity index 100%
rename from typescript/testbed3d/src/demos/softBodies.ts
rename to bindings/typescript/testbed3d/src/demos/softBodies.ts
diff --git a/typescript/testbed3d/src/demos/softTearing.ts b/bindings/typescript/testbed3d/src/demos/softTearing.ts
similarity index 100%
rename from typescript/testbed3d/src/demos/softTearing.ts
rename to bindings/typescript/testbed3d/src/demos/softTearing.ts
diff --git a/typescript/testbed3d/src/demos/trimesh.ts b/bindings/typescript/testbed3d/src/demos/trimesh.ts
similarity index 100%
rename from typescript/testbed3d/src/demos/trimesh.ts
rename to bindings/typescript/testbed3d/src/demos/trimesh.ts
diff --git a/typescript/testbed3d/src/demos/voxels.ts b/bindings/typescript/testbed3d/src/demos/voxels.ts
similarity index 100%
rename from typescript/testbed3d/src/demos/voxels.ts
rename to bindings/typescript/testbed3d/src/demos/voxels.ts
diff --git a/typescript/testbed3d/src/index.ts b/bindings/typescript/testbed3d/src/index.ts
similarity index 100%
rename from typescript/testbed3d/src/index.ts
rename to bindings/typescript/testbed3d/src/index.ts
diff --git a/typescript/testbed3d/static/.htaccess b/bindings/typescript/testbed3d/static/.htaccess
similarity index 100%
rename from typescript/testbed3d/static/.htaccess
rename to bindings/typescript/testbed3d/static/.htaccess
diff --git a/typescript/testbed3d/static/index.html b/bindings/typescript/testbed3d/static/index.html
similarity index 100%
rename from typescript/testbed3d/static/index.html
rename to bindings/typescript/testbed3d/static/index.html
diff --git a/typescript/testbed3d/static/suzanne_blender_monkey.glb b/bindings/typescript/testbed3d/static/suzanne_blender_monkey.glb
similarity index 100%
rename from typescript/testbed3d/static/suzanne_blender_monkey.glb
rename to bindings/typescript/testbed3d/static/suzanne_blender_monkey.glb
diff --git a/typescript/testbed3d/tsconfig.json b/bindings/typescript/testbed3d/tsconfig.json
similarity index 100%
rename from typescript/testbed3d/tsconfig.json
rename to bindings/typescript/testbed3d/tsconfig.json
diff --git a/typescript/testbed3d/webpack.config.js b/bindings/typescript/testbed3d/webpack.config.js
similarity index 100%
rename from typescript/testbed3d/webpack.config.js
rename to bindings/typescript/testbed3d/webpack.config.js
diff --git a/website/README.md b/website/README.md
index c3d8f653f..f48337c52 100644
--- a/website/README.md
+++ b/website/README.md
@@ -62,7 +62,7 @@ Examples that read assets from disk (URDF/MJCF robots, `.obj` meshes, scene dump
 ### API references
 
 The JavaScript, C, and Python API pages embed the references generated from the bindings of this repository
-(typedoc for `typescript/`, Doxygen for `c/`, Sphinx for `python/`). They are build artifacts: `static/javascript2d`,
+(typedoc for `bindings/typescript/`, Doxygen for `bindings/c/`, Sphinx for `bindings/python/`). They are build artifacts: `static/javascript2d`,
 `static/javascript3d`, `static/c`, and `static/python` are gitignored, so they must be generated once before `yarn build`
 (or `yarn start`) can serve them.
 
@@ -75,7 +75,7 @@ $ ./scripts/build-api-docs.sh py         # just the Python one
 
 The JavaScript reference requires `wasm-pack` and `npm` (it builds the 2D and 3D packages first); the C
 reference requires `cmake`, a C compiler, `python3`, and Doxygen 1.9.4 or later; the Python reference builds the
-package with `python/dev.sh docs` (Rust toolchain and `python3`). `publish.sh` and
+package with `bindings/python/dev.sh docs` (Rust toolchain and `python3`). `publish.sh` and
 `yarn build:all` run this build themselves.
 
 ### Deployment
diff --git a/website/USER_GUIDE_AUDIT.md b/website/USER_GUIDE_AUDIT.md
index 91d6b2f15..8c0f68b79 100644
--- a/website/USER_GUIDE_AUDIT.md
+++ b/website/USER_GUIDE_AUDIT.md
@@ -2,7 +2,7 @@
 
 Audit of `docs/user_guides/templates/` against the engine on the `soft-bodies` branch (rapier 0.35.3,
 `@dimforge/rapier` 0.17.3 as pinned by `docs-examples`). Every API name and default value quoted by the guide was
-checked against `src/` and `typescript/src.ts`.
+checked against `src/` and `bindings/typescript/src.ts`.
 
 One commit per item.
 
@@ -45,7 +45,7 @@ One commit per item.
       prediction, fast-rotation and gyroscopic forces.
 - [x] 19. The contact skin of the colliders, and the one-sided (oriented) triangle-meshes and polylines.
 - [x] 20. The scene loaders: `rapier3d-urdf`, `rapier3d-mjcf` and `rapier3d-meshloader`.
-- [x] 21. The Python bindings, which live in `python/` with their own documentation.
+- [x] 21. The Python bindings, which live in `bindings/python/` with their own documentation.
 - [x] 22. `the_rapier_testbed.mdx` contains nothing but its front matter.
 - [x] 23. `common_recipes.mdx` contains nothing but its section titles.
 
diff --git a/website/docs-examples/2d/bevy/Cargo.toml b/website/docs-examples/2d/bevy/Cargo.toml
index 669e1b83b..da3cc85c9 100644
--- a/website/docs-examples/2d/bevy/Cargo.toml
+++ b/website/docs-examples/2d/bevy/Cargo.toml
@@ -8,14 +8,10 @@ edition = "2021"
 [dependencies]
 # The in-development bevy_rapier tracks Bevy's main branch.
 bevy = { git = "https://github.com/bevyengine/bevy", branch = "main" }
-# Use the bevy_rapier checkout next to the rapier repository so doc snippets are checked against local changes.
-bevy_rapier2d = { path = "../../../../../bevy_rapier/bevy_rapier2d", features = ["fem", "serde-serialize"] }
+# Use the in-tree bevy_rapier so doc snippets are checked against local changes.
+bevy_rapier2d = { path = "../../../../bindings/bevy_rapier/bevy_rapier2d", features = ["fem", "serde-serialize"] }
 # Used For serialization
 bincode = { version = "2.0.1", features = ["serde"] }
 
 # Standalone workspace, excluded from the one of the other snippets (see `docs-examples/Cargo.toml`).
 [workspace]
-
-# Make bevy_rapier use the in-tree rapier too, so the bevy and rust snippets share the same rapier.
-[patch.crates-io]
-rapier2d = { path = "../../../../crates/rapier2d" }
diff --git a/website/docs-examples/2d/c/CMakeLists.txt b/website/docs-examples/2d/c/CMakeLists.txt
index 620cf277e..43ac5f0e8 100644
--- a/website/docs-examples/2d/c/CMakeLists.txt
+++ b/website/docs-examples/2d/c/CMakeLists.txt
@@ -5,7 +5,7 @@ set(RAPIER_DIMENSION "2" CACHE STRING "" FORCE)
 set(RAPIER_FEATURES "fem" CACHE STRING "" FORCE)
 set(RAPIER_BUILD_TESTS OFF CACHE BOOL "" FORCE)
 set(RAPIER_BUILD_EXAMPLES OFF CACHE BOOL "" FORCE)
-add_subdirectory("${CMAKE_CURRENT_SOURCE_DIR}/../../../../c" rapier)
+add_subdirectory("${CMAKE_CURRENT_SOURCE_DIR}/../../../../bindings/c" rapier)
 enable_testing()
 file(GLOB SNIPPETS CONFIGURE_DEPENDS "${CMAKE_CURRENT_SOURCE_DIR}/examples/*.c")
 foreach(snippet ${SNIPPETS})
diff --git a/website/docs-examples/2d/javascript/package-lock.json b/website/docs-examples/2d/javascript/package-lock.json
index 54e881d39..3db82a1b5 100644
--- a/website/docs-examples/2d/javascript/package-lock.json
+++ b/website/docs-examples/2d/javascript/package-lock.json
@@ -9,7 +9,7 @@
       "version": "1.0.0",
       "license": "Apache-2.0",
       "dependencies": {
-        "@dimforge/rapier2d": "file:../../../../typescript/builds/rapier2d/pkg"
+        "@dimforge/rapier2d": "file:../../../../bindings/typescript/builds/rapier2d/pkg"
       },
       "devDependencies": {
         "html-loader": "^5.0.0",
@@ -21,13 +21,13 @@
         "webpack-cli": "^5.1.4"
       }
     },
-    "../../../../typescript/builds/rapier2d/pkg": {
+    "../../../../bindings/typescript/builds/rapier2d/pkg": {
       "name": "@dimforge/rapier2d",
       "version": "0.20.0",
       "license": "Apache-2.0"
     },
     "node_modules/@dimforge/rapier2d": {
-      "resolved": "../../../../typescript/builds/rapier2d/pkg",
+      "resolved": "../../../../bindings/typescript/builds/rapier2d/pkg",
       "link": true
     },
     "node_modules/@discoveryjs/json-ext": {
diff --git a/website/docs-examples/2d/javascript/package.json b/website/docs-examples/2d/javascript/package.json
index 3bcbd2fe2..befdd5e3f 100644
--- a/website/docs-examples/2d/javascript/package.json
+++ b/website/docs-examples/2d/javascript/package.json
@@ -19,6 +19,6 @@
     "webpack-cli": "^5.1.4"
   },
   "dependencies": {
-    "@dimforge/rapier2d": "file:../../../../typescript/builds/rapier2d/pkg"
+    "@dimforge/rapier2d": "file:../../../../bindings/typescript/builds/rapier2d/pkg"
   }
 }
\ No newline at end of file
diff --git a/website/docs-examples/3d/bevy/Cargo.toml b/website/docs-examples/3d/bevy/Cargo.toml
index 46300142c..f7f36c97e 100644
--- a/website/docs-examples/3d/bevy/Cargo.toml
+++ b/website/docs-examples/3d/bevy/Cargo.toml
@@ -8,12 +8,8 @@ edition = "2021"
 [dependencies]
 # The in-development bevy_rapier tracks Bevy's main branch.
 bevy = { git = "https://github.com/bevyengine/bevy", branch = "main" }
-# Use the bevy_rapier checkout next to the rapier repository so doc snippets are checked against local changes.
-bevy_rapier3d = { path = "../../../../../bevy_rapier/bevy_rapier3d", features = ["fem", "urdf", "mjcf", "meshloader"] }
+# Use the in-tree bevy_rapier so doc snippets are checked against local changes.
+bevy_rapier3d = { path = "../../../../bindings/bevy_rapier/bevy_rapier3d", features = ["fem", "urdf", "mjcf", "meshloader"] }
 
 # Standalone workspace, excluded from the one of the other snippets (see `docs-examples/Cargo.toml`).
 [workspace]
-
-# Make bevy_rapier use the in-tree rapier too, so the bevy and rust snippets share the same rapier.
-[patch.crates-io]
-rapier3d = { path = "../../../../crates/rapier3d" }
diff --git a/website/docs-examples/3d/c/CMakeLists.txt b/website/docs-examples/3d/c/CMakeLists.txt
index 31daeb9d5..fc7380a14 100644
--- a/website/docs-examples/3d/c/CMakeLists.txt
+++ b/website/docs-examples/3d/c/CMakeLists.txt
@@ -5,7 +5,7 @@ set(RAPIER_DIMENSION "3" CACHE STRING "" FORCE)
 set(RAPIER_FEATURES "fem,robotics" CACHE STRING "" FORCE)
 set(RAPIER_BUILD_TESTS OFF CACHE BOOL "" FORCE)
 set(RAPIER_BUILD_EXAMPLES OFF CACHE BOOL "" FORCE)
-add_subdirectory("${CMAKE_CURRENT_SOURCE_DIR}/../../../../c" rapier)
+add_subdirectory("${CMAKE_CURRENT_SOURCE_DIR}/../../../../bindings/c" rapier)
 enable_testing()
 file(GLOB SNIPPETS CONFIGURE_DEPENDS "${CMAKE_CURRENT_SOURCE_DIR}/examples/*.c")
 foreach(snippet ${SNIPPETS})
diff --git a/website/docs-examples/3d/javascript/package-lock.json b/website/docs-examples/3d/javascript/package-lock.json
index 3d72c2169..041d57df7 100644
--- a/website/docs-examples/3d/javascript/package-lock.json
+++ b/website/docs-examples/3d/javascript/package-lock.json
@@ -9,7 +9,7 @@
       "version": "1.0.0",
       "license": "Apache-2.0",
       "dependencies": {
-        "@dimforge/rapier3d": "file:../../../../typescript/builds/rapier3d/pkg"
+        "@dimforge/rapier3d": "file:../../../../bindings/typescript/builds/rapier3d/pkg"
       },
       "devDependencies": {
         "html-loader": "^5.0.0",
@@ -19,13 +19,13 @@
         "webpack-cli": "^5.1.4"
       }
     },
-    "../../../../typescript/builds/rapier3d/pkg": {
+    "../../../../bindings/typescript/builds/rapier3d/pkg": {
       "name": "@dimforge/rapier3d",
       "version": "0.20.0",
       "license": "Apache-2.0"
     },
     "node_modules/@dimforge/rapier3d": {
-      "resolved": "../../../../typescript/builds/rapier3d/pkg",
+      "resolved": "../../../../bindings/typescript/builds/rapier3d/pkg",
       "link": true
     },
     "node_modules/@discoveryjs/json-ext": {
diff --git a/website/docs-examples/3d/javascript/package.json b/website/docs-examples/3d/javascript/package.json
index f4a4da7c2..ff81e588c 100644
--- a/website/docs-examples/3d/javascript/package.json
+++ b/website/docs-examples/3d/javascript/package.json
@@ -17,6 +17,6 @@
     "webpack-cli": "^5.1.4"
   },
   "dependencies": {
-    "@dimforge/rapier3d": "file:../../../../typescript/builds/rapier3d/pkg"
+    "@dimforge/rapier3d": "file:../../../../bindings/typescript/builds/rapier3d/pkg"
   }
 }
\ No newline at end of file
diff --git a/website/docs-examples/3d/python/run_snippets.sh b/website/docs-examples/3d/python/run_snippets.sh
index 8d9cb2ed7..cb0cf84a1 100755
--- a/website/docs-examples/3d/python/run_snippets.sh
+++ b/website/docs-examples/3d/python/run_snippets.sh
@@ -1,6 +1,6 @@
 #!/bin/bash
 # Runs the Python snippets of the user-guide against the in-tree bindings.
-# Build them first with `python/dev.sh build` (or set PYTHON to an interpreter where `rapier3d` is installed).
+# Build them first with `bindings/python/dev.sh build` (or set PYTHON to an interpreter where `rapier3d` is installed).
 # Usage: ./run_snippets.sh [snippet.py]...
 
 cd "$(dirname "${BASH_SOURCE[0]}")"
diff --git a/website/docs-examples/3d/python/testbed.py b/website/docs-examples/3d/python/testbed.py
index fe2ea8fb0..f3fcd55a5 100644
--- a/website/docs-examples/3d/python/testbed.py
+++ b/website/docs-examples/3d/python/testbed.py
@@ -3,7 +3,7 @@
 
 # Run the testbed headlessly (no window) from its sources in the repository.
 os.environ["PANDA_NO_WINDOW"] = "1"
-sys.path.insert(0, os.path.join(os.path.dirname(os.path.abspath(__file__)), "../../../../python/rapier-testbed"))
+sys.path.insert(0, os.path.join(os.path.dirname(os.path.abspath(__file__)), "../../../../bindings/python/rapier-testbed"))
 
 import rapier3d as rp
 
diff --git a/website/docs-examples/Cargo.toml b/website/docs-examples/Cargo.toml
index e2afbb37e..591f3798d 100644
--- a/website/docs-examples/Cargo.toml
+++ b/website/docs-examples/Cargo.toml
@@ -1,6 +1,6 @@
 [workspace]
 members = ["2d/rust", "3d/rust", "inject_file"]
-# The bevy snippets need a bevy_rapier checkout next to the rapier repository: they are standalone workspaces so
-# the other crates (including `inject_file`) build without it.
+# The bevy snippets build against the in-tree bevy_rapier (`bindings/bevy_rapier`), which tracks Bevy's main
+# branch: they are standalone workspaces so the other crates (including `inject_file`) build without Bevy.
 exclude = ["2d/bevy", "3d/bevy"]
 resolver = "2"
diff --git a/website/docs-examples/README.md b/website/docs-examples/README.md
index 073fd6187..c3138d1cf 100644
--- a/website/docs-examples/README.md
+++ b/website/docs-examples/README.md
@@ -9,19 +9,18 @@ By running `./generate_user_guide.sh` at the root path, These examples are copie
 The produced binary might or might not produce something useful, it's
 intended usage is to run `cargo check --workspace --examples`.
 
-The bevy snippets (`2d/bevy`, `3d/bevy`) are standalone workspaces building against the in-development `bevy_rapier`,
-which must be cloned next to the `rapier` repository. Check them with `cargo check --examples` from their own
-folders.
+The bevy snippets (`2d/bevy`, `3d/bevy`) are standalone workspaces building against the in-tree `bevy_rapier`
+(`bindings/bevy_rapier`). Check them with `cargo check --examples` from their own folders.
 
 ## Javascript
 
 The snippets build against the bindings **of this repository**, not the ones published on
 npm, so a snippet may use an API before it is released. `@dimforge/rapier{2,3}d` is a `file:`
-dependency on `typescript/builds/rapier{2,3}d/pkg`, which is generated; build it once (per
+dependency on `bindings/typescript/builds/rapier{2,3}d/pkg`, which is generated; build it once (per
 dimension) before installing:
 
 ```sh
-cd typescript
+cd bindings/typescript
 npm ci
 cargo run -p prepare_builds -- -d dim2 -f non-deterministic
 cd builds/rapier2d && npm i && npm run build:wasm && npm run build:ts
diff --git a/website/docs/user_guides/templates/common_mistakes.mdx b/website/docs/user_guides/templates/common_mistakes.mdx
index 5f306f689..d9fc7d7b6 100644
--- a/website/docs/user_guides/templates/common_mistakes.mdx
+++ b/website/docs/user_guides/templates/common_mistakes.mdx
@@ -72,7 +72,7 @@ debug build of your application can still use an optimized Rapier library, as lo
 ## My local build of Rapier is slower than the online demos
 Make sure the bindings are built in release mode. Rapier can be 100 times slower without optimizations enabled. The
 package installed by `pip` is always optimized, but the bindings built from source are only optimized if `--release`
-is given to maturin, e.g., `maturin develop --release -m python/rapier-py-3d/Cargo.toml` (see
+is given to maturin, e.g., `maturin develop --release -m bindings/python/rapier-py-3d/Cargo.toml` (see
 [building from source](./getting_started_py.mdx#building-from-source)). The build mode of the bindings actually loaded
 by your application is given by the `profile` property of `rapier3d.build_features()`:
 
diff --git a/website/docs/user_guides/templates/determinism.mdx b/website/docs/user_guides/templates/determinism.mdx
index 6c96022ed..0dead3109 100644
--- a/website/docs/user_guides/templates/determinism.mdx
+++ b/website/docs/user_guides/templates/determinism.mdx
@@ -166,7 +166,7 @@ computers (including different OS and/or different processors) will result in th
 achieve this, both computers must start the simulation with the **same initial conditions** as discussed above, and the
 following additional conditions must be met:
 - The bindings are built with the `determinism` feature, e.g., with
-  `maturin develop --release -F determinism -m python/rapier-py-3d/Cargo.toml` (see
+  `maturin develop --release -F determinism -m bindings/python/rapier-py-3d/Cargo.toml` (see
   [building from source](./getting_started_py.mdx#building-from-source)). The parallelism, which is always enabled,
   can be combined with it: the results of the parallel solver are identical to the results of the sequential one, and
   don't depend on the number of threads (nor, therefore, on the number of cores of the machine running the
diff --git a/website/docs/user_guides/templates/getting_started_c.mdx b/website/docs/user_guides/templates/getting_started_c.mdx
index dd8db4c5c..7977a981c 100644
--- a/website/docs/user_guides/templates/getting_started_c.mdx
+++ b/website/docs/user_guides/templates/getting_started_c.mdx
@@ -13,7 +13,7 @@ the `c` folder of the [Rapier repository](https://github.com/dimforge/rapier). T
 need a Rust toolchain as well as a C compiler. From the root of the repository:
 
 ```sh
-cmake -S c -B build/c -DCMAKE_BUILD_TYPE=Release
+cmake -S bindings/c -B build/c -DCMAKE_BUILD_TYPE=Release
 cmake --build build/c --config Release --parallel
 ```
 
@@ -158,7 +158,7 @@ ownership rules, the threading rules, and the errors. It can also be generated l
 [Doxygen](https://www.doxygen.nl) (1.9.4 or later):
 
 ```sh
-cmake -S c/doxygen -B build/c-docs
+cmake -S bindings/c/doxygen -B build/c-docs
 cmake --build build/c-docs --target rapier_docs --parallel
 ```
 
diff --git a/website/docs/user_guides/templates/getting_started_js.mdx b/website/docs/user_guides/templates/getting_started_js.mdx
index cb0eaff83..7f82f15a6 100644
--- a/website/docs/user_guides/templates/getting_started_js.mdx
+++ b/website/docs/user_guides/templates/getting_started_js.mdx
@@ -128,4 +128,4 @@ Below is an example of rendering this data using Pixi.js and Pixi Viewport.
 <load path='/2d/javascript/src/snippets/graphics/Graphics.ts' marker='Debug2' />
 ```
 
-An example of this in action can be see in the [Rapier.js testbed code](https://github.com/dimforge/rapier.js/blob/master/testbed2d/src/Graphics.ts).
+An example of this in action can be see in the [Rapier.js testbed code](https://github.com/dimforge/rapier/blob/master/bindings/typescript/testbed2d/src/Graphics.ts).
diff --git a/website/docs/user_guides/templates/getting_started_py.mdx b/website/docs/user_guides/templates/getting_started_py.mdx
index 67c6d0aa7..adc789c32 100644
--- a/website/docs/user_guides/templates/getting_started_py.mdx
+++ b/website/docs/user_guides/templates/getting_started_py.mdx
@@ -25,7 +25,7 @@ e.g., to use a version of Rapier that isn't published yet. This requires a Rust
 
 ```sh
 pip install maturin
-maturin develop --release -m python/rapier-py-3d/Cargo.toml
+maturin develop --release -m bindings/python/rapier-py-3d/Cargo.toml
 ```
 
 This installs the package into your virtual environment in editable mode. Replacing `maturin develop` by
diff --git a/website/docs/user_guides/templates/joint_constraints.mdx b/website/docs/user_guides/templates/joint_constraints.mdx
index 4888f989f..45e50bb1e 100644
--- a/website/docs/user_guides/templates/joint_constraints.mdx
+++ b/website/docs/user_guides/templates/joint_constraints.mdx
@@ -163,7 +163,7 @@ After each simulation step, the coordinates and velocities of a multibody joint
 `MultibodyJointState` component (automatically added alongside the `MultibodyJoint`). Modifying `MultibodyJoint::parent`
 re-attaches the joint to another rigid-body. Unlike impulse joints, multibody joints cannot be disabled.
 
-See [bevy_rapier's example](https://github.com/dimforge/bevy_rapier/blob/master/bevy_rapier3d/examples/multibody_joints3.rs)
+See [bevy_rapier's example](https://github.com/dimforge/rapier/blob/master/bindings/bevy_rapier/bevy_rapier3d/examples/multibody_joints3.rs)
 for a demonstration of both approaches.
 
 </bevy>
@@ -235,7 +235,7 @@ values={[
   </TabItem>
 </Tabs>
 
-See the [C testbed example](https://github.com/dimforge/rapier/blob/master/c/testbed/examples3d/joints3.c) for a
+See the [C testbed example](https://github.com/dimforge/rapier/blob/master/bindings/c/testbed/examples3d/joints3.c) for a
 demonstration of both approaches.
 
 ### Generalized coordinates
diff --git a/website/docs/user_guides/templates/the_rapier_testbed.mdx b/website/docs/user_guides/templates/the_rapier_testbed.mdx
index 33d6c1f58..b23593402 100644
--- a/website/docs/user_guides/templates/the_rapier_testbed.mdx
+++ b/website/docs/user_guides/templates/the_rapier_testbed.mdx
@@ -73,7 +73,7 @@ by enabling the `RAPIER_BUILD_TESTBED` option of CMake. It downloads its graphic
 configuration (on Linux, the X11 and OpenGL development packages must be installed). From the root of the repository:
 
 ```bash
-cmake -S c -B build/c3 -DRAPIER_BUILD_TESTBED=ON -DRAPIER_DIMENSION=3 -DCMAKE_BUILD_TYPE=Release
+cmake -S bindings/c -B build/c3 -DRAPIER_BUILD_TESTBED=ON -DRAPIER_DIMENSION=3 -DCMAKE_BUILD_TYPE=Release
 cmake --build build/c3 --target rapier_testbed --config Release --parallel
 ./build/c3/testbed/rapier_testbed # 3D demos
 ```
@@ -109,7 +109,7 @@ window, which is useful to check that a demo runs without errors, or to measure
 ## Writing a scene
 Unlike the Rust testbed, the C testbed isn't a library meant to be used by your own application: it is an
 application of the Rapier repository, which demos are compiled with it. Each demo is one C function (e.g.
-`tbRestitution3` in `c/testbed/examples3d/restitution3.c`) building a world like in any other application, giving it
+`tbRestitution3` in `bindings/c/testbed/examples3d/restitution3.c`) building a world like in any other application, giving it
 to the viewer, and then stepping it from the rendering loop. Note that the loop is what owns the simulation: the viewer
 only draws the state of the world it is given, and tells whether the user asked for the simulation to keep running or
 to stop:
@@ -119,16 +119,16 @@ to stop:
 ```
 
 Therefore, prototyping a scene with the testbed (e.g. for reproducing a problem before opening an issue) is done in
-your local copy of the repository: its source file is added to the `c/testbed/examples3d` folder (resp.
+your local copy of the repository: its source file is added to the `bindings/c/testbed/examples3d` folder (resp.
 `examples2d`), which files are all compiled with the testbed, and its function is added to the demos listed by the
-`tbExamples` array of `c/testbed/registry3.c` (resp. `registry2.c`):
+`tbExamples` array of `bindings/c/testbed/registry3.c` (resp. `registry2.c`):
 
 ```c
 <load path='/3d/c/examples/testbed3.c' marker='Registry' />
 ```
 
 :::info
-The registries are generated from the list of the Rust demos by the `c/testbed/update_catalog.py` script, which
+The registries are generated from the list of the Rust demos by the `bindings/c/testbed/update_catalog.py` script, which
 doesn't know about the entries added by hand: they are lost whenever the registries are generated again.
 :::
 
@@ -150,7 +150,7 @@ The testbed is published as the `rapier-testbed` package, which depends on `rapi
 pip install rapier-testbed
 ```
 
-It can also be installed from the `python/rapier-testbed` folder of the
+It can also be installed from the `bindings/python/rapier-testbed` folder of the
 [Rapier repository](https://github.com/dimforge/rapier), e.g., to use it with bindings
 [built from source](./getting_started_py.mdx#building-from-source). From the root of the repository, and with your
 virtual environment activated (`--no-deps` keeps the bindings you built instead of downloading them, and `-e` makes
@@ -158,7 +158,7 @@ your modifications of the testbed effective without reinstalling it):
 
 ```sh
 pip install panda3d numpy
-pip install --no-deps -e ./python/rapier-testbed
+pip install --no-deps -e ./bindings/python/rapier-testbed
 ```
 
 ## Running the demos
@@ -171,7 +171,7 @@ python -m rapier_testbed # List the demos, and open the selected one.
 python -m rapier_testbed.examples3.domino3 # Open the domino demo.
 ```
 
-The `python/examples_tour.py` script of the repository opens every demo in turn, each of them being opened when the
+The `bindings/python/examples_tour.py` script of the repository opens every demo in turn, each of them being opened when the
 window of the previous one is closed.
 
 :::warning
diff --git a/website/scripts/build-api-docs.sh b/website/scripts/build-api-docs.sh
index fc1a840ae..87e080590 100755
--- a/website/scripts/build-api-docs.sh
+++ b/website/scripts/build-api-docs.sh
@@ -4,13 +4,13 @@
 # Usage: ./scripts/build-api-docs.sh [js|c|py]...
 # Without argument, the JavaScript (typedoc), C (Doxygen), and Python (Sphinx) references are built.
 #
-# - JavaScript: prepares the non-deterministic 2D/3D packages of `typescript/`, builds them, runs
+# - JavaScript: prepares the non-deterministic 2D/3D packages of `bindings/typescript/`, builds them, runs
 #   typedoc, and copies the result to static/javascript2d and static/javascript3d.
-#   Requires cargo, wasm-pack and npm (see typescript/README.md).
-# - C: runs the Doxygen reference of `c/doxygen` (all dimension/precision variants) and copies the
+#   Requires cargo, wasm-pack and npm (see bindings/typescript/README.md).
+# - C: runs the Doxygen reference of `bindings/c/doxygen` (all dimension/precision variants) and copies the
 #   HTML to static/c. Requires cmake, a C compiler, python3 and Doxygen 1.9.4+.
-# - Python: builds the `rapier3d` package and its Sphinx docs with `python/dev.sh docs` (in the virtual
-#   environment it manages, see python/README.md), and copies the HTML to static/python.
+# - Python: builds the `rapier3d` package and its Sphinx docs with `bindings/python/dev.sh docs` (in the virtual
+#   environment it manages, see bindings/python/README.md), and copies the HTML to static/python.
 #   Requires a Rust toolchain and python3.
 
 set -e
@@ -29,7 +29,7 @@ build_js() {
     for dim in 2 3; do
         echo -e "${BLUE}Building the JavaScript ${dim}D API reference${NC}"
         (
-            cd "$RAPIER_DIR/typescript"
+            cd "$RAPIER_DIR/bindings/typescript"
             cargo run --quiet -p prepare_builds -- -d "dim${dim}" -f non-deterministic
             cd "builds/rapier${dim}d"
             npm install --no-audit --no-fund
@@ -40,7 +40,7 @@ build_js() {
             npm run build:doc
         )
         rm -rf "$STATIC_DIR/javascript${dim}d"
-        cp -r "$RAPIER_DIR/typescript/builds/rapier${dim}d/docs" "$STATIC_DIR/javascript${dim}d"
+        cp -r "$RAPIER_DIR/bindings/typescript/builds/rapier${dim}d/docs" "$STATIC_DIR/javascript${dim}d"
         echo -e "${GREEN}JavaScript ${dim}D API reference copied to static/javascript${dim}d${NC}"
     done
 }
@@ -49,7 +49,7 @@ build_c() {
     local build_dir="$RAPIER_DIR/target/website-c-docs"
     echo -e "${BLUE}Building the C API reference${NC}"
     rm -rf "$build_dir/html"
-    cmake -S "$RAPIER_DIR/c/doxygen" -B "$build_dir"
+    cmake -S "$RAPIER_DIR/bindings/c/doxygen" -B "$build_dir"
     cmake --build "$build_dir" --target rapier_docs --parallel
     rm -rf "$STATIC_DIR/c"
     mkdir -p "$STATIC_DIR/c"
@@ -60,10 +60,10 @@ build_c() {
 
 build_py() {
     echo -e "${BLUE}Building the Python API reference${NC}"
-    rm -rf "$RAPIER_DIR/python/docs/_build/html"
-    "$RAPIER_DIR/python/dev.sh" docs
+    rm -rf "$RAPIER_DIR/bindings/python/docs/_build/html"
+    "$RAPIER_DIR/bindings/python/dev.sh" docs
     rm -rf "$STATIC_DIR/python"
-    cp -r "$RAPIER_DIR/python/docs/_build/html" "$STATIC_DIR/python"
+    cp -r "$RAPIER_DIR/bindings/python/docs/_build/html" "$STATIC_DIR/python"
     echo -e "${GREEN}Python API reference copied to static/python${NC}"
 }