diff --git a/crates/bevy_xpbd_2d/Cargo.toml b/crates/bevy_xpbd_2d/Cargo.toml
index 823523d5..6336d02f 100644
--- a/crates/bevy_xpbd_2d/Cargo.toml
+++ b/crates/bevy_xpbd_2d/Cargo.toml
@@ -70,6 +70,10 @@ required-features = ["2d"]
 name = "collision_layers"
 required-features = ["2d"]
 
+[[example]]
+name = "custom_collider"
+required-features = ["2d"]
+
 [[example]]
 name = "fixed_joint_2d"
 required-features = ["2d"]
diff --git a/crates/bevy_xpbd_2d/examples/custom_collider.rs b/crates/bevy_xpbd_2d/examples/custom_collider.rs
new file mode 100644
index 00000000..0f5f5f52
--- /dev/null
+++ b/crates/bevy_xpbd_2d/examples/custom_collider.rs
@@ -0,0 +1,228 @@
+//! An example demonstrating how to make a custom collider and use it for collision detection.
+
+use bevy::{prelude::*, sprite::MaterialMesh2dBundle};
+use bevy_xpbd_2d::{math::*, prelude::*, PhysicsSchedule, PhysicsStepSet};
+use examples_common_2d::XpbdExamplePlugin;
+
+fn main() {
+    App::new()
+        .add_plugins((
+            DefaultPlugins,
+            XpbdExamplePlugin,
+            // Add collider backend for our custom collider.
+            // This handles things like initializing and updating required components
+            // and managing collider hierarchies.
+            ColliderBackendPlugin::<CircleCollider>::default(),
+            // Enable collision detection for our custom collider.
+            NarrowPhasePlugin::<CircleCollider>::default(),
+        ))
+        .insert_resource(ClearColor(Color::rgb(0.01, 0.01, 0.025)))
+        .insert_resource(Gravity::ZERO)
+        .add_systems(Startup, setup)
+        .add_systems(
+            PhysicsSchedule,
+            (center_gravity, rotate).before(PhysicsStepSet::BroadPhase),
+        )
+        .run();
+}
+
+/// A basic collider with a circle shape. Only supports uniform scaling.
+#[derive(Component)]
+struct CircleCollider {
+    /// The radius of the circle collider. This may be scaled by the `Transform` scale.
+    radius: Scalar,
+    /// The radius of the circle collider without `Transform` scale applied.
+    unscaled_radius: Scalar,
+    /// The scaling factor, determined by `Transform` scale.
+    scale: Scalar,
+}
+
+impl CircleCollider {
+    fn new(radius: Scalar) -> Self {
+        Self {
+            radius,
+            unscaled_radius: radius,
+            scale: 1.0,
+        }
+    }
+}
+
+impl AnyCollider for CircleCollider {
+    fn aabb(&self, position: Vector, _rotation: impl Into<Rotation>) -> ColliderAabb {
+        ColliderAabb::new(position, Vector::splat(self.radius))
+    }
+
+    fn mass_properties(&self, density: Scalar) -> ColliderMassProperties {
+        // In 2D, the Z length is assumed to be 1.0, so volume = area
+        let volume = bevy_xpbd_2d::math::PI * self.radius.powi(2);
+        let mass = density * volume;
+        let inertia = self.radius.powi(2) / 2.0;
+
+        ColliderMassProperties {
+            mass: Mass(mass),
+            inverse_mass: InverseMass(mass.recip()),
+            inertia: Inertia(inertia),
+            inverse_inertia: InverseInertia(inertia.recip()),
+            center_of_mass: CenterOfMass::default(),
+        }
+    }
+
+    // This is the actual collision detection part.
+    // It compute all contacts between two colliders at the given positions.
+    fn contact_manifolds(
+        &self,
+        other: &Self,
+        position1: Vector,
+        rotation1: impl Into<Rotation>,
+        position2: Vector,
+        rotation2: impl Into<Rotation>,
+        prediction_distance: Scalar,
+    ) -> Vec<ContactManifold> {
+        let rotation1: Rotation = rotation1.into();
+        let rotation2: Rotation = rotation2.into();
+
+        let inv_rotation1 = rotation1.inverse();
+        let delta_pos = inv_rotation1.rotate(position2 - position1);
+        let delta_rot = inv_rotation1.mul(rotation2);
+
+        let distance_squared = delta_pos.length_squared();
+        let sum_radius = self.radius + other.radius;
+
+        if distance_squared < (sum_radius + prediction_distance).powi(2) {
+            let normal1 = if distance_squared != 0.0 {
+                delta_pos.normalize_or_zero()
+            } else {
+                Vector::X
+            };
+            let normal2 = delta_rot.inverse().rotate(-normal1);
+            let point1 = normal1 * self.radius;
+            let point2 = normal2 * other.radius;
+
+            vec![ContactManifold {
+                index: 0,
+                normal1,
+                normal2,
+                contacts: vec![ContactData {
+                    index: 0,
+                    point1,
+                    point2,
+                    normal1,
+                    normal2,
+                    penetration: sum_radius - distance_squared.sqrt(),
+                    // Impulses are computed by the constraint solver
+                    normal_impulse: 0.0,
+                    tangent_impulse: 0.0,
+                }],
+            }]
+        } else {
+            vec![]
+        }
+    }
+}
+
+// Note: This circle collider only supports uniform scaling.
+impl ScalableCollider for CircleCollider {
+    fn scale(&self) -> Vector {
+        Vector::splat(self.scale)
+    }
+
+    fn set_scale(&mut self, scale: Vector, _detail: u32) {
+        // For non-unifprm scaling, this would need to be converted to an ellipse collider or a convex hull.
+        self.scale = scale.max_element();
+        self.radius = self.unscaled_radius * scale.max_element();
+    }
+}
+
+/// A marker component for the rotating body at the center.
+#[derive(Component)]
+struct CenterBody;
+
+fn setup(
+    mut commands: Commands,
+    mut materials: ResMut<Assets<ColorMaterial>>,
+    mut meshes: ResMut<Assets<Mesh>>,
+) {
+    commands.spawn(Camera2dBundle::default());
+
+    let center_radius = 200.0;
+    let particle_radius = 5.0;
+
+    let red = materials.add(Color::rgb(0.9, 0.3, 0.3).into());
+    let blue = materials.add(Color::rgb(0.1, 0.6, 1.0).into());
+    let particle_mesh = meshes.add(shape::Circle::new(particle_radius).into());
+
+    // Spawn rotating body at the center.
+    commands
+        .spawn((
+            MaterialMesh2dBundle {
+                mesh: meshes.add(shape::Circle::new(center_radius).into()).into(),
+                material: materials.add(Color::rgb(0.7, 0.7, 0.8).into()).clone(),
+                ..default()
+            },
+            RigidBody::Kinematic,
+            CircleCollider::new(center_radius.adjust_precision()),
+            CenterBody,
+        ))
+        .with_children(|c| {
+            // Spawn obstacles along the perimeter of the rotating body, like the teeth of a cog.
+            let count = 8;
+            let angle_step = std::f32::consts::TAU / count as f32;
+            for i in 0..count {
+                let pos = Quat::from_rotation_z(i as f32 * angle_step) * Vec3::Y * center_radius;
+                c.spawn((
+                    MaterialMesh2dBundle {
+                        mesh: particle_mesh.clone().into(),
+                        material: red.clone(),
+                        transform: Transform::from_translation(pos).with_scale(Vec3::ONE * 5.0),
+                        ..default()
+                    },
+                    CircleCollider::new(particle_radius.adjust_precision()),
+                ));
+            }
+        });
+
+    let x_count = 10;
+    let y_count = 30;
+
+    // Spawm grid of particles. These will be pulled towards the rotating body.
+    for x in -x_count / 2..x_count / 2 {
+        for y in -y_count / 2..y_count / 2 {
+            commands.spawn((
+                MaterialMesh2dBundle {
+                    mesh: particle_mesh.clone().into(),
+                    material: blue.clone(),
+                    transform: Transform::from_xyz(
+                        x as f32 * 3.0 * particle_radius - 350.0,
+                        y as f32 * 3.0 * particle_radius,
+                        0.0,
+                    ),
+                    ..default()
+                },
+                RigidBody::Dynamic,
+                CircleCollider::new(particle_radius.adjust_precision()),
+                LinearDamping(0.4),
+            ));
+        }
+    }
+}
+
+/// Pulls all particles towards the center.
+fn center_gravity(
+    mut particles: Query<(&Transform, &mut LinearVelocity), Without<CenterBody>>,
+    time: Res<Time>,
+) {
+    let delta_seconds = time.delta_seconds_f64().adjust_precision();
+    for (transform, mut lin_vel) in &mut particles {
+        let pos_delta = transform.translation.truncate().adjust_precision();
+        let dir = -pos_delta.normalize_or_zero();
+        lin_vel.0 += 800.0 * delta_seconds * dir;
+    }
+}
+
+/// Rotates the center body periodically clockwise and counterclockwise.
+fn rotate(mut query: Query<&mut AngularVelocity, With<CenterBody>>, time: Res<Time>) {
+    let sin = 3.0 * time.elapsed_seconds_f64().adjust_precision().sin();
+    for mut ang_vel in &mut query {
+        ang_vel.0 = sin;
+    }
+}
diff --git a/src/components/mass_properties.rs b/src/components/mass_properties.rs
index 27187c73..0854f248 100644
--- a/src/components/mass_properties.rs
+++ b/src/components/mass_properties.rs
@@ -309,7 +309,7 @@ impl Default for ColliderDensity {
 ///
 /// fn print_collider_masses(query: Query<&ColliderMassProperties>) {
 ///     for mass_props in &query {
-///         println!("{}", mass_props.mass());
+///         println!("{}", mass_props.mass.0);
 ///     }
 /// }
 /// ```
@@ -318,15 +318,15 @@ impl Default for ColliderDensity {
 #[reflect(Component)]
 pub struct ColliderMassProperties {
     /// Mass given by collider.
-    pub(crate) mass: Mass,
+    pub mass: Mass,
     /// Inverse mass given by collider.
-    pub(crate) inverse_mass: InverseMass,
+    pub inverse_mass: InverseMass,
     /// Inertia given by collider.
-    pub(crate) inertia: Inertia,
+    pub inertia: Inertia,
     /// Inverse inertia given by collider.
-    pub(crate) inverse_inertia: InverseInertia,
+    pub inverse_inertia: InverseInertia,
     /// Local center of mass given by collider.
-    pub(crate) center_of_mass: CenterOfMass,
+    pub center_of_mass: CenterOfMass,
 }
 
 impl ColliderMassProperties {
@@ -339,68 +339,12 @@ impl ColliderMassProperties {
         center_of_mass: CenterOfMass::ZERO,
     };
 
-    /// Computes mass properties from a given [`Collider`] and density.
+    /// Computes mass properties from a given collider and density.
     ///
     /// Because [`ColliderMassProperties`] is read-only, adding this as a component manually
     /// has no effect. The mass properties will be recomputed using the [`ColliderDensity`].
-    pub fn new(collider: &Collider, density: Scalar) -> Self {
-        let props = collider.shape_scaled().mass_properties(density);
-
-        Self {
-            mass: Mass(props.mass()),
-            inverse_mass: InverseMass(props.inv_mass),
-
-            #[cfg(feature = "2d")]
-            inertia: Inertia(props.principal_inertia()),
-            #[cfg(feature = "3d")]
-            inertia: Inertia(props.reconstruct_inertia_matrix().into()),
-
-            #[cfg(feature = "2d")]
-            inverse_inertia: InverseInertia(1.0 / props.principal_inertia()),
-            #[cfg(feature = "3d")]
-            inverse_inertia: InverseInertia(props.reconstruct_inverse_inertia_matrix().into()),
-
-            center_of_mass: CenterOfMass(props.local_com.into()),
-        }
-    }
-
-    /// Get the [mass](Mass) of the [`Collider`].
-    pub fn mass(&self) -> Scalar {
-        self.mass.0
-    }
-
-    /// Get the [inverse mass](InverseMass) of the [`Collider`].
-    pub fn inverse_mass(&self) -> Scalar {
-        self.inverse_mass.0
-    }
-
-    /// Get the [inerta](Inertia) of the [`Collider`].
-    #[cfg(feature = "2d")]
-    pub fn inertia(&self) -> Scalar {
-        self.inertia.0
-    }
-
-    /// Get the [inertia tensor](InverseInertia) of the [`Collider`].
-    #[cfg(feature = "3d")]
-    pub fn inertia(&self) -> Matrix3 {
-        self.inertia.0
-    }
-
-    /// Get the [inverse inertia](InverseInertia) of the [`Collider`].
-    #[cfg(feature = "2d")]
-    pub fn inverse_inertia(&self) -> Scalar {
-        self.inverse_inertia.0
-    }
-
-    /// Get the [inverse inertia](InverseInertia) of the [`Collider`].
-    #[cfg(feature = "3d")]
-    pub fn inverse_inertia(&self) -> Matrix3 {
-        self.inverse_inertia.0
-    }
-
-    /// Get the [local center of mass](CenterOfMass) of the [`Collider`].
-    pub fn center_of_mass(&self) -> Vector {
-        self.center_of_mass.0
+    pub fn new<C: AnyCollider>(collider: &C, density: Scalar) -> Self {
+        collider.mass_properties(density)
     }
 }
 
diff --git a/src/components/mod.rs b/src/components/mod.rs
index 35aa755b..64e6382a 100644
--- a/src/components/mod.rs
+++ b/src/components/mod.rs
@@ -1,6 +1,5 @@
-//! Components used for rigid bodies, colliders and mass properties.
+//! Commonly used components.
 
-mod collider;
 mod forces;
 mod layers;
 mod locked_axes;
@@ -8,7 +7,6 @@ mod mass_properties;
 mod rotation;
 mod world_queries;
 
-pub use collider::*;
 pub use forces::*;
 pub use layers::*;
 pub use locked_axes::*;
diff --git a/src/components/rotation.rs b/src/components/rotation.rs
index 370821c8..57959b3b 100644
--- a/src/components/rotation.rs
+++ b/src/components/rotation.rs
@@ -146,7 +146,7 @@ impl Rotation {
         self.as_radians().to_degrees()
     }
 
-    /// Rotates the rotation by a given vector.
+    /// Rotates the given vector by `self`.
     pub fn rotate(&self, vec: Vector) -> Vector {
         Vector::new(
             vec.x * self.cos() - vec.y * self.sin(),
diff --git a/src/components/world_queries.rs b/src/components/world_queries.rs
index c415ca4f..e300ce27 100644
--- a/src/components/world_queries.rs
+++ b/src/components/world_queries.rs
@@ -93,7 +93,7 @@ impl<'w> RigidBodyQueryItem<'w> {
 
 #[derive(WorldQuery)]
 #[world_query(mutable)]
-pub(crate) struct MassPropertiesQuery {
+pub struct MassPropertiesQuery {
     pub mass: &'static mut Mass,
     pub inverse_mass: &'static mut InverseMass,
     pub inertia: &'static mut Inertia,
diff --git a/src/lib.rs b/src/lib.rs
index b8e78fa5..5a20cc64 100644
--- a/src/lib.rs
+++ b/src/lib.rs
@@ -536,7 +536,7 @@ pub mod prelude {
                 narrow_phase::NarrowPhaseConfig,
                 *,
             },
-            prepare::*,
+            prepare::{init_transforms, update_mass_properties, PrepareConfig, PreparePlugin},
             setup::*,
             solver::solve_constraint,
             spatial_query::*,
diff --git a/src/plugins/collision/broad_phase.rs b/src/plugins/collision/broad_phase.rs
index 49761d0c..0c00acc0 100644
--- a/src/plugins/collision/broad_phase.rs
+++ b/src/plugins/collision/broad_phase.rs
@@ -22,141 +22,52 @@ impl Plugin for BroadPhasePlugin {
     fn build(&self, app: &mut App) {
         app.init_resource::<AabbIntervals>();
 
+        app.configure_sets(
+            PhysicsSchedule,
+            (
+                BroadPhaseSet::First,
+                BroadPhaseSet::UpdateStructures,
+                BroadPhaseSet::CollectCollisions,
+                BroadPhaseSet::Last,
+            )
+                .chain()
+                .in_set(PhysicsStepSet::BroadPhase),
+        );
+
         let physics_schedule = app
             .get_schedule_mut(PhysicsSchedule)
             .expect("add PhysicsSchedule first");
 
         physics_schedule.add_systems(
-            (
-                update_aabb,
-                update_aabb_intervals,
-                add_new_aabb_intervals,
-                collect_collision_pairs,
-            )
+            (update_aabb_intervals, add_new_aabb_intervals)
                 .chain()
-                .in_set(PhysicsStepSet::BroadPhase),
+                .in_set(BroadPhaseSet::UpdateStructures),
         );
+
+        physics_schedule
+            .add_systems(collect_collision_pairs.in_set(BroadPhaseSet::CollectCollisions));
     }
 }
 
+/// System sets for systems running in [`PhysicsStepSet::BroadPhase`].
+#[derive(SystemSet, Clone, Copy, Debug, PartialEq, Eq, Hash)]
+pub enum BroadPhaseSet {
+    /// Runs at the start of the broad phase. Empty by default.
+    First,
+    /// Updates acceleration structures and other data needed for broad phase collision detection.
+    UpdateStructures,
+    /// Detects potential intersections between entities and adds them to the [`BroadCollisionPairs`] resource.
+    CollectCollisions,
+    /// Runs at the end of the broad phase. Empty by default.
+    Last,
+}
+
 /// A list of entity pairs for potential collisions collected during the broad phase.
 #[derive(Reflect, Resource, Default, Debug)]
 #[cfg_attr(feature = "serialize", derive(serde::Serialize, serde::Deserialize))]
 #[reflect(Resource)]
 pub struct BroadCollisionPairs(pub Vec<(Entity, Entity)>);
 
-type AABBChanged = Or<(
-    Changed<Position>,
-    Changed<Rotation>,
-    Changed<LinearVelocity>,
-    Changed<AngularVelocity>,
-    Changed<Collider>,
-)>;
-
-/// Updates the Axis-Aligned Bounding Boxes of all colliders. A safety margin will be added to account for sudden accelerations.
-#[allow(clippy::type_complexity)]
-fn update_aabb(
-    mut colliders: Query<
-        (
-            &Collider,
-            &mut ColliderAabb,
-            &Position,
-            &Rotation,
-            Option<&ColliderParent>,
-            Option<&LinearVelocity>,
-            Option<&AngularVelocity>,
-        ),
-        AABBChanged,
-    >,
-    parent_velocity: Query<
-        (&Position, Option<&LinearVelocity>, Option<&AngularVelocity>),
-        With<Children>,
-    >,
-    dt: Res<Time>,
-    narrow_phase_config: Option<Res<NarrowPhaseConfig>>,
-) {
-    // Safety margin multiplier bigger than DELTA_TIME to account for sudden accelerations
-    let safety_margin_factor = 2.0 * dt.delta_seconds_adjusted();
-
-    for (collider, mut aabb, pos, rot, collider_parent, lin_vel, ang_vel) in &mut colliders {
-        let (lin_vel, ang_vel) = if let (Some(lin_vel), Some(ang_vel)) = (lin_vel, ang_vel) {
-            (*lin_vel, *ang_vel)
-        } else if let Some(Ok((parent_pos, Some(lin_vel), Some(ang_vel)))) =
-            collider_parent.map(|p| parent_velocity.get(p.get()))
-        {
-            // If the rigid body is rotating, off-center colliders will orbit around it,
-            // which affects their linear velocities. We need to compute the linear velocity
-            // at the offset position.
-            // TODO: This assumes that the colliders would continue moving in the same direction,
-            //       but because they are orbiting, the direction will change. We should take
-            //       into account the uniform circular motion.
-            let offset = pos.0 - parent_pos.0;
-            #[cfg(feature = "2d")]
-            let vel_at_offset =
-                lin_vel.0 + Vector::new(-ang_vel.0 * offset.y, ang_vel.0 * offset.x) * 1.0;
-            #[cfg(feature = "3d")]
-            let vel_at_offset = lin_vel.0 + ang_vel.cross(offset);
-            (LinearVelocity(vel_at_offset), *ang_vel)
-        } else {
-            (LinearVelocity::ZERO, AngularVelocity::ZERO)
-        };
-
-        // Compute current isometry and predicted isometry for next feame
-        let start_iso = utils::make_isometry(*pos, *rot);
-        let end_iso = {
-            #[cfg(feature = "2d")]
-            {
-                utils::make_isometry(
-                    pos.0 + lin_vel.0 * safety_margin_factor,
-                    *rot + Rotation::from_radians(safety_margin_factor * ang_vel.0),
-                )
-            }
-            #[cfg(feature = "3d")]
-            {
-                let q = Quaternion::from_vec4(ang_vel.0.extend(0.0)) * rot.0;
-                let (x, y, z, w) = (
-                    rot.x + safety_margin_factor * 0.5 * q.x,
-                    rot.y + safety_margin_factor * 0.5 * q.y,
-                    rot.z + safety_margin_factor * 0.5 * q.z,
-                    rot.w + safety_margin_factor * 0.5 * q.w,
-                );
-                utils::make_isometry(
-                    pos.0 + lin_vel.0 * safety_margin_factor,
-                    Quaternion::from_xyzw(x, y, z, w).normalize(),
-                )
-            }
-        };
-
-        // Compute swept AABB, the space that the body would occupy if it was integrated for one frame
-        aabb.0 = collider
-            .shape_scaled()
-            .compute_swept_aabb(&start_iso, &end_iso);
-
-        // Add narrow phase prediction distance to AABBs to avoid missed collisions
-        let prediction_distance = if let Some(ref config) = narrow_phase_config {
-            config.prediction_distance
-        } else {
-            #[cfg(feature = "2d")]
-            {
-                1.0
-            }
-            #[cfg(feature = "3d")]
-            {
-                0.005
-            }
-        };
-        aabb.maxs.x += prediction_distance;
-        aabb.mins.x -= prediction_distance;
-        aabb.maxs.y += prediction_distance;
-        aabb.mins.y -= prediction_distance;
-        #[cfg(feature = "3d")]
-        {
-            aabb.maxs.z += prediction_distance;
-            aabb.mins.z -= prediction_distance;
-        }
-    }
-}
-
 /// True if the rigid body hasn't moved.
 type IsBodyInactive = bool;
 
diff --git a/src/components/collider.rs b/src/plugins/collision/collider.rs
similarity index 91%
rename from src/components/collider.rs
rename to src/plugins/collision/collider.rs
index d711c2cc..4cd6d863 100644
--- a/src/components/collider.rs
+++ b/src/plugins/collision/collider.rs
@@ -14,7 +14,7 @@ use bevy::{
 use collision::contact_query::UnsupportedShape;
 use itertools::Either;
 use parry::{
-    bounding_volume::Aabb,
+    bounding_volume::{Aabb, BoundingVolume},
     shape::{RoundShape, SharedShape, TypedShape},
 };
 
@@ -26,6 +26,73 @@ pub type VHACDParameters = parry::transformation::vhacd::VHACDParameters;
 /// Flags used for the preprocessing of a triangle mesh collider.
 pub type TriMeshFlags = parry::shape::TriMeshFlags;
 
+/// A trait that generalizes over colliders. Implementing this trait
+/// allows colliders to be used with the physics engine.
+pub trait AnyCollider: Component {
+    /// Computes the [Axis-Aligned Bounding Box](ColliderAabb) of the collider
+    /// with the given position and rotation.
+    #[cfg_attr(
+        feature = "2d",
+        doc = "\n\nThe rotation is counterclockwise and in radians."
+    )]
+    fn aabb(&self, position: Vector, rotation: impl Into<Rotation>) -> ColliderAabb;
+
+    /// Computes the swept [Axis-Aligned Bounding Box](ColliderAabb) of the collider.
+    /// This corresponds to the space the shape would occupy if it moved from the given
+    /// start position to the given end position.
+    #[cfg_attr(
+        feature = "2d",
+        doc = "\n\nThe rotation is counterclockwise and in radians."
+    )]
+    fn swept_aabb(
+        &self,
+        start_position: Vector,
+        start_rotation: impl Into<Rotation>,
+        end_position: Vector,
+        end_rotation: impl Into<Rotation>,
+    ) -> ColliderAabb {
+        self.aabb(start_position, start_rotation)
+            .merged(self.aabb(end_position, end_rotation))
+    }
+
+    /// Computes the collider's mass properties based on its shape and a given density.
+    fn mass_properties(&self, density: Scalar) -> ColliderMassProperties;
+
+    /// Computes all [`ContactManifold`]s between two colliders.
+    ///
+    /// Returns an empty vector if the colliders are separated by a distance greater than `prediction_distance`
+    /// or if the given shapes are invalid.
+    fn contact_manifolds(
+        &self,
+        other: &Self,
+        position1: Vector,
+        rotation1: impl Into<Rotation>,
+        position2: Vector,
+        rotation2: impl Into<Rotation>,
+        prediction_distance: Scalar,
+    ) -> Vec<ContactManifold>;
+}
+
+/// A trait for colliders that support scaling.
+pub trait ScalableCollider: AnyCollider {
+    /// Returns the global scaling factor of the collider.
+    fn scale(&self) -> Vector;
+
+    /// Sets the global scaling factor of the collider.
+    ///
+    /// If the scaling factor is not uniform and the resulting scaled shape
+    /// can not be represented exactly, the given `detail` is used for an approximation.
+    fn set_scale(&mut self, scale: Vector, detail: u32);
+
+    /// Scales the collider by the given scaling factor.
+    ///
+    /// If the scaling factor is not uniform and the resulting scaled shape
+    /// can not be represented exactly, the given `detail` is used for an approximation.
+    fn scale_by(&mut self, factor: Vector, detail: u32) {
+        self.set_scale(factor * self.scale(), detail)
+    }
+}
+
 /// A collider used for detecting collisions and generating contacts.
 ///
 /// ## Creation
@@ -216,6 +283,66 @@ impl fmt::Debug for Collider {
     }
 }
 
+impl AnyCollider for Collider {
+    fn aabb(&self, position: Vector, rotation: impl Into<Rotation>) -> ColliderAabb {
+        ColliderAabb(
+            self.shape_scaled()
+                .compute_aabb(&utils::make_isometry(position, rotation)),
+        )
+    }
+
+    fn mass_properties(&self, density: Scalar) -> ColliderMassProperties {
+        let props = self.shape_scaled().mass_properties(density);
+
+        ColliderMassProperties {
+            mass: Mass(props.mass()),
+            inverse_mass: InverseMass(props.inv_mass),
+
+            #[cfg(feature = "2d")]
+            inertia: Inertia(props.principal_inertia()),
+            #[cfg(feature = "3d")]
+            inertia: Inertia(props.reconstruct_inertia_matrix().into()),
+
+            #[cfg(feature = "2d")]
+            inverse_inertia: InverseInertia(1.0 / props.principal_inertia()),
+            #[cfg(feature = "3d")]
+            inverse_inertia: InverseInertia(props.reconstruct_inverse_inertia_matrix().into()),
+
+            center_of_mass: CenterOfMass(props.local_com.into()),
+        }
+    }
+
+    fn contact_manifolds(
+        &self,
+        other: &Self,
+        position1: Vector,
+        rotation1: impl Into<Rotation>,
+        position2: Vector,
+        rotation2: impl Into<Rotation>,
+        prediction_distance: Scalar,
+    ) -> Vec<ContactManifold> {
+        contact_query::contact_manifolds(
+            self,
+            position1,
+            rotation1,
+            other,
+            position2,
+            rotation2,
+            prediction_distance,
+        )
+    }
+}
+
+impl ScalableCollider for Collider {
+    fn scale(&self) -> Vector {
+        self.scale()
+    }
+
+    fn set_scale(&mut self, scale: Vector, detail: u32) {
+        self.set_scale(scale, detail)
+    }
+}
+
 impl Collider {
     /// Returns the raw unscaled shape of the collider.
     pub fn shape(&self) -> &SharedShape {
@@ -227,11 +354,6 @@ impl Collider {
         &self.scaled_shape
     }
 
-    /// Returns the global scale of the collider.
-    pub fn scale(&self) -> Vector {
-        self.scale
-    }
-
     /// Sets the unscaled shape of the collider. The collider's scale will be applied to this shape.
     pub fn set_shape(&mut self, shape: SharedShape) {
         self.shape = shape;
@@ -244,6 +366,11 @@ impl Collider {
         }
     }
 
+    /// Returns the global scale of the collider.
+    pub fn scale(&self) -> Vector {
+        self.scale
+    }
+
     /// Set the global scaling factor of this shape.
     ///
     /// If the scaling factor is not uniform, and the scaled shape can’t be
@@ -271,29 +398,6 @@ impl Collider {
         }
     }
 
-    /// Computes the [Axis-Aligned Bounding Box](ColliderAabb) of the collider.
-    #[cfg(feature = "2d")]
-    pub fn compute_aabb(&self, position: Vector, rotation: Scalar) -> ColliderAabb {
-        ColliderAabb(self.shape_scaled().compute_aabb(&utils::make_isometry(
-            position,
-            Rotation::from_radians(rotation),
-        )))
-    }
-
-    /// Computes the [Axis-Aligned Bounding Box](ColliderAabb) of the collider.
-    #[cfg(feature = "3d")]
-    pub fn compute_aabb(&self, position: Vector, rotation: Quaternion) -> ColliderAabb {
-        ColliderAabb(
-            self.shape_scaled()
-                .compute_aabb(&utils::make_isometry(position, Rotation(rotation))),
-        )
-    }
-
-    /// Computes the collider's mass properties based on its shape and a given density.
-    pub fn mass_properties(&self, density: Scalar) -> ColliderMassProperties {
-        ColliderMassProperties::new(self, density)
-    }
-
     /// Projects the given `point` onto `self` transformed by `translation` and `rotation`.
     /// The returned tuple contains the projected point and whether it is inside the collider.
     ///
@@ -1287,10 +1391,20 @@ pub struct Sensor;
 pub struct ColliderAabb(pub Aabb);
 
 impl ColliderAabb {
-    /// Creates a new collider from a given [`SharedShape`] with a default density of 1.0.
+    /// Creates a new [`ColliderAabb`] from the given `center` and `half_size`.
+    pub fn new(center: Vector, half_size: Vector) -> Self {
+        Self(Aabb::from_half_extents(center.into(), half_size.into()))
+    }
+
+    /// Creates a new [`ColliderAabb`] from a given [`SharedShape`].
     pub fn from_shape(shape: &SharedShape) -> Self {
         Self(shape.compute_local_aabb())
     }
+
+    /// Merges this AABB with another one.
+    pub fn merged(self, other: Self) -> Self {
+        ColliderAabb(self.0.merged(&other.0))
+    }
 }
 
 impl Default for ColliderAabb {
diff --git a/src/plugins/collision/collider_backend.rs b/src/plugins/collision/collider_backend.rs
new file mode 100644
index 00000000..469b2f59
--- /dev/null
+++ b/src/plugins/collision/collider_backend.rs
@@ -0,0 +1,884 @@
+//! Handles generic collider backend logic, like initializing colliders and AABBs and updating related components.
+//!
+//! See [`ColliderBackendPlugin`].
+
+use std::marker::PhantomData;
+
+use crate::{
+    broad_phase::BroadPhaseSet,
+    prelude::*,
+    prepare::{any_new, PrepareSet},
+    sync::SyncSet,
+};
+#[cfg(all(feature = "3d", feature = "async-collider"))]
+use bevy::scene::SceneInstance;
+use bevy::{
+    prelude::*,
+    utils::{intern::Interned, HashMap},
+};
+
+/// A plugin for handling generic collider backend logic.
+///
+/// - Initializes colliders.
+/// - Updates [`ColliderAabb`]s.
+/// - Updates [`ColliderParent`]s.
+/// - Updates collider mass properties.
+/// - Updates collider scale based on `Transform` scale.
+/// - Propagates child collider positions.
+///
+/// ## Custom collision backends
+///
+/// By default, [`PhysicsPlugins`] adds this plugin for the [`Collider`] component.
+/// You can also create custom collider backends by implementing the [`AnyCollider`] and [`ScalableCollider`] traits.
+///
+/// To use a custom collider backend, simply add the [`ColliderBackendPlugin`] with your collider type:
+///
+/// ```no_run
+/// use bevy::prelude::*;
+#[cfg_attr(feature = "2d", doc = "use bevy_xpbd_2d::prelude::*;")]
+#[cfg_attr(feature = "3d", doc = "use bevy_xpbd_3d::prelude::*;")]
+/// #
+/// # type MyCollider = Collider;
+///
+/// fn main() {
+///     App::new()
+///         .add_plugins((
+///             DefaultPlugins,
+///             PhysicsPlugins::default(),
+///             // MyCollider must implement AnyCollider and ScalableCollider.
+///             ColliderBackendPlugin::<MyCollider>::default(),
+///             // To enable collision detection for the collider,
+///             // we also need to add the NarrowPhasePlugin for it.
+///             NarrowPhasePlugin::<MyCollider>::default(),
+///         ))
+///         // ...your other plugins, systems and resources
+///         .run();
+/// }
+/// ```
+///
+/// Assuming you have implemented [`AnyCollider`] and [`ScalableCollider`] correctly,
+/// it should now work with the rest of the engine just like normal [`Collider`]s!
+///
+/// **Note**: [Spatial queries](spatial_query) are not supported for custom colliders yet.
+
+pub struct ColliderBackendPlugin<C: ScalableCollider> {
+    schedule: Interned<dyn ScheduleLabel>,
+    _phantom: PhantomData<C>,
+}
+
+impl<C: ScalableCollider> ColliderBackendPlugin<C> {
+    /// Creates a [`ColliderBackendPlugin`] with the schedule that is used for running the [`PhysicsSchedule`].
+    ///
+    /// The default schedule is `PostUpdate`.
+    pub fn new(schedule: impl ScheduleLabel) -> Self {
+        Self {
+            schedule: schedule.intern(),
+            _phantom: PhantomData,
+        }
+    }
+}
+
+impl<C: ScalableCollider> Default for ColliderBackendPlugin<C> {
+    fn default() -> Self {
+        Self {
+            schedule: PostUpdate.intern(),
+            _phantom: PhantomData,
+        }
+    }
+}
+
+impl<C: ScalableCollider> Plugin for ColliderBackendPlugin<C> {
+    fn build(&self, app: &mut App) {
+        app.init_resource::<ColliderStorageMap<C>>();
+
+        app.add_systems(
+            self.schedule,
+            (
+                (
+                    init_colliders::<C>,
+                    apply_deferred,
+                    update_collider_parents::<C>,
+                    apply_deferred,
+                )
+                    .chain()
+                    .in_set(PrepareSet::InitColliders),
+                init_transforms::<C>
+                    .in_set(PrepareSet::InitTransforms)
+                    .after(init_transforms::<RigidBody>),
+                (
+                    (
+                        propagate_collider_transforms,
+                        update_child_collider_position,
+                    )
+                        .chain()
+                        .run_if(any_new::<C>),
+                    update_collider_mass_properties::<C>,
+                )
+                    .chain()
+                    .in_set(PrepareSet::Finalize)
+                    .before(prepare::update_mass_properties),
+                update_collider_scale::<C>
+                    .after(SyncSet::Update)
+                    .before(SyncSet::Last),
+            ),
+        );
+
+        let physics_schedule = app
+            .get_schedule_mut(PhysicsSchedule)
+            .expect("add PhysicsSchedule first");
+
+        // Allowing ambiguities is required so that it's possible
+        // to have multiple collision backends at the same time.
+        physics_schedule.add_systems(
+            update_aabb::<C>
+                .in_set(PhysicsStepSet::BroadPhase)
+                .after(BroadPhaseSet::First)
+                .before(BroadPhaseSet::UpdateStructures)
+                .ambiguous_with_all(),
+        );
+
+        physics_schedule.add_systems((
+            update_collider_storage::<C>.before(PhysicsStepSet::BroadPhase),
+            handle_collider_storage_removals::<C>.after(PhysicsStepSet::SpatialQuery),
+            handle_rigid_body_removals.after(PhysicsStepSet::SpatialQuery),
+        ));
+
+        physics_schedule.add_systems(
+            wake_on_collider_removed::<C>
+                .in_set(PhysicsStepSet::Sleeping)
+                .after(sleeping::mark_sleeping_bodies)
+                .before(sleeping::wake_on_changed)
+                // Allowing ambiguities is required so that it's possible
+                // to have multiple collision backends at the same time.
+                .ambiguous_with_all(),
+        );
+
+        #[cfg(all(feature = "3d", feature = "async-collider"))]
+        app.add_systems(Update, (init_async_colliders, init_async_scene_colliders));
+
+        // Update child colliders before narrow phase in substepping loop
+        let substep_schedule = app
+            .get_schedule_mut(SubstepSchedule)
+            .expect("add SubstepSchedule first");
+        substep_schedule.add_systems(
+            (
+                propagate_collider_transforms,
+                update_child_collider_position,
+            )
+                .chain()
+                .after(SubstepSet::Integrate)
+                .before(SubstepSet::NarrowPhase)
+                .ambiguous_with_all(),
+        );
+    }
+}
+
+#[derive(Reflect, Clone, Copy, Component, Debug, Default, Deref, DerefMut, PartialEq)]
+#[reflect(Component)]
+pub(crate) struct PreviousColliderTransform(ColliderTransform);
+
+// TODO: Remove this once component removal hooks exist
+/// A hash map that stores some collider data that is needed when colliders are removed from
+/// rigid bodies.
+///
+/// This includes the collider parent for finding the associated rigid body after collider removal,
+/// and collider mass properties for updating the rigid body's mass properties when its collider is removed.
+///
+/// Ideally, we would just have some entity removal event or callback, but that doesn't
+/// exist yet, and `RemovedComponents` only returns entities, not component data.
+#[derive(Resource, Reflect, Clone, Debug, PartialEq)]
+#[reflect(Resource)]
+pub(crate) struct ColliderStorageMap<C: AnyCollider> {
+    pub(crate) map: HashMap<Entity, (ColliderParent, ColliderMassProperties, ColliderTransform)>,
+    _phantom: PhantomData<C>,
+}
+
+impl<C: AnyCollider> Default for ColliderStorageMap<C> {
+    fn default() -> Self {
+        Self {
+            map: default(),
+            _phantom: PhantomData,
+        }
+    }
+}
+
+/// Initializes missing components for [colliders](Collider).
+#[allow(clippy::type_complexity)]
+fn init_colliders<C: AnyCollider>(
+    mut commands: Commands,
+    mut colliders: Query<
+        (
+            Entity,
+            &C,
+            Option<&ColliderAabb>,
+            Option<&ColliderDensity>,
+            Option<&ColliderMassProperties>,
+        ),
+        Added<C>,
+    >,
+) {
+    for (entity, collider, aabb, density, mass_properties) in &mut colliders {
+        let density = *density.unwrap_or(&ColliderDensity::default());
+        commands.entity(entity).insert((
+            *aabb.unwrap_or(&collider.aabb(Vector::ZERO, Rotation::default())),
+            density,
+            *mass_properties.unwrap_or(&collider.mass_properties(density.0)),
+            CollidingEntities::default(),
+        ));
+    }
+}
+
+/// Creates [`Collider`]s from [`AsyncCollider`]s if the meshes have become available.
+#[cfg(all(feature = "3d", feature = "async-collider"))]
+pub fn init_async_colliders(
+    mut commands: Commands,
+    meshes: Res<Assets<Mesh>>,
+    async_colliders: Query<(Entity, &Handle<Mesh>, &AsyncCollider)>,
+) {
+    for (entity, mesh_handle, async_collider) in async_colliders.iter() {
+        if let Some(mesh) = meshes.get(mesh_handle) {
+            let collider = match &async_collider.0 {
+                ComputedCollider::TriMesh => Collider::trimesh_from_mesh(mesh),
+                ComputedCollider::TriMeshWithFlags(flags) => {
+                    Collider::trimesh_from_mesh_with_config(mesh, *flags)
+                }
+                ComputedCollider::ConvexHull => Collider::convex_hull_from_mesh(mesh),
+                ComputedCollider::ConvexDecomposition(params) => {
+                    Collider::convex_decomposition_from_mesh_with_config(mesh, params)
+                }
+            };
+            if let Some(collider) = collider {
+                commands
+                    .entity(entity)
+                    .insert(collider)
+                    .remove::<AsyncCollider>();
+            } else {
+                error!("Unable to generate collider from mesh {:?}", mesh);
+            }
+        }
+    }
+}
+
+/// Creates [`Collider`]s from [`AsyncSceneCollider`]s if the scenes have become available.
+#[cfg(all(feature = "3d", feature = "async-collider"))]
+pub fn init_async_scene_colliders(
+    mut commands: Commands,
+    meshes: Res<Assets<Mesh>>,
+    scene_spawner: Res<SceneSpawner>,
+    async_colliders: Query<(Entity, &SceneInstance, &AsyncSceneCollider)>,
+    children: Query<&Children>,
+    mesh_handles: Query<(&Name, &Handle<Mesh>)>,
+) {
+    for (scene_entity, scene_instance, async_scene_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 Some(collider_data) = async_scene_collider
+                        .meshes_by_name
+                        .get(name.as_str())
+                        .cloned()
+                        .unwrap_or(
+                            async_scene_collider
+                                .default_shape
+                                .clone()
+                                .map(|shape| AsyncSceneColliderData { shape, ..default() }),
+                        )
+                    else {
+                        continue;
+                    };
+
+                    let mesh = meshes.get(handle).expect("mesh should already be loaded");
+
+                    let collider = match collider_data.shape {
+                        ComputedCollider::TriMesh => Collider::trimesh_from_mesh(mesh),
+                        ComputedCollider::TriMeshWithFlags(flags) => {
+                            Collider::trimesh_from_mesh_with_config(mesh, flags)
+                        }
+                        ComputedCollider::ConvexHull => Collider::convex_hull_from_mesh(mesh),
+                        ComputedCollider::ConvexDecomposition(params) => {
+                            Collider::convex_decomposition_from_mesh_with_config(mesh, &params)
+                        }
+                    };
+                    if let Some(collider) = collider {
+                        commands.entity(child_entity).insert((
+                            collider,
+                            collider_data.layers,
+                            ColliderDensity(collider_data.density),
+                        ));
+                    } else {
+                        error!(
+                            "unable to generate collider from mesh {:?} with name {}",
+                            mesh, name
+                        );
+                    }
+                }
+            }
+
+            commands.entity(scene_entity).remove::<AsyncSceneCollider>();
+        }
+    }
+}
+
+/// Updates the Axis-Aligned Bounding Boxes of all colliders. A safety margin will be added to account for sudden accelerations.
+#[allow(clippy::type_complexity)]
+fn update_aabb<C: AnyCollider>(
+    mut colliders: Query<
+        (
+            &C,
+            &mut ColliderAabb,
+            &Position,
+            &Rotation,
+            Option<&ColliderParent>,
+            Option<&LinearVelocity>,
+            Option<&AngularVelocity>,
+        ),
+        Or<(
+            Changed<Position>,
+            Changed<Rotation>,
+            Changed<LinearVelocity>,
+            Changed<AngularVelocity>,
+            Changed<C>,
+        )>,
+    >,
+    parent_velocity: Query<
+        (&Position, Option<&LinearVelocity>, Option<&AngularVelocity>),
+        With<Children>,
+    >,
+    dt: Res<Time>,
+    narrow_phase_config: Option<Res<NarrowPhaseConfig>>,
+) {
+    // Safety margin multiplier bigger than DELTA_TIME to account for sudden accelerations
+    let safety_margin_factor = 2.0 * dt.delta_seconds_adjusted();
+
+    for (collider, mut aabb, pos, rot, collider_parent, lin_vel, ang_vel) in &mut colliders {
+        let (lin_vel, ang_vel) = if let (Some(lin_vel), Some(ang_vel)) = (lin_vel, ang_vel) {
+            (*lin_vel, *ang_vel)
+        } else if let Some(Ok((parent_pos, Some(lin_vel), Some(ang_vel)))) =
+            collider_parent.map(|p| parent_velocity.get(p.get()))
+        {
+            // If the rigid body is rotating, off-center colliders will orbit around it,
+            // which affects their linear velocities. We need to compute the linear velocity
+            // at the offset position.
+            // TODO: This assumes that the colliders would continue moving in the same direction,
+            //       but because they are orbiting, the direction will change. We should take
+            //       into account the uniform circular motion.
+            let offset = pos.0 - parent_pos.0;
+            #[cfg(feature = "2d")]
+            let vel_at_offset =
+                lin_vel.0 + Vector::new(-ang_vel.0 * offset.y, ang_vel.0 * offset.x) * 1.0;
+            #[cfg(feature = "3d")]
+            let vel_at_offset = lin_vel.0 + ang_vel.cross(offset);
+            (LinearVelocity(vel_at_offset), *ang_vel)
+        } else {
+            (LinearVelocity::ZERO, AngularVelocity::ZERO)
+        };
+
+        // Current position and predicted position for next feame
+        let (start_pos, start_rot) = (*pos, *rot);
+        let (end_pos, end_rot) = {
+            #[cfg(feature = "2d")]
+            {
+                (
+                    pos.0 + lin_vel.0 * safety_margin_factor,
+                    *rot + Rotation::from_radians(safety_margin_factor * ang_vel.0),
+                )
+            }
+            #[cfg(feature = "3d")]
+            {
+                let q = Quaternion::from_vec4(ang_vel.0.extend(0.0)) * rot.0;
+                let (x, y, z, w) = (
+                    rot.x + safety_margin_factor * 0.5 * q.x,
+                    rot.y + safety_margin_factor * 0.5 * q.y,
+                    rot.z + safety_margin_factor * 0.5 * q.z,
+                    rot.w + safety_margin_factor * 0.5 * q.w,
+                );
+                (
+                    pos.0 + lin_vel.0 * safety_margin_factor,
+                    Quaternion::from_xyzw(x, y, z, w).normalize(),
+                )
+            }
+        };
+
+        // Compute swept AABB, the space that the body would occupy if it was integrated for one frame
+        aabb.0 = *collider.swept_aabb(start_pos.0, start_rot, end_pos, end_rot);
+
+        // Add narrow phase prediction distance to AABBs to avoid missed collisions
+        let prediction_distance = if let Some(ref config) = narrow_phase_config {
+            config.prediction_distance
+        } else {
+            #[cfg(feature = "2d")]
+            {
+                1.0
+            }
+            #[cfg(feature = "3d")]
+            {
+                0.005
+            }
+        };
+        aabb.maxs.x += prediction_distance;
+        aabb.mins.x -= prediction_distance;
+        aabb.maxs.y += prediction_distance;
+        aabb.mins.y -= prediction_distance;
+        #[cfg(feature = "3d")]
+        {
+            aabb.maxs.z += prediction_distance;
+            aabb.mins.z -= prediction_distance;
+        }
+    }
+}
+
+#[allow(clippy::type_complexity)]
+fn update_collider_parents<C: AnyCollider>(
+    mut commands: Commands,
+    mut bodies: Query<(Entity, Option<&mut ColliderParent>, Has<C>), With<RigidBody>>,
+    children: Query<&Children>,
+    mut child_colliders: Query<Option<&mut ColliderParent>, (With<C>, Without<RigidBody>)>,
+) {
+    for (entity, collider_parent, has_collider) in &mut bodies {
+        if has_collider {
+            if let Some(mut collider_parent) = collider_parent {
+                collider_parent.0 = entity;
+            } else {
+                commands.entity(entity).insert((
+                    ColliderParent(entity),
+                    // Todo: This probably causes a one frame delay. Compute real value?
+                    ColliderTransform::default(),
+                    PreviousColliderTransform::default(),
+                ));
+            }
+        }
+        for child in children.iter_descendants(entity) {
+            if let Ok(collider_parent) = child_colliders.get_mut(child) {
+                if let Some(mut collider_parent) = collider_parent {
+                    collider_parent.0 = entity;
+                } else {
+                    commands.entity(child).insert((
+                        ColliderParent(entity),
+                        // Todo: This probably causes a one frame delay. Compute real value?
+                        ColliderTransform::default(),
+                        PreviousColliderTransform::default(),
+                    ));
+                }
+            }
+        }
+    }
+}
+
+/// Updates colliders when the rigid bodies they were attached to have been removed.
+fn handle_rigid_body_removals(
+    mut commands: Commands,
+    colliders: Query<(Entity, &ColliderParent), Without<RigidBody>>,
+    bodies: Query<(), With<RigidBody>>,
+    removals: RemovedComponents<RigidBody>,
+) {
+    // Return if no rigid bodies have been removed
+    if removals.is_empty() {
+        return;
+    }
+
+    for (collider_entity, collider_parent) in &colliders {
+        // If the body associated with the collider parent entity doesn't exist,
+        // remove ColliderParent and ColliderTransform.
+        if !bodies.contains(collider_parent.get()) {
+            commands.entity(collider_entity).remove::<(
+                ColliderParent,
+                ColliderTransform,
+                PreviousColliderTransform,
+            )>();
+        }
+    }
+}
+
+/// Updates [`ColliderStorageMap`], a resource that stores some collider properties that need
+/// to be handled when colliders are removed from entities.
+#[allow(clippy::type_complexity)]
+fn update_collider_storage<C: AnyCollider>(
+    // TODO: Maybe it's enough to store only colliders that aren't on rigid body entities
+    //       directly (i.e. child colliders)
+    colliders: Query<
+        (
+            Entity,
+            &ColliderParent,
+            &ColliderMassProperties,
+            &ColliderTransform,
+        ),
+        Or<(
+            Changed<ColliderParent>,
+            Changed<ColliderTransform>,
+            Changed<ColliderMassProperties>,
+        )>,
+    >,
+    mut storage: ResMut<ColliderStorageMap<C>>,
+) {
+    for (entity, parent, collider_mass_properties, collider_transform) in &colliders {
+        storage.map.insert(
+            entity,
+            (*parent, *collider_mass_properties, *collider_transform),
+        );
+    }
+}
+
+/// Removes removed colliders from the [`ColliderStorageMap`] resource at the end of the physics frame.
+fn handle_collider_storage_removals<C: AnyCollider>(
+    mut removals: RemovedComponents<C>,
+    mut storage: ResMut<ColliderStorageMap<C>>,
+) {
+    removals.read().for_each(|entity| {
+        storage.map.remove(&entity);
+    });
+}
+
+#[allow(clippy::type_complexity)]
+pub(crate) fn update_child_collider_position(
+    mut colliders: Query<
+        (
+            &ColliderTransform,
+            &mut Position,
+            &mut Rotation,
+            &ColliderParent,
+        ),
+        Without<RigidBody>,
+    >,
+    parents: Query<(&Position, &Rotation), (With<RigidBody>, With<Children>)>,
+) {
+    for (collider_transform, mut position, mut rotation, parent) in &mut colliders {
+        let Ok((parent_pos, parent_rot)) = parents.get(parent.get()) else {
+            continue;
+        };
+
+        position.0 = parent_pos.0 + parent_rot.rotate(collider_transform.translation);
+        #[cfg(feature = "2d")]
+        {
+            *rotation = *parent_rot + collider_transform.rotation;
+        }
+        #[cfg(feature = "3d")]
+        {
+            *rotation = (parent_rot.0 * collider_transform.rotation.0)
+                .normalize()
+                .into();
+        }
+    }
+}
+
+/// Updates the scale of colliders based on [`Transform`] scale.
+#[allow(clippy::type_complexity)]
+pub fn update_collider_scale<C: ScalableCollider>(
+    mut colliders: ParamSet<(
+        // Root bodies
+        Query<(&Transform, &mut C), Without<Parent>>,
+        // Child colliders
+        Query<(&ColliderTransform, &mut C), With<Parent>>,
+    )>,
+) {
+    // Update collider scale for root bodies
+    for (transform, mut collider) in &mut colliders.p0() {
+        #[cfg(feature = "2d")]
+        let scale = transform.scale.truncate().adjust_precision();
+        #[cfg(feature = "3d")]
+        let scale = transform.scale.adjust_precision();
+        if scale != collider.scale() {
+            // TODO: Support configurable subdivision count for shapes that
+            //       can't be represented without approximations after scaling.
+            collider.set_scale(scale, 10);
+        }
+    }
+
+    // Update collider scale for child colliders
+    for (collider_transform, mut collider) in &mut colliders.p1() {
+        if collider_transform.scale != collider.scale() {
+            // TODO: Support configurable subdivision count for shapes that
+            //       can't be represented without approximations after scaling.
+            collider.set_scale(collider_transform.scale, 10);
+        }
+    }
+}
+
+/// Updates [`ColliderTransform`]s based on entity hierarchies. Each transform is computed by recursively
+/// traversing the children of each rigid body and adding their transforms together to form
+/// the total transform relative to the body.
+///
+/// This is largely a clone of `propagate_transforms` in `bevy_transform`.
+#[allow(clippy::type_complexity)]
+pub(crate) fn propagate_collider_transforms(
+    mut root_query: Query<(Entity, Ref<Transform>, &Children), Without<Parent>>,
+    collider_query: Query<
+        (
+            Ref<Transform>,
+            Option<&mut ColliderTransform>,
+            Option<&Children>,
+        ),
+        With<Parent>,
+    >,
+    parent_query: Query<(Entity, Ref<Transform>, Has<RigidBody>, Ref<Parent>)>,
+) {
+    root_query.par_iter_mut().for_each(
+        |(entity, transform,children)| {
+            for (child, child_transform, is_child_rb, parent) in parent_query.iter_many(children) {
+                assert_eq!(
+                    parent.get(), entity,
+                    "Malformed hierarchy. This probably means that your hierarchy has been improperly maintained, or contains a cycle"
+                );
+                let child_transform = ColliderTransform::from(*child_transform);
+
+                // SAFETY:
+                // - `child` must have consistent parentage, or the above assertion would panic.
+                // Since `child` is parented to a root entity, the entire hierarchy leading to it is consistent.
+                // - We may operate as if all descendants are consistent, since `propagate_collider_transform_recursive` will panic before 
+                //   continuing to propagate if it encounters an entity with inconsistent parentage.
+                // - Since each root entity is unique and the hierarchy is consistent and forest-like,
+                //   other root entities' `propagate_collider_transform_recursive` calls will not conflict with this one.
+                // - Since this is the only place where `transform_query` gets used, there will be no conflicting fetches elsewhere.
+                unsafe {
+                    propagate_collider_transforms_recursive(
+                        if is_child_rb {
+                            ColliderTransform {
+                                scale: child_transform.scale,
+                                ..default()
+                            }
+                        } else {
+                            let transform = ColliderTransform::from(*transform);
+
+                            ColliderTransform {
+                                translation: transform.scale * child_transform.translation,
+                                rotation: child_transform.rotation,
+                                scale: (transform.scale * child_transform.scale).max(Vector::splat(Scalar::EPSILON)),
+                            }
+                        },
+                        &collider_query,
+                        &parent_query,
+                        child,
+                        transform.is_changed() || parent.is_changed()
+                    );
+                }
+            }
+        },
+    );
+}
+
+/// Recursively computes the [`ColliderTransform`] for `entity` and all of its descendants
+/// by propagating transforms.
+///
+/// This is largely a clone of `propagate_recursive` in `bevy_transform`.
+///
+/// # Panics
+///
+/// If `entity`'s descendants have a malformed hierarchy, this function will panic occur before propagating
+/// the transforms of any malformed entities and their descendants.
+///
+/// # Safety
+///
+/// - While this function is running, `transform_query` must not have any fetches for `entity`,
+/// nor any of its descendants.
+/// - The caller must ensure that the hierarchy leading to `entity`
+/// is well-formed and must remain as a tree or a forest. Each entity must have at most one parent.
+#[allow(clippy::type_complexity)]
+unsafe fn propagate_collider_transforms_recursive(
+    transform: ColliderTransform,
+    collider_query: &Query<
+        (
+            Ref<Transform>,
+            Option<&mut ColliderTransform>,
+            Option<&Children>,
+        ),
+        With<Parent>,
+    >,
+    parent_query: &Query<(Entity, Ref<Transform>, Has<RigidBody>, Ref<Parent>)>,
+    entity: Entity,
+    mut changed: bool,
+) {
+    let children = {
+        // SAFETY: This call cannot create aliased mutable references.
+        //   - The top level iteration parallelizes on the roots of the hierarchy.
+        //   - The caller ensures that each child has one and only one unique parent throughout the entire
+        //     hierarchy.
+        //
+        // For example, consider the following malformed hierarchy:
+        //
+        //     A
+        //   /   \
+        //  B     C
+        //   \   /
+        //     D
+        //
+        // D has two parents, B and C. If the propagation passes through C, but the Parent component on D points to B,
+        // the above check will panic as the origin parent does match the recorded parent.
+        //
+        // Also consider the following case, where A and B are roots:
+        //
+        //  A       B
+        //   \     /
+        //    C   D
+        //     \ /
+        //      E
+        //
+        // Even if these A and B start two separate tasks running in parallel, one of them will panic before attempting
+        // to mutably access E.
+        let Ok((transform_ref, collider_transform, children)) =
+            (unsafe { collider_query.get_unchecked(entity) })
+        else {
+            return;
+        };
+
+        changed |= transform_ref.is_changed();
+        if changed {
+            if let Some(mut collider_transform) = collider_transform {
+                if *collider_transform != transform {
+                    *collider_transform = transform;
+                }
+            }
+        }
+
+        children
+    };
+
+    let Some(children) = children else { return };
+    for (child, child_transform, is_rb, parent) in parent_query.iter_many(children) {
+        assert_eq!(
+            parent.get(), entity,
+            "Malformed hierarchy. This probably means that your hierarchy has been improperly maintained, or contains a cycle"
+        );
+
+        let child_transform = ColliderTransform::from(*child_transform);
+
+        // SAFETY: The caller guarantees that `transform_query` will not be fetched
+        // for any descendants of `entity`, so it is safe to call `propagate_collider_transforms_recursive` for each child.
+        //
+        // The above assertion ensures that each child has one and only one unique parent throughout the
+        // entire hierarchy.
+        unsafe {
+            propagate_collider_transforms_recursive(
+                if is_rb {
+                    ColliderTransform {
+                        scale: child_transform.scale,
+                        ..default()
+                    }
+                } else {
+                    ColliderTransform {
+                        translation: transform.transform_point(child_transform.translation),
+                        #[cfg(feature = "2d")]
+                        rotation: transform.rotation + child_transform.rotation,
+                        #[cfg(feature = "3d")]
+                        rotation: Rotation(transform.rotation.0 * child_transform.rotation.0),
+                        scale: (transform.scale * child_transform.scale)
+                            .max(Vector::splat(Scalar::EPSILON)),
+                    }
+                },
+                collider_query,
+                parent_query,
+                child,
+                changed || parent.is_changed(),
+            );
+        }
+    }
+}
+
+/// Updates the mass properties of [`Collider`]s and [collider parents](ColliderParent).
+#[allow(clippy::type_complexity)]
+fn update_collider_mass_properties<C: AnyCollider>(
+    mut mass_props: Query<(Entity, MassPropertiesQuery)>,
+    mut colliders: Query<
+        (
+            &ColliderTransform,
+            &mut PreviousColliderTransform,
+            &ColliderParent,
+            Ref<C>,
+            &ColliderDensity,
+            &mut ColliderMassProperties,
+        ),
+        Or<(
+            Changed<C>,
+            Changed<ColliderTransform>,
+            Changed<ColliderDensity>,
+            Changed<ColliderMassProperties>,
+        )>,
+    >,
+    collider_map: Res<ColliderStorageMap<C>>,
+    mut removed_colliders: RemovedComponents<C>,
+) {
+    for (
+        collider_transform,
+        mut previous_collider_transform,
+        collider_parent,
+        collider,
+        density,
+        mut collider_mass_properties,
+    ) in &mut colliders
+    {
+        if let Ok((_, mut mass_properties)) = mass_props.get_mut(collider_parent.0) {
+            // Subtract previous collider mass props from the body's own mass props,
+            // If the collider is new, it doesn't have previous mass props, so we shouldn't subtract anything.
+            if !collider.is_added() {
+                mass_properties -= ColliderMassProperties {
+                    center_of_mass: CenterOfMass(
+                        previous_collider_transform
+                            .transform_point(collider_mass_properties.center_of_mass.0),
+                    ),
+                    ..*collider_mass_properties
+                };
+            }
+
+            previous_collider_transform.0 = *collider_transform;
+
+            // Update collider mass props
+            *collider_mass_properties = collider.mass_properties(density.max(Scalar::EPSILON));
+
+            // Add new collider mass props to the body's mass props
+            mass_properties += ColliderMassProperties {
+                center_of_mass: CenterOfMass(
+                    collider_transform.transform_point(collider_mass_properties.center_of_mass.0),
+                ),
+                ..*collider_mass_properties
+            };
+        }
+    }
+
+    // Subtract mass properties of removed colliders
+    for entity in removed_colliders.read() {
+        if let Some((collider_parent, collider_mass_properties, collider_transform)) =
+            collider_map.map.get(&entity)
+        {
+            if let Ok((_, mut mass_properties)) = mass_props.get_mut(collider_parent.0) {
+                mass_properties -= ColliderMassProperties {
+                    center_of_mass: CenterOfMass(
+                        collider_transform
+                            .transform_point(collider_mass_properties.center_of_mass.0),
+                    ),
+                    ..*collider_mass_properties
+                };
+            }
+        }
+    }
+}
+
+/// Removes the [`Sleeping`] component from sleeping bodies when any of their
+/// colliders have been removed.
+#[allow(clippy::type_complexity)]
+fn wake_on_collider_removed<C: AnyCollider>(
+    mut commands: Commands,
+    mut bodies: Query<(Entity, &mut TimeSleeping), With<RigidBody>>,
+    all_colliders: Query<&ColliderParent>,
+    child_colliders: Query<
+        &ColliderParent,
+        (
+            Without<RigidBody>,
+            Or<(Changed<C>, Changed<Transform>, Changed<ColliderTransform>)>,
+        ),
+    >,
+    mut removed_colliders: RemovedComponents<C>,
+    // This stores some collider data so that we can access it even though the entity has been removed
+    collider_storage: Res<ColliderStorageMap<C>>,
+) {
+    let removed_colliders_iter =
+        all_colliders.iter_many(removed_colliders.read().filter_map(|entity| {
+            collider_storage
+                .map
+                .get(&entity)
+                .map(|(rb_entity, _, _)| rb_entity.get())
+        }));
+    for collider_parent in child_colliders.iter().chain(removed_colliders_iter) {
+        if let Ok((entity, mut time_sleeping)) = bodies.get_mut(collider_parent.get()) {
+            commands.entity(entity).remove::<Sleeping>();
+            time_sleeping.0 = 0.0;
+        }
+    }
+}
diff --git a/src/plugins/collision/mod.rs b/src/plugins/collision/mod.rs
index c99eb6e2..7d3c18a8 100644
--- a/src/plugins/collision/mod.rs
+++ b/src/plugins/collision/mod.rs
@@ -10,7 +10,11 @@
 //!
 //! You can also find several utility methods for computing contacts in [`contact_query`].
 
+mod collider;
+pub use collider::*;
+
 pub mod broad_phase;
+pub mod collider_backend;
 pub mod contact_query;
 pub mod contact_reporting;
 pub mod narrow_phase;
diff --git a/src/plugins/collision/narrow_phase.rs b/src/plugins/collision/narrow_phase.rs
index 2bb64c72..4c5879db 100644
--- a/src/plugins/collision/narrow_phase.rs
+++ b/src/plugins/collision/narrow_phase.rs
@@ -2,6 +2,8 @@
 //!
 //! See [`NarrowPhasePlugin`].
 
+use std::marker::PhantomData;
+
 use crate::prelude::*;
 use bevy::ecs::query::Has;
 #[cfg(feature = "parallel")]
@@ -13,46 +15,96 @@ use bevy::tasks::{ComputeTaskPool, ParallelSlice};
 /// which is handled by the [`BroadPhasePlugin`].
 ///
 /// The results of the narrow phase are added into [`Collisions`].
-pub struct NarrowPhasePlugin;
+///
+/// The plugin takes a collider type. This should be [`Collider`] for
+/// the vast majority of applications, but for custom collisión backends
+/// you may use any collider that implements the [`AnyCollider`] trait.
+pub struct NarrowPhasePlugin<C: AnyCollider> {
+    _phantom: PhantomData<C>,
+}
 
-impl Plugin for NarrowPhasePlugin {
+impl<C: AnyCollider> Default for NarrowPhasePlugin<C> {
+    fn default() -> Self {
+        Self {
+            _phantom: PhantomData,
+        }
+    }
+}
+
+impl<C: AnyCollider> Plugin for NarrowPhasePlugin<C> {
     fn build(&self, app: &mut App) {
-        app.init_resource::<NarrowPhaseConfig>()
+        // For some systems, we only want one instance, even if there are multiple
+        // NarrowPhasePlugin instances with different collider types.
+        let is_first_instance = app.world.is_resource_added::<NarrowPhaseInitialized>();
+
+        app.init_resource::<NarrowPhaseInitialized>()
+            .init_resource::<NarrowPhaseConfig>()
             .init_resource::<Collisions>()
             .register_type::<NarrowPhaseConfig>();
 
-        // Manage collision states like `during_current_frame` and remove old contacts
-        // TODO: It would be nice not to have collision state logic in the narrow phase
-        app.get_schedule_mut(PhysicsSchedule)
-            .expect("add PhysicsSchedule first")
-            .add_systems(
+        app.configure_sets(
+            SubstepSchedule,
+            (
+                NarrowPhaseSet::First,
+                NarrowPhaseSet::CollectCollisions,
+                NarrowPhaseSet::Last,
+            )
+                .chain()
+                .in_set(SubstepSet::NarrowPhase),
+        );
+
+        let physics_schedule = app
+            .get_schedule_mut(PhysicsSchedule)
+            .expect("add PhysicsSchedule first");
+
+        // Manage collision states like `during_current_frame` and remove old contacts.
+        // Only one narrow phase instance should do this.
+        // TODO: It would be nice not to have collision state logic in the narrow phase.
+        if !is_first_instance {
+            physics_schedule.add_systems(
                 (
-                    // Reset collision states before the substepping loop
+                    // Reset collision states before the substepping loop.
                     reset_collision_states
                         .after(PhysicsStepSet::BroadPhase)
                         .before(PhysicsStepSet::Substeps),
                     // Remove ended collisions after contact reporting
-                    ((|mut collisions: ResMut<Collisions>| {
-                        collisions.retain(|contacts| contacts.during_current_frame)
-                    }),)
-                        .chain()
+                    remove_ended_collisions
                         .after(PhysicsStepSet::ReportContacts)
                         .before(PhysicsStepSet::Sleeping),
                 )
                     .chain(),
             );
+        }
 
-        // Reset substep collision states and collect contacts into `Collisions`
-        app.get_schedule_mut(SubstepSchedule)
-            .expect("add SubstepSchedule first")
-            .add_systems(
-                (reset_substep_collision_states, collect_collisions)
-                    .chain()
-                    .in_set(SubstepSet::NarrowPhase),
+        let substep_schedule = app
+            .get_schedule_mut(SubstepSchedule)
+            .expect("add SubstepSchedule first");
+
+        // Reset substep collision states. Only one narrow phase instance should do this.
+        if !is_first_instance {
+            substep_schedule.add_systems(
+                reset_substep_collision_states
+                    .after(NarrowPhaseSet::First)
+                    .before(NarrowPhaseSet::CollectCollisions),
             );
+        }
+
+        // Collect contacts into `Collisions`.
+        substep_schedule.add_systems(
+            (
+                // Allowing ambiguities is required so that it's possible
+                // to have multiple collision backends at the same time.
+                collect_collisions::<C>.ambiguous_with_all(),
+            )
+                .chain()
+                .in_set(NarrowPhaseSet::CollectCollisions),
+        );
     }
 }
 
+#[derive(Resource, Default)]
+struct NarrowPhaseInitialized;
+
 /// A resource for configuring the [narrow phase](NarrowPhasePlugin).
 #[derive(Resource, Reflect, Clone, Debug, PartialEq)]
 #[cfg_attr(feature = "serialize", derive(serde::Serialize, serde::Deserialize))]
@@ -77,24 +129,39 @@ impl Default for NarrowPhaseConfig {
     }
 }
 
+/// System sets for systems running in [`SubstepSet::NarrowPhase`].
+#[derive(SystemSet, Clone, Copy, Debug, PartialEq, Eq, Hash)]
+pub enum NarrowPhaseSet {
+    /// Runs at the start of the narrow phase. Empty by default.
+    First,
+    /// Computes contacts between entities and adds them to the [`Collisions`] resource.
+    CollectCollisions,
+    /// Runs at the end of the narrow phase. Empty by default.
+    Last,
+}
+
 /// Computes contacts based on [`BroadCollisionPairs`] and adds them to [`Collisions`].
 #[allow(clippy::too_many_arguments)]
 #[allow(clippy::type_complexity)]
-pub fn collect_collisions(
-    bodies: Query<(
+pub fn collect_collisions<C: AnyCollider>(
+    query: Query<(
         Ref<Position>,
         Option<&AccumulatedTranslation>,
         Ref<Rotation>,
-        &Collider,
+        &C,
     )>,
     broad_collision_pairs: Res<BroadCollisionPairs>,
     mut collisions: ResMut<Collisions>,
     narrow_phase_config: Res<NarrowPhaseConfig>,
 ) {
+    if query.is_empty() {
+        return;
+    }
+
     // We want to preserve collisions between entities that are stationary
     // but not included in [`BroadCollisionPairs`].
     let stationary_collisions = collisions.0.keys().filter(|&&(e1, e2)| {
-        if let Ok([bundle1, bundle2]) = bodies.get_many([e1, e2]) {
+        if let Ok([bundle1, bundle2]) = query.get_many([e1, e2]) {
             let (position1, _, rotation1, _) = bundle1;
             let (position2, _, rotation2, _) = bundle2;
             !(position1.is_changed()
@@ -121,7 +188,7 @@ pub fn collect_collisions(
                     process_collision_pair(
                         *entity1,
                         *entity2,
-                        &bodies,
+                        &query,
                         &collisions,
                         &narrow_phase_config,
                         |contacts| {
@@ -143,7 +210,7 @@ pub fn collect_collisions(
             process_collision_pair(
                 entity1,
                 entity2,
-                &bodies,
+                &query,
                 &collisions,
                 &narrow_phase_config,
                 |contacts| {
@@ -158,14 +225,14 @@ pub fn collect_collisions(
 
 /// Helper method that calculates the intersection between two colliders to determine if they are in contact.
 #[allow(clippy::type_complexity)]
-fn process_collision_pair<F>(
+fn process_collision_pair<C: AnyCollider, F>(
     entity1: Entity,
     entity2: Entity,
     bodies: &Query<(
         Ref<Position>,
         Option<&AccumulatedTranslation>,
         Ref<Rotation>,
-        &Collider,
+        &C,
     )>,
     collisions: &ResMut<Collisions>,
     narrow_phase_config: &Res<NarrowPhaseConfig>,
@@ -188,11 +255,10 @@ fn process_collision_pair<F>(
             during_current_frame: true,
             during_current_substep: true,
             during_previous_frame: previous_contact.map_or(false, |c| c.during_previous_frame),
-            manifolds: contact_query::contact_manifolds(
-                collider1,
+            manifolds: collider1.contact_manifolds(
+                collider2,
                 position1,
                 *rotation1,
-                collider2,
                 position2,
                 *rotation2,
                 narrow_phase_config.prediction_distance,
@@ -207,6 +273,10 @@ fn process_collision_pair<F>(
     }
 }
 
+fn remove_ended_collisions(mut collisions: ResMut<Collisions>) {
+    collisions.retain(|contacts| contacts.during_current_frame);
+}
+
 // TODO: The collision state handling feels a bit confusing and error-prone.
 //       Ideally, the narrow phase wouldn't need to handle it at all, or it would at least be simpler.
 /// Resets collision states like `during_current_frame` and `during_previous_frame`.
diff --git a/src/plugins/mod.rs b/src/plugins/mod.rs
index b383c78d..d48323f7 100644
--- a/src/plugins/mod.rs
+++ b/src/plugins/mod.rs
@@ -33,7 +33,7 @@ pub mod sync;
 
 use bevy::utils::intern::Interned;
 pub use collision::{
-    broad_phase::BroadPhasePlugin, contact_reporting::ContactReportingPlugin,
+    broad_phase::BroadPhasePlugin, collider_backend::*, contact_reporting::ContactReportingPlugin,
     narrow_phase::NarrowPhasePlugin,
 };
 #[cfg(feature = "debug-plugin")]
@@ -57,11 +57,13 @@ use bevy::prelude::*;
 /// - [`PhysicsSetupPlugin`]: Sets up the physics engine by initializing the necessary schedules, sets and resources.
 /// - [`PreparePlugin`]: Runs systems at the start of each physics frame; initializes [rigid bodies](RigidBody)
 /// and [colliders](Collider) and updates components.
+/// - [`ColliderBackendPlugin`]: Handles generic collider backend logic, like initializing colliders and AABBs
+/// and updating related components.
 /// - [`BroadPhasePlugin`]: Collects pairs of potentially colliding entities into [`BroadCollisionPairs`] using
 /// [AABB](ColliderAabb) intersection checks.
-/// - [`IntegratorPlugin`]: Integrates Newton's 2nd law of motion, applying forces and moving entities according to their velocities.
 /// - [`NarrowPhasePlugin`]: Computes contacts between entities and sends collision events.
 /// - [`ContactReportingPlugin`]: Sends collision events and updates [`CollidingEntities`].
+/// - [`IntegratorPlugin`]: Integrates Newton's 2nd law of motion, applying forces and moving entities according to their velocities.
 /// - [`SolverPlugin`]: Solves positional and angular [constraints], updates velocities and solves velocity constraints
 /// (dynamic [friction](Friction) and [restitution](Restitution)).
 /// - [`SleepingPlugin`]: Controls when bodies should be deactivated and marked as [`Sleeping`] to improve performance.
@@ -189,10 +191,11 @@ impl PluginGroup for PhysicsPlugins {
         PluginGroupBuilder::start::<Self>()
             .add(PhysicsSetupPlugin::new(self.schedule))
             .add(PreparePlugin::new(self.schedule))
+            .add(ColliderBackendPlugin::<Collider>::new(self.schedule))
             .add(BroadPhasePlugin)
-            .add(IntegratorPlugin)
-            .add(NarrowPhasePlugin)
+            .add(NarrowPhasePlugin::<Collider>::default())
             .add(ContactReportingPlugin)
+            .add(IntegratorPlugin)
             .add(SolverPlugin)
             .add(SleepingPlugin)
             .add(SpatialQueryPlugin::new(self.schedule))
diff --git a/src/plugins/prepare.rs b/src/plugins/prepare.rs
index 91748e4f..d0a3b2a3 100644
--- a/src/plugins/prepare.rs
+++ b/src/plugins/prepare.rs
@@ -1,31 +1,28 @@
-//! Runs systems at the start of each physics frame; initializes [rigid bodies](RigidBody)
-//! and [colliders](Collider) and updates components.
+//! Runs systems at the start of each physics frame. Initializes [rigid bodies](RigidBody)
+//! and updates components.
 //!
 //! See [`PreparePlugin`].
 
 #![allow(clippy::type_complexity)]
 
 use crate::prelude::*;
-#[cfg(all(feature = "3d", feature = "async-collider"))]
-use bevy::scene::SceneInstance;
-use bevy::{
-    ecs::query::Has,
-    prelude::*,
-    utils::{intern::Interned, HashMap},
-};
+use bevy::{prelude::*, utils::intern::Interned};
 
-/// Runs systems at the start of each physics frame; initializes [rigid bodies](RigidBody)
-/// and [colliders](Collider) and updates components.
+/// Runs systems at the start of each physics frame. Initializes [rigid bodies](RigidBody)
+/// and updates components.
 ///
 /// - Adds missing rigid body components for entities with a [`RigidBody`] component
-/// - Adds missing collider components for entities with a [`Collider`] component
-/// - Adds missing mass properties for entities with a [`RigidBody`] or [`Collider`] component
-/// - Updates mass properties and adds [`ColliderMassProperties`] on top of the existing mass properties
+/// - Adds missing mass properties for entities with a [`RigidBody`] component
+/// - Updates mass properties
 /// - Clamps restitution coefficients between 0 and 1
 ///
 /// The [`Transform`] component will be initialized based on [`Position`] or [`Rotation`]
 /// and vice versa. You can configure this synchronization using the [`PrepareConfig`] resource.
 ///
+/// The plugin takes a collider type. This should be [`Collider`] for
+/// the vast majority of applications, but for custom collisión backends
+/// you may use any collider that implements the [`AnyCollider`] trait.
+///
 /// The systems run in [`PhysicsSet::Prepare`].
 pub struct PreparePlugin {
     schedule: Interned<dyn ScheduleLabel>,
@@ -98,77 +95,49 @@ impl Plugin for PreparePlugin {
                 .in_set(PhysicsSet::Prepare),
         );
 
-        app.init_resource::<ColliderStorageMap>()
-            .init_resource::<PrepareConfig>()
-            .register_type::<PrepareConfig>()
-            .add_systems(
-                self.schedule,
-                (
-                    apply_deferred,
-                    // Run transform propagation if new bodies or colliders have been added
-                    (
-                        bevy::transform::systems::sync_simple_transforms,
-                        bevy::transform::systems::propagate_transforms,
-                    )
-                        .chain()
-                        .run_if(any_new_physics_entities),
-                )
-                    .chain()
-                    .in_set(PrepareSet::PropagateTransforms),
-            )
-            .add_systems(
-                self.schedule,
-                init_rigid_bodies.in_set(PrepareSet::InitRigidBodies),
-            )
-            .add_systems(
-                self.schedule,
-                init_mass_properties.in_set(PrepareSet::InitMassProperties),
-            )
-            .add_systems(
-                self.schedule,
+        app.init_resource::<PrepareConfig>()
+            .register_type::<PrepareConfig>();
+
+        // Note: Collider logic is handled by the `ColliderBackendPlugin`
+        app.add_systems(
+            self.schedule,
+            (
+                apply_deferred,
+                // Run transform propagation if new bodies have been added
                 (
-                    init_colliders,
-                    apply_deferred,
-                    update_collider_parents,
-                    apply_deferred,
+                    bevy::transform::systems::sync_simple_transforms,
+                    bevy::transform::systems::propagate_transforms,
                 )
                     .chain()
-                    .in_set(PrepareSet::InitColliders),
-            )
-            .add_systems(
-                self.schedule,
-                init_transforms.in_set(PrepareSet::InitTransforms),
+                    .run_if(any_new::<RigidBody>),
             )
-            .add_systems(
-                self.schedule,
-                (
-                    (
-                        sync::propagate_collider_transforms,
-                        sync::update_child_collider_position,
-                    )
-                        .chain()
-                        .run_if(any_new_physics_entities),
-                    update_mass_properties,
-                    clamp_collider_density,
-                    clamp_restitution,
-                    // All the components we added above must exist before we can simulate the bodies.
-                    apply_deferred,
-                )
-                    .chain()
-                    .in_set(PrepareSet::Finalize),
-            );
-
-        app.add_systems(
-            PhysicsSchedule,
+                .chain()
+                .in_set(PrepareSet::PropagateTransforms),
+        )
+        .add_systems(
+            self.schedule,
+            init_rigid_bodies.in_set(PrepareSet::InitRigidBodies),
+        )
+        .add_systems(
+            self.schedule,
+            init_mass_properties.in_set(PrepareSet::InitMassProperties),
+        )
+        .add_systems(
+            self.schedule,
+            init_transforms::<RigidBody>.in_set(PrepareSet::InitTransforms),
+        )
+        .add_systems(
+            self.schedule,
             (
-                update_collider_storage.before(PhysicsStepSet::BroadPhase),
-                handle_collider_storage_removals.after(PhysicsStepSet::SpatialQuery),
-                handle_rigid_body_removals.after(PhysicsStepSet::SpatialQuery),
-            ),
+                update_mass_properties,
+                clamp_collider_density,
+                clamp_restitution,
+                // All the components we added above must exist before we can simulate the bodies.
+                apply_deferred,
+            )
+                .chain()
+                .in_set(PrepareSet::Finalize),
         );
-
-        #[cfg(all(feature = "3d", feature = "async-collider"))]
-        app.add_systems(Update, (init_async_colliders, init_async_scene_colliders));
     }
 }
 
@@ -193,34 +162,15 @@ impl Default for PrepareConfig {
     }
 }
 
-#[derive(Reflect, Clone, Copy, Component, Debug, Default, Deref, DerefMut, PartialEq)]
-#[reflect(Component)]
-pub(crate) struct PreviousColliderTransform(ColliderTransform);
-
-// Todo: Does this make sense in this file? It would also be nice to find an alternative approach.
-/// A hash map that stores some collider data that is needed when colliders are removed from
-/// rigid bodies.
-///
-/// This includes the collider parent for finding the associated rigid body after collider removal,
-/// and collider mass properties for updating the rigid body's mass properties when its collider is removed.
-///
-/// Ideally, we would just have some entity removal event or callback, but that doesn't
-/// exist yet, and `RemovedComponents` only returns entities, not component data.
-#[derive(Resource, Reflect, Clone, Debug, Default, Deref, DerefMut, PartialEq)]
-#[reflect(Resource)]
-pub(crate) struct ColliderStorageMap(
-    HashMap<Entity, (ColliderParent, ColliderMassProperties, ColliderTransform)>,
-);
-
-/// A run condition that returns `true` if new [rigid bodies](RigidBody) or [colliders](Collider)
-/// have been added. Used for avoiding unnecessary transform propagation.
-fn any_new_physics_entities(query: Query<(), Or<(Added<RigidBody>, Added<Collider>)>>) -> bool {
+/// A run condition that returns `true` if a component of the given type `C` has been added to any entity.
+pub fn any_new<C: Component>(query: Query<(), Added<C>>) -> bool {
     !query.is_empty()
 }
 
 // TODO: This system feels very overengineered. Try to clean it up?
-/// Initializes [`Transform`] based on [`Position`] and [`Rotation`] or vice versa.
-fn init_transforms(
+/// Initializes [`Transform`] based on [`Position`] and [`Rotation`] or vice versa
+/// when a component of the given type is inserted.
+pub fn init_transforms<C: Component>(
     mut commands: Commands,
     config: Res<PrepareConfig>,
     mut query: Query<
@@ -233,9 +183,9 @@ fn init_transforms(
             Option<&Rotation>,
             Option<&PreviousRotation>,
             Option<&Parent>,
-            Has<RigidBody>,
+            Has<C>,
         ),
-        Or<(Added<RigidBody>, Added<Collider>)>,
+        Added<C>,
     >,
     parents: Query<
         (
@@ -489,317 +439,32 @@ fn init_mass_properties(
     }
 }
 
-/// Initializes missing components for [colliders](Collider).
-fn init_colliders(
-    mut commands: Commands,
-    mut colliders: Query<
-        (
-            Entity,
-            &Collider,
-            Option<&ColliderAabb>,
-            Option<&ColliderDensity>,
-            Option<&ColliderMassProperties>,
-        ),
-        Added<Collider>,
-    >,
-) {
-    for (entity, collider, aabb, density, mass_properties) in &mut colliders {
-        let density = *density.unwrap_or(&ColliderDensity::default());
-        commands.entity(entity).insert((
-            *aabb.unwrap_or(&ColliderAabb::from_shape(collider.shape_scaled())),
-            density,
-            *mass_properties.unwrap_or(&collider.mass_properties(density.0)),
-            CollidingEntities::default(),
-        ));
-    }
-}
-
-/// Creates [`Collider`]s from [`AsyncCollider`]s if the meshes have become available.
-#[cfg(all(feature = "3d", feature = "async-collider"))]
-pub fn init_async_colliders(
-    mut commands: Commands,
-    meshes: Res<Assets<Mesh>>,
-    async_colliders: Query<(Entity, &Handle<Mesh>, &AsyncCollider)>,
-) {
-    for (entity, mesh_handle, async_collider) in async_colliders.iter() {
-        if let Some(mesh) = meshes.get(mesh_handle) {
-            let collider = match &async_collider.0 {
-                ComputedCollider::TriMesh => Collider::trimesh_from_mesh(mesh),
-                ComputedCollider::TriMeshWithFlags(flags) => {
-                    Collider::trimesh_from_mesh_with_config(mesh, *flags)
-                }
-                ComputedCollider::ConvexHull => Collider::convex_hull_from_mesh(mesh),
-                ComputedCollider::ConvexDecomposition(params) => {
-                    Collider::convex_decomposition_from_mesh_with_config(mesh, params)
-                }
-            };
-            if let Some(collider) = collider {
-                commands
-                    .entity(entity)
-                    .insert(collider)
-                    .remove::<AsyncCollider>();
-            } else {
-                error!("Unable to generate collider from mesh {:?}", mesh);
-            }
-        }
-    }
-}
-
-/// Creates [`Collider`]s from [`AsyncSceneCollider`]s if the scenes have become available.
-#[cfg(all(feature = "3d", feature = "async-collider"))]
-pub fn init_async_scene_colliders(
-    mut commands: Commands,
-    meshes: Res<Assets<Mesh>>,
-    scene_spawner: Res<SceneSpawner>,
-    async_colliders: Query<(Entity, &SceneInstance, &AsyncSceneCollider)>,
-    children: Query<&Children>,
-    mesh_handles: Query<(&Name, &Handle<Mesh>)>,
-) {
-    for (scene_entity, scene_instance, async_scene_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 Some(collider_data) = async_scene_collider
-                        .meshes_by_name
-                        .get(name.as_str())
-                        .cloned()
-                        .unwrap_or(
-                            async_scene_collider
-                                .default_shape
-                                .clone()
-                                .map(|shape| AsyncSceneColliderData { shape, ..default() }),
-                        )
-                    else {
-                        continue;
-                    };
-
-                    let mesh = meshes.get(handle).expect("mesh should already be loaded");
-
-                    let collider = match collider_data.shape {
-                        ComputedCollider::TriMesh => Collider::trimesh_from_mesh(mesh),
-                        ComputedCollider::TriMeshWithFlags(flags) => {
-                            Collider::trimesh_from_mesh_with_config(mesh, flags)
-                        }
-                        ComputedCollider::ConvexHull => Collider::convex_hull_from_mesh(mesh),
-                        ComputedCollider::ConvexDecomposition(params) => {
-                            Collider::convex_decomposition_from_mesh_with_config(mesh, &params)
-                        }
-                    };
-                    if let Some(collider) = collider {
-                        commands.entity(child_entity).insert((
-                            collider,
-                            collider_data.layers,
-                            ColliderDensity(collider_data.density),
-                        ));
-                    } else {
-                        error!(
-                            "unable to generate collider from mesh {:?} with name {}",
-                            mesh, name
-                        );
-                    }
-                }
-            }
-
-            commands.entity(scene_entity).remove::<AsyncSceneCollider>();
-        }
-    }
-}
-
-fn update_collider_parents(
-    mut commands: Commands,
-    mut bodies: Query<(Entity, Option<&mut ColliderParent>, Has<Collider>), With<RigidBody>>,
-    children: Query<&Children>,
-    mut child_colliders: Query<Option<&mut ColliderParent>, (With<Collider>, Without<RigidBody>)>,
-) {
-    for (entity, collider_parent, has_collider) in &mut bodies {
-        if has_collider {
-            if let Some(mut collider_parent) = collider_parent {
-                collider_parent.0 = entity;
-            } else {
-                commands.entity(entity).insert((
-                    ColliderParent(entity),
-                    // Todo: This probably causes a one frame delay. Compute real value?
-                    ColliderTransform::default(),
-                    PreviousColliderTransform::default(),
-                ));
-            }
-        }
-        for child in children.iter_descendants(entity) {
-            if let Ok(collider_parent) = child_colliders.get_mut(child) {
-                if let Some(mut collider_parent) = collider_parent {
-                    collider_parent.0 = entity;
-                } else {
-                    commands.entity(child).insert((
-                        ColliderParent(entity),
-                        // Todo: This probably causes a one frame delay. Compute real value?
-                        ColliderTransform::default(),
-                        PreviousColliderTransform::default(),
-                    ));
-                }
-            }
-        }
-    }
-}
-
-/// Updates colliders when the rigid bodies they were attached to have been removed.
-fn handle_rigid_body_removals(
-    mut commands: Commands,
-    colliders: Query<(Entity, &ColliderParent), Without<RigidBody>>,
-    bodies: Query<(), With<RigidBody>>,
-    removals: RemovedComponents<RigidBody>,
-) {
-    // Return if no rigid bodies have been removed
-    if removals.is_empty() {
-        return;
-    }
-
-    for (collider_entity, collider_parent) in &colliders {
-        // If the body associated with the collider parent entity doesn't exist,
-        // remove ColliderParent and ColliderTransform.
-        if !bodies.contains(collider_parent.get()) {
-            commands.entity(collider_entity).remove::<(
-                ColliderParent,
-                ColliderTransform,
-                PreviousColliderTransform,
-            )>();
-        }
-    }
-}
-
-/// Updates [`ColliderStorageMap`], a resource that stores some collider properties that need
-/// to be handled when colliders are removed from entities.
-fn update_collider_storage(
-    // TODO: Maybe it's enough to store only colliders that aren't on rigid body entities
-    //       directly (i.e. child colliders)
-    colliders: Query<
+/// Updates each body's [`InverseMass`] and [`InverseInertia`] whenever [`Mass`] or [`Inertia`] are changed.
+pub fn update_mass_properties(
+    mut bodies: Query<
         (
             Entity,
-            &ColliderParent,
-            &ColliderMassProperties,
-            &ColliderTransform,
-        ),
-        (
-            With<Collider>,
-            Or<(
-                Changed<ColliderParent>,
-                Changed<ColliderTransform>,
-                Changed<ColliderMassProperties>,
-            )>,
-        ),
-    >,
-    mut storage: ResMut<ColliderStorageMap>,
-) {
-    for (entity, parent, collider_mass_properties, collider_transform) in &colliders {
-        storage.insert(
-            entity,
-            (*parent, *collider_mass_properties, *collider_transform),
-        );
-    }
-}
-
-/// Removes removed colliders from the [`ColliderStorageMap`] resource at the end of the physics frame.
-fn handle_collider_storage_removals(
-    mut removals: RemovedComponents<Collider>,
-    mut storage: ResMut<ColliderStorageMap>,
-) {
-    removals.read().for_each(|entity| {
-        storage.remove(&entity);
-    });
-}
-
-/// Updates each body's mass properties whenever their dependant mass properties or the body's [`Collider`] change.
-///
-/// Also updates the collider's mass properties if the body has a collider.
-fn update_mass_properties(
-    mut bodies: Query<(Entity, &RigidBody, MassPropertiesQuery)>,
-    mut colliders: Query<
-        (
-            &ColliderTransform,
-            &mut PreviousColliderTransform,
-            &ColliderParent,
-            Ref<Collider>,
-            &ColliderDensity,
-            &mut ColliderMassProperties,
+            &RigidBody,
+            Ref<Mass>,
+            &mut InverseMass,
+            Ref<Inertia>,
+            &mut InverseInertia,
         ),
-        Or<(
-            Changed<Collider>,
-            Changed<ColliderTransform>,
-            Changed<ColliderDensity>,
-            Changed<ColliderMassProperties>,
-        )>,
+        Or<(Changed<Mass>, Changed<Inertia>)>,
     >,
-    collider_map: Res<ColliderStorageMap>,
-    mut removed_colliders: RemovedComponents<Collider>,
 ) {
-    for (
-        collider_transform,
-        mut previous_collider_transform,
-        collider_parent,
-        collider,
-        density,
-        mut collider_mass_properties,
-    ) in &mut colliders
-    {
-        if let Ok((_, _, mut mass_properties)) = bodies.get_mut(collider_parent.0) {
-            // Subtract previous collider mass props from the body's own mass props,
-            // If the collider is new, it doesn't have previous mass props, so we shouldn't subtract anything.
-            if !collider.is_added() {
-                mass_properties -= ColliderMassProperties {
-                    center_of_mass: CenterOfMass(
-                        previous_collider_transform
-                            .transform_point(collider_mass_properties.center_of_mass.0),
-                    ),
-                    ..*collider_mass_properties
-                };
-            }
-
-            previous_collider_transform.0 = *collider_transform;
-
-            // Update collider mass props
-            *collider_mass_properties = collider.mass_properties(density.max(Scalar::EPSILON));
-
-            // Add new collider mass props to the body's mass props
-            mass_properties += ColliderMassProperties {
-                center_of_mass: CenterOfMass(
-                    collider_transform.transform_point(collider_mass_properties.center_of_mass.0),
-                ),
-                ..*collider_mass_properties
-            };
-        }
-    }
-
-    // Subtract mass properties of removed colliders
-    for entity in removed_colliders.read() {
-        if let Some((collider_parent, collider_mass_properties, collider_transform)) =
-            collider_map.get(&entity)
-        {
-            if let Ok((_, _, mut mass_properties)) = bodies.get_mut(collider_parent.0) {
-                mass_properties -= ColliderMassProperties {
-                    center_of_mass: CenterOfMass(
-                        collider_transform
-                            .transform_point(collider_mass_properties.center_of_mass.0),
-                    ),
-                    ..*collider_mass_properties
-                };
-            }
-        }
-    }
-
-    for (entity, rb, mut mass_properties) in &mut bodies {
-        let is_mass_valid =
-            mass_properties.mass.is_finite() && mass_properties.mass.0 >= Scalar::EPSILON;
+    for (entity, rb, mass, mut inv_mass, inertia, mut inv_inertia) in &mut bodies {
+        let is_mass_valid = mass.is_finite() && mass.0 >= Scalar::EPSILON;
         #[cfg(feature = "2d")]
-        let is_inertia_valid =
-            mass_properties.inertia.is_finite() && mass_properties.inertia.0 >= Scalar::EPSILON;
+        let is_inertia_valid = inertia.is_finite() && inertia.0 >= Scalar::EPSILON;
         #[cfg(feature = "3d")]
-        let is_inertia_valid =
-            mass_properties.inertia.is_finite() && *mass_properties.inertia != Inertia::ZERO;
+        let is_inertia_valid = inertia.is_finite() && *inertia != Inertia::ZERO;
 
-        if mass_properties.mass.is_changed() && is_mass_valid {
-            mass_properties.inverse_mass.0 = 1.0 / mass_properties.mass.0;
+        if mass.is_changed() && is_mass_valid {
+            inv_mass.0 = 1.0 / mass.0;
         }
-        if mass_properties.inertia.is_changed() && is_inertia_valid {
-            mass_properties.inverse_inertia.0 = mass_properties.inertia.inverse().0;
+        if inertia.is_changed() && is_inertia_valid {
+            inv_inertia.0 = inertia.inverse().0;
         }
 
         // Warn about dynamic bodies with no mass or inertia
diff --git a/src/plugins/sleeping.rs b/src/plugins/sleeping.rs
index 35d41338..661c4c1a 100644
--- a/src/plugins/sleeping.rs
+++ b/src/plugins/sleeping.rs
@@ -27,7 +27,6 @@ impl Plugin for SleepingPlugin {
                 (
                     mark_sleeping_bodies,
                     wake_on_changed,
-                    wake_on_collider_removed,
                     wake_all_sleeping_bodies.run_if(resource_changed::<Gravity>()),
                 )
                     .chain()
@@ -46,7 +45,7 @@ type SleepingQueryComponents = (
 
 /// Adds the [`Sleeping`] component to bodies whose linear and anigular velocities have been
 /// under the [`SleepingThreshold`] for a duration indicated by [`DeactivationTime`].
-fn mark_sleeping_bodies(
+pub fn mark_sleeping_bodies(
     mut commands: Commands,
     mut bodies: Query<SleepingQueryComponents, (Without<Sleeping>, Without<SleepingDisabled>)>,
     deactivation_time: Res<DeactivationTime>,
@@ -102,7 +101,7 @@ type WokeUpFilter = Or<(
 /// Removes the [`Sleeping`] component from sleeping bodies when properties like
 /// position, rotation, velocity and external forces are changed.
 #[allow(clippy::type_complexity)]
-fn wake_on_changed(
+pub fn wake_on_changed(
     mut commands: Commands,
     mut bodies: Query<(Entity, &mut TimeSleeping), (With<Sleeping>, WokeUpFilter)>,
 ) {
@@ -112,38 +111,6 @@ fn wake_on_changed(
     }
 }
 
-type ColliderTransformedFilter = Or<(
-    Changed<Collider>,
-    Changed<Transform>,
-    Changed<ColliderTransform>,
-)>;
-
-/// Removes the [`Sleeping`] component from sleeping bodies when any of their
-/// colliders have been removed.
-#[allow(clippy::type_complexity)]
-fn wake_on_collider_removed(
-    mut commands: Commands,
-    mut bodies: Query<(Entity, &mut TimeSleeping), With<RigidBody>>,
-    all_colliders: Query<&ColliderParent>,
-    child_colliders: Query<&ColliderParent, (Without<RigidBody>, ColliderTransformedFilter)>,
-    mut removed_colliders: RemovedComponents<Collider>,
-    // This stores some collider data so that we can access it even though the entity has been removed
-    collider_storage: Res<ColliderStorageMap>,
-) {
-    let removed_colliders_iter =
-        all_colliders.iter_many(removed_colliders.read().filter_map(|entity| {
-            collider_storage
-                .get(&entity)
-                .map(|(rb_entity, _, _)| rb_entity.get())
-        }));
-    for collider_parent in child_colliders.iter().chain(removed_colliders_iter) {
-        if let Ok((entity, mut time_sleeping)) = bodies.get_mut(collider_parent.get()) {
-            commands.entity(entity).remove::<Sleeping>();
-            time_sleeping.0 = 0.0;
-        }
-    }
-}
-
 /// Removes the [`Sleeping`] component from all sleeping bodies.
 /// Triggered automatically when [`Gravity`] is changed.
 fn wake_all_sleeping_bodies(
diff --git a/src/plugins/spatial_query/mod.rs b/src/plugins/spatial_query/mod.rs
index 184a37f1..cdfd40b2 100644
--- a/src/plugins/spatial_query/mod.rs
+++ b/src/plugins/spatial_query/mod.rs
@@ -158,7 +158,7 @@ pub use ray_caster::*;
 pub use shape_caster::*;
 pub use system_param::*;
 
-use crate::prelude::*;
+use crate::{prelude::*, prepare::PrepareSet};
 use bevy::{prelude::*, utils::intern::Interned};
 
 /// Initializes the [`SpatialQueryPipeline`] resource and handles component-based [spatial queries](spatial_query)
diff --git a/src/plugins/sync.rs b/src/plugins/sync.rs
index 4d71ea1a..06abfa23 100644
--- a/src/plugins/sync.rs
+++ b/src/plugins/sync.rs
@@ -4,7 +4,7 @@
 //! See [`SyncPlugin`].
 
 use crate::{prelude::*, utils::get_pos_translation};
-use bevy::{ecs::query::Has, prelude::*, utils::intern::Interned};
+use bevy::{prelude::*, utils::intern::Interned};
 
 /// Responsible for synchronizing physics components with other data, like keeping [`Position`]
 /// and [`Rotation`] in sync with `Transform`.
@@ -52,11 +52,24 @@ impl Plugin for SyncPlugin {
         app.init_resource::<SyncConfig>()
             .register_type::<SyncConfig>();
 
+        app.configure_sets(
+            self.schedule,
+            (
+                SyncSet::First,
+                SyncSet::TransformToPosition,
+                SyncSet::PositionToTransform,
+                SyncSet::Update,
+                SyncSet::Last,
+            )
+                .chain()
+                .in_set(PhysicsSet::Sync),
+        );
+
         // Initialize `PreviousGlobalTransform` and apply `Transform` changes that happened
         // between the end of the previous physics frame and the start of this physics frame.
         app.add_systems(
             self.schedule,
-            ((
+            (
                 bevy::transform::systems::sync_simple_transforms,
                 bevy::transform::systems::propagate_transforms,
                 init_previous_global_transform,
@@ -66,52 +79,42 @@ impl Plugin for SyncPlugin {
             )
                 .chain()
                 .after(PhysicsSet::Prepare)
-                .before(PhysicsSet::StepSimulation),)
-                .chain()
+                .before(PhysicsSet::StepSimulation)
                 .run_if(|config: Res<SyncConfig>| config.transform_to_position),
         );
 
-        // Apply `Transform`, `Position` and `Rotation` changes that happened during the physics frame.
+        // Apply `Transform` changes to `Position` and `Rotation`
         app.add_systems(
             self.schedule,
             (
-                (
-                    // Apply `Transform` changes to `Position` and `Rotation`
-                    bevy::transform::systems::sync_simple_transforms,
-                    bevy::transform::systems::propagate_transforms,
-                    transform_to_position,
-                )
-                    .chain()
-                    .run_if(|config: Res<SyncConfig>| config.transform_to_position),
-                // Apply `Position` and `Rotation` changes to `Transform`
-                position_to_transform
-                    .run_if(|config: Res<SyncConfig>| config.position_to_transform),
-                (
-                    // Update `PreviousGlobalTransform` for next frame's `GlobalTransform` change detection
-                    bevy::transform::systems::sync_simple_transforms,
-                    bevy::transform::systems::propagate_transforms,
-                    update_previous_global_transforms,
-                )
-                    .chain()
-                    .run_if(|config: Res<SyncConfig>| config.transform_to_position),
-                update_collider_scale,
+                bevy::transform::systems::sync_simple_transforms,
+                bevy::transform::systems::propagate_transforms,
+                transform_to_position,
             )
                 .chain()
-                .in_set(PhysicsSet::Sync),
+                .in_set(SyncSet::TransformToPosition)
+                .run_if(|config: Res<SyncConfig>| config.transform_to_position),
         );
 
-        // Update child colliders before narrow phase in substepping loop
-        let substep_schedule = app
-            .get_schedule_mut(SubstepSchedule)
-            .expect("add SubstepSchedule first");
-        substep_schedule.add_systems(
+        // Apply `Position` and `Rotation` changes to `Transform`
+        app.add_systems(
+            self.schedule,
+            position_to_transform
+                .in_set(SyncSet::PositionToTransform)
+                .run_if(|config: Res<SyncConfig>| config.position_to_transform),
+        );
+
+        // Update `PreviousGlobalTransform` for next frame's `GlobalTransform` change detection
+        app.add_systems(
+            self.schedule,
             (
-                propagate_collider_transforms,
-                update_child_collider_position,
+                bevy::transform::systems::sync_simple_transforms,
+                bevy::transform::systems::propagate_transforms,
+                update_previous_global_transforms,
             )
                 .chain()
-                .after(SubstepSet::Integrate)
-                .before(SubstepSet::NarrowPhase),
+                .in_set(SyncSet::Update)
+                .run_if(|config: Res<SyncConfig>| config.transform_to_position),
         );
     }
 }
@@ -136,17 +139,31 @@ impl Default for SyncConfig {
     }
 }
 
+/// System sets for systems running in [`PhysiCsSet::Sync`].
+#[derive(SystemSet, Clone, Copy, Debug, PartialEq, Eq, Hash)]
+pub enum SyncSet {
+    /// Runs at the start of [`PhysicsSet::Sync`]. Empty by default.
+    First,
+    /// Updates [`Position`] and [`Rotation`] based on transform changes.
+    TransformToPosition,
+    /// Updates transforms based on [`Position`] and [`Rotation`] changes.
+    PositionToTransform,
+    /// Handles transform propagation and other updates after physics positions have been synced with transforms.
+    Update,
+    /// Runs at the end of [`PhysicsSet::Sync`]. Empty by default.
+    Last,
+}
+
 /// The global transform of a body at the end of the previous frame.
 /// Used for detecting if the transform was modified before the start of the physics schedule.
 #[derive(Component, Reflect, Clone, Copy, Debug, Default, Deref, DerefMut, PartialEq)]
 #[reflect(Component)]
 pub struct PreviousGlobalTransform(pub GlobalTransform);
 
-type PhysicsObjectAddedFilter = Or<(Added<RigidBody>, Added<Collider>)>;
-
-fn init_previous_global_transform(
+#[allow(clippy::type_complexity)]
+pub(crate) fn init_previous_global_transform(
     mut commands: Commands,
-    query: Query<(Entity, &GlobalTransform), PhysicsObjectAddedFilter>,
+    query: Query<(Entity, &GlobalTransform), Or<(Added<Position>, Added<Rotation>)>>,
 ) {
     for (entity, transform) in &query {
         commands
@@ -155,255 +172,12 @@ fn init_previous_global_transform(
     }
 }
 
-#[allow(clippy::type_complexity)]
-pub(crate) fn update_child_collider_position(
-    mut colliders: Query<
-        (
-            &ColliderTransform,
-            &mut Position,
-            &mut Rotation,
-            &ColliderParent,
-        ),
-        Without<RigidBody>,
-    >,
-    parents: Query<(&Position, &Rotation), (With<RigidBody>, With<Children>)>,
-) {
-    for (collider_transform, mut position, mut rotation, parent) in &mut colliders {
-        let Ok((parent_pos, parent_rot)) = parents.get(parent.get()) else {
-            continue;
-        };
-
-        position.0 = parent_pos.0 + parent_rot.rotate(collider_transform.translation);
-        #[cfg(feature = "2d")]
-        {
-            *rotation = *parent_rot + collider_transform.rotation;
-        }
-        #[cfg(feature = "3d")]
-        {
-            *rotation = (parent_rot.0 * collider_transform.rotation.0)
-                .normalize()
-                .into();
-        }
-    }
-}
-
-#[allow(clippy::type_complexity)]
-pub(crate) fn update_collider_scale(
-    mut colliders: ParamSet<(
-        // Root bodies
-        Query<(&Transform, &mut Collider), Without<Parent>>,
-        // Child colliders
-        Query<(&ColliderTransform, &mut Collider), With<Parent>>,
-    )>,
-) {
-    // Update collider scale for root bodies
-    for (transform, mut collider) in &mut colliders.p0() {
-        #[cfg(feature = "2d")]
-        let scale = transform.scale.truncate().adjust_precision();
-        #[cfg(feature = "3d")]
-        let scale = transform.scale.adjust_precision();
-        if scale != collider.scale() {
-            // TODO: Support configurable subdivision count for shapes that
-            //       can't be represented without approximations after scaling.
-            collider.set_scale(scale, 10);
-        }
-    }
-
-    // Update collider scale for child colliders
-    for (collider_transform, mut collider) in &mut colliders.p1() {
-        if collider_transform.scale != collider.scale() {
-            // TODO: Support configurable subdivision count for shapes that
-            //       can't be represented without approximations after scaling.
-            collider.set_scale(collider_transform.scale, 10);
-        }
-    }
-}
-
-/// Updates [`ColliderTransform`]s based on entity hierarchies. Each transform is computed by recursively
-/// traversing the children of each rigid body and adding their transforms together to form
-/// the total transform relative to the body.
-///
-/// This is largely a clone of `propagate_transforms` in `bevy_transform`.
-#[allow(clippy::type_complexity)]
-pub(crate) fn propagate_collider_transforms(
-    mut root_query: Query<(Entity, Ref<Transform>, &Children), Without<Parent>>,
-    collider_query: Query<
-        (
-            Ref<Transform>,
-            Option<&mut ColliderTransform>,
-            Option<&Children>,
-        ),
-        With<Parent>,
-    >,
-    parent_query: Query<(Entity, Ref<Transform>, Has<RigidBody>, Ref<Parent>)>,
-) {
-    root_query.par_iter_mut().for_each(
-        |(entity, transform,children)| {
-            for (child, child_transform, is_child_rb, parent) in parent_query.iter_many(children) {
-                assert_eq!(
-                    parent.get(), entity,
-                    "Malformed hierarchy. This probably means that your hierarchy has been improperly maintained, or contains a cycle"
-                );
-                let child_transform = ColliderTransform::from(*child_transform);
-
-                // SAFETY:
-                // - `child` must have consistent parentage, or the above assertion would panic.
-                // Since `child` is parented to a root entity, the entire hierarchy leading to it is consistent.
-                // - We may operate as if all descendants are consistent, since `propagate_collider_transform_recursive` will panic before 
-                //   continuing to propagate if it encounters an entity with inconsistent parentage.
-                // - Since each root entity is unique and the hierarchy is consistent and forest-like,
-                //   other root entities' `propagate_collider_transform_recursive` calls will not conflict with this one.
-                // - Since this is the only place where `transform_query` gets used, there will be no conflicting fetches elsewhere.
-                unsafe {
-                    propagate_collider_transforms_recursive(
-                        if is_child_rb {
-                            ColliderTransform {
-                                scale: child_transform.scale,
-                                ..default()
-                            }
-                        } else {
-                            let transform = ColliderTransform::from(*transform);
-
-                            ColliderTransform {
-                                translation: transform.scale * child_transform.translation,
-                                rotation: child_transform.rotation,
-                                scale: (transform.scale * child_transform.scale).max(Vector::splat(Scalar::EPSILON)),
-                            }
-                        },
-                        &collider_query,
-                        &parent_query,
-                        child,
-                        transform.is_changed() || parent.is_changed()
-                    );
-                }
-            }
-        },
-    );
-}
-
-/// Recursively computes the [`ColliderTransform`] for `entity` and all of its descendants
-/// by propagating transforms.
-///
-/// This is largely a clone of `propagate_recursive` in `bevy_transform`.
-///
-/// # Panics
-///
-/// If `entity`'s descendants have a malformed hierarchy, this function will panic occur before propagating
-/// the transforms of any malformed entities and their descendants.
-///
-/// # Safety
-///
-/// - While this function is running, `transform_query` must not have any fetches for `entity`,
-/// nor any of its descendants.
-/// - The caller must ensure that the hierarchy leading to `entity`
-/// is well-formed and must remain as a tree or a forest. Each entity must have at most one parent.
-#[allow(clippy::type_complexity)]
-unsafe fn propagate_collider_transforms_recursive(
-    transform: ColliderTransform,
-    collider_query: &Query<
-        (
-            Ref<Transform>,
-            Option<&mut ColliderTransform>,
-            Option<&Children>,
-        ),
-        With<Parent>,
-    >,
-    parent_query: &Query<(Entity, Ref<Transform>, Has<RigidBody>, Ref<Parent>)>,
-    entity: Entity,
-    mut changed: bool,
-) {
-    let children = {
-        // SAFETY: This call cannot create aliased mutable references.
-        //   - The top level iteration parallelizes on the roots of the hierarchy.
-        //   - The caller ensures that each child has one and only one unique parent throughout the entire
-        //     hierarchy.
-        //
-        // For example, consider the following malformed hierarchy:
-        //
-        //     A
-        //   /   \
-        //  B     C
-        //   \   /
-        //     D
-        //
-        // D has two parents, B and C. If the propagation passes through C, but the Parent component on D points to B,
-        // the above check will panic as the origin parent does match the recorded parent.
-        //
-        // Also consider the following case, where A and B are roots:
-        //
-        //  A       B
-        //   \     /
-        //    C   D
-        //     \ /
-        //      E
-        //
-        // Even if these A and B start two separate tasks running in parallel, one of them will panic before attempting
-        // to mutably access E.
-        let Ok((transform_ref, collider_transform, children)) =
-            (unsafe { collider_query.get_unchecked(entity) })
-        else {
-            return;
-        };
-
-        changed |= transform_ref.is_changed();
-        if changed {
-            if let Some(mut collider_transform) = collider_transform {
-                if *collider_transform != transform {
-                    *collider_transform = transform;
-                }
-            }
-        }
-
-        children
-    };
-
-    let Some(children) = children else { return };
-    for (child, child_transform, is_rb, parent) in parent_query.iter_many(children) {
-        assert_eq!(
-            parent.get(), entity,
-            "Malformed hierarchy. This probably means that your hierarchy has been improperly maintained, or contains a cycle"
-        );
-
-        let child_transform = ColliderTransform::from(*child_transform);
-
-        // SAFETY: The caller guarantees that `transform_query` will not be fetched
-        // for any descendants of `entity`, so it is safe to call `propagate_collider_transforms_recursive` for each child.
-        //
-        // The above assertion ensures that each child has one and only one unique parent throughout the
-        // entire hierarchy.
-        unsafe {
-            propagate_collider_transforms_recursive(
-                if is_rb {
-                    ColliderTransform {
-                        scale: child_transform.scale,
-                        ..default()
-                    }
-                } else {
-                    ColliderTransform {
-                        translation: transform.transform_point(child_transform.translation),
-                        #[cfg(feature = "2d")]
-                        rotation: transform.rotation + child_transform.rotation,
-                        #[cfg(feature = "3d")]
-                        rotation: Rotation(transform.rotation.0 * child_transform.rotation.0),
-                        scale: (transform.scale * child_transform.scale)
-                            .max(Vector::splat(Scalar::EPSILON)),
-                    }
-                },
-                collider_query,
-                parent_query,
-                child,
-                changed || parent.is_changed(),
-            );
-        }
-    }
-}
-
 /// Copies `GlobalTransform` changes to [`Position`] and [`Rotation`].
 /// This allows users to use transforms for moving and positioning bodies and colliders.
 ///
 /// To account for hierarchies, transform propagation should be run before this system.
 #[allow(clippy::type_complexity)]
-fn transform_to_position(
+pub fn transform_to_position(
     mut query: Query<(
         &GlobalTransform,
         &PreviousGlobalTransform,
@@ -494,7 +268,7 @@ type ParentComponents = (
 /// Nested rigid bodies move independently of each other, so the `Transform`s of child entities are updated
 /// based on their own and their parent's [`Position`] and [`Rotation`].
 #[cfg(feature = "2d")]
-fn position_to_transform(
+pub fn position_to_transform(
     mut query: Query<PosToTransformComponents, PosToTransformFilter>,
     parents: Query<ParentComponents, With<Children>>,
 ) {
@@ -541,7 +315,7 @@ fn position_to_transform(
 /// Nested rigid bodies move independently of each other, so the `Transform`s of child entities are updated
 /// based on their own and their parent's [`Position`] and [`Rotation`].
 #[cfg(feature = "3d")]
-fn position_to_transform(
+pub fn position_to_transform(
     mut query: Query<PosToTransformComponents, PosToTransformFilter>,
     parents: Query<ParentComponents, With<Children>>,
 ) {
@@ -576,7 +350,7 @@ fn position_to_transform(
 }
 
 /// Updates [`PreviousGlobalTransform`] by setting it to `GlobalTransform` at the very end or start of a frame.
-fn update_previous_global_transforms(
+pub fn update_previous_global_transforms(
     mut bodies: Query<(&GlobalTransform, &mut PreviousGlobalTransform)>,
 ) {
     for (transform, mut previous_transform) in &mut bodies {