From bab3431674cd5d5cbacdfcb7582b44cba7158028 Mon Sep 17 00:00:00 2001
From: Thierry Berger <contact@thierryberger.com>
Date: Mon, 9 Sep 2024 15:28:56 +0200
Subject: [PATCH] Rapier context as a Component (#545)

Co-authored-by: Anthony Tornetta <25857049+AnthonyTornetta@users.noreply.github.com>
---
 CHANGELOG.md                                  |  13 +
 bevy_rapier2d/Cargo.toml                      |   1 +
 bevy_rapier2d/examples/player_movement2.rs    |   3 +-
 bevy_rapier2d/examples/testbed2.rs            |   4 +-
 bevy_rapier3d/Cargo.toml                      |   1 +
 bevy_rapier3d/examples/joints3.rs             |   2 +-
 bevy_rapier3d/examples/multi_world3.rs        | 120 +++++
 bevy_rapier3d/examples/ray_casting3.rs        |   2 +-
 bevy_rapier_benches3d/src/lib.rs              |   5 +-
 src/pipeline/events.rs                        |  32 +-
 src/plugin/configuration.rs                   |  43 +-
 src/plugin/{context.rs => context/mod.rs}     |  82 +++-
 src/plugin/context/systemparams/mod.rs        |  12 +
 .../rapier_context_systemparam.rs             | 140 ++++++
 src/plugin/mod.rs                             |  10 +-
 src/plugin/plugin.rs                          | 296 ++++++++++--
 src/plugin/systems/character_controller.rs    |  24 +-
 src/plugin/systems/collider.rs                | 180 +++++--
 src/plugin/systems/joint.rs                   |  81 +++-
 src/plugin/systems/mod.rs                     |  63 +--
 .../systems/multiple_rapier_contexts.rs       | 223 +++++++++
 src/plugin/systems/remove.rs                  | 122 +++--
 src/plugin/systems/rigid_body.rs              | 438 +++++++++++-------
 src/plugin/systems/writeback.rs               |  20 +-
 src/render/mod.rs                             |  59 +--
 25 files changed, 1558 insertions(+), 418 deletions(-)
 create mode 100644 bevy_rapier3d/examples/multi_world3.rs
 rename src/plugin/{context.rs => context/mod.rs} (92%)
 create mode 100644 src/plugin/context/systemparams/mod.rs
 create mode 100644 src/plugin/context/systemparams/rapier_context_systemparam.rs
 create mode 100644 src/plugin/systems/multiple_rapier_contexts.rs

diff --git a/CHANGELOG.md b/CHANGELOG.md
index 2c34d5e2..f5b8ddc1 100644
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@@ -21,6 +21,19 @@ which was its hardcoded behaviour.
   `RapierDebugColliderPlugin` and `DebugRenderContext`, as well as individual collider setup via
   a `ColliderDebug` component.
 
+### Modified
+
+- `RapierContext`, `RapierConfiguration` and `RenderToSimulationTime` are now a `Component` instead of resources.
+  - Rapier now supports multiple independent physics worlds, see example `multi_world3` for usage details.
+  - Migration guide:
+    - `ResMut<mut RapierContext>` -> `WriteDefaultRapierContext`
+    - `Res<RapierContext>` -> `ReadDefaultRapierContext`
+    - Access to `RapierConfiguration` and `RenderToSimulationTime` should query for it
+on the responsible entity owning the `RenderContext`.
+  - If you are building a library on top of `bevy_rapier` and would want to support multiple independent physics worlds too,
+you can check out the details of [#545](https://github.com/dimforge/bevy_rapier/pull/545)
+to get more context and information.
+
 ## v0.27.0 (07 July 2024)
 
 **This is an update from rapier 0.19 to Rapier 0.21 which includes several stability improvements
diff --git a/bevy_rapier2d/Cargo.toml b/bevy_rapier2d/Cargo.toml
index b15d611b..4f0a145c 100644
--- a/bevy_rapier2d/Cargo.toml
+++ b/bevy_rapier2d/Cargo.toml
@@ -58,6 +58,7 @@ serde = { version = "1", features = ["derive"], optional = true }
 bevy = { version = "0.14", default-features = false, features = [
     "x11",
     "bevy_state",
+    "bevy_debug_stepping",
 ] }
 oorandom = "11"
 approx = "0.5.1"
diff --git a/bevy_rapier2d/examples/player_movement2.rs b/bevy_rapier2d/examples/player_movement2.rs
index 1a4c0910..7cc1cab5 100644
--- a/bevy_rapier2d/examples/player_movement2.rs
+++ b/bevy_rapier2d/examples/player_movement2.rs
@@ -24,7 +24,8 @@ fn main() {
 #[derive(Component)]
 pub struct Player(f32);
 
-pub fn spawn_player(mut commands: Commands, mut rapier_config: ResMut<RapierConfiguration>) {
+pub fn spawn_player(mut commands: Commands, mut rapier_config: Query<&mut RapierConfiguration>) {
+    let mut rapier_config = rapier_config.single_mut();
     // Set gravity to 0.0 and spawn camera.
     rapier_config.gravity = Vec2::ZERO;
     commands.spawn(Camera2dBundle::default());
diff --git a/bevy_rapier2d/examples/testbed2.rs b/bevy_rapier2d/examples/testbed2.rs
index 3e8dfd27..8a433e22 100644
--- a/bevy_rapier2d/examples/testbed2.rs
+++ b/bevy_rapier2d/examples/testbed2.rs
@@ -204,7 +204,9 @@ fn main() {
             OnExit(Examples::PlayerMovement2),
             (
                 cleanup,
-                |mut rapier_config: ResMut<RapierConfiguration>, ctxt: Res<RapierContext>| {
+                |mut rapier_config: Query<&mut RapierConfiguration>,
+                 ctxt: ReadDefaultRapierContext| {
+                    let mut rapier_config = rapier_config.single_mut();
                     rapier_config.gravity =
                         RapierConfiguration::new(ctxt.integration_parameters.length_unit).gravity;
                 },
diff --git a/bevy_rapier3d/Cargo.toml b/bevy_rapier3d/Cargo.toml
index ac470cec..5e2a77bc 100644
--- a/bevy_rapier3d/Cargo.toml
+++ b/bevy_rapier3d/Cargo.toml
@@ -60,6 +60,7 @@ bevy = { version = "0.14", default-features = false, features = [
     "x11",
     "tonemapping_luts",
     "bevy_state",
+    "bevy_debug_stepping",
 ] }
 approx = "0.5.1"
 glam = { version = "0.27", features = ["approx"] }
diff --git a/bevy_rapier3d/examples/joints3.rs b/bevy_rapier3d/examples/joints3.rs
index 6eb2721c..2864d33b 100644
--- a/bevy_rapier3d/examples/joints3.rs
+++ b/bevy_rapier3d/examples/joints3.rs
@@ -284,7 +284,7 @@ pub fn setup_physics(mut commands: Commands) {
 }
 
 pub fn print_impulse_revolute_joints(
-    context: Res<RapierContext>,
+    context: ReadDefaultRapierContext,
     joints: Query<(Entity, &ImpulseJoint)>,
 ) {
     for (entity, impulse_joint) in joints.iter() {
diff --git a/bevy_rapier3d/examples/multi_world3.rs b/bevy_rapier3d/examples/multi_world3.rs
new file mode 100644
index 00000000..dc5fa807
--- /dev/null
+++ b/bevy_rapier3d/examples/multi_world3.rs
@@ -0,0 +1,120 @@
+use bevy::{input::common_conditions::input_just_pressed, prelude::*};
+use bevy_rapier3d::prelude::*;
+
+const N_WORLDS: usize = 2;
+
+fn main() {
+    App::new()
+        .insert_resource(ClearColor(Color::srgb(
+            0xF9 as f32 / 255.0,
+            0xF9 as f32 / 255.0,
+            0xFF as f32 / 255.0,
+        )))
+        .add_plugins((
+            DefaultPlugins,
+            RapierPhysicsPlugin::<NoUserData>::default()
+                .with_custom_initialization(RapierContextInitialization::NoAutomaticRapierContext),
+            RapierDebugRenderPlugin::default(),
+        ))
+        .add_systems(
+            Startup,
+            ((create_worlds, setup_physics).chain(), setup_graphics),
+        )
+        .add_systems(Update, move_platforms)
+        .add_systems(
+            Update,
+            change_world.run_if(input_just_pressed(KeyCode::KeyC)),
+        )
+        .run();
+}
+
+fn create_worlds(mut commands: Commands) {
+    for i in 0..N_WORLDS {
+        let mut world = commands.spawn((RapierContext::default(), WorldId(i)));
+        if i == 0 {
+            world.insert(DefaultRapierContext);
+        }
+    }
+}
+
+fn setup_graphics(mut commands: Commands) {
+    commands.spawn(Camera3dBundle {
+        transform: Transform::from_xyz(0.0, 3.0, -10.0)
+            .looking_at(Vec3::new(0.0, 0.0, 0.0), Vec3::Y),
+        ..Default::default()
+    });
+}
+
+#[derive(Component)]
+pub struct WorldId(pub usize);
+
+#[derive(Component)]
+struct Platform {
+    starting_y: f32,
+}
+
+fn move_platforms(time: Res<Time>, mut query: Query<(&mut Transform, &Platform)>) {
+    for (mut transform, platform) in query.iter_mut() {
+        transform.translation.y = platform.starting_y + -time.elapsed_seconds().sin();
+    }
+}
+
+/// Demonstrates how easy it is to move one entity to another world.
+fn change_world(
+    query_context: Query<Entity, With<DefaultRapierContext>>,
+    mut query_links: Query<(Entity, &mut RapierContextEntityLink)>,
+) {
+    let default_context = query_context.single();
+    for (e, mut link) in query_links.iter_mut() {
+        if link.0 == default_context {
+            continue;
+        }
+        link.0 = default_context;
+        println!("changing world of {} for world {}", e, link.0);
+    }
+}
+
+pub fn setup_physics(
+    context: Query<(Entity, &WorldId), With<RapierContext>>,
+    mut commands: Commands,
+) {
+    for (context_entity, id) in context.iter() {
+        let id = id.0;
+
+        let color = [
+            Hsla::hsl(220.0, 1.0, 0.3),
+            Hsla::hsl(180.0, 1.0, 0.3),
+            Hsla::hsl(260.0, 1.0, 0.7),
+        ][id % 3];
+
+        /*
+         * Ground
+         */
+        let ground_size = 5.1;
+        let ground_height = 0.1;
+
+        let starting_y = (id as f32) * -0.5 - ground_height;
+
+        let mut platforms = commands.spawn((
+            TransformBundle::from(Transform::from_xyz(0.0, starting_y, 0.0)),
+            Collider::cuboid(ground_size, ground_height, ground_size),
+            ColliderDebugColor(color),
+            RapierContextEntityLink(context_entity),
+        ));
+        if id == 1 {
+            platforms.insert(Platform { starting_y });
+        }
+
+        /*
+         * Create the cube
+         */
+
+        commands.spawn((
+            TransformBundle::from(Transform::from_xyz(0.0, 1.0 + id as f32 * 5.0, 0.0)),
+            RigidBody::Dynamic,
+            Collider::cuboid(0.5, 0.5, 0.5),
+            ColliderDebugColor(color),
+            RapierContextEntityLink(context_entity),
+        ));
+    }
+}
diff --git a/bevy_rapier3d/examples/ray_casting3.rs b/bevy_rapier3d/examples/ray_casting3.rs
index 0840fe7d..d5e45d9e 100644
--- a/bevy_rapier3d/examples/ray_casting3.rs
+++ b/bevy_rapier3d/examples/ray_casting3.rs
@@ -76,7 +76,7 @@ pub fn setup_physics(mut commands: Commands) {
 pub fn cast_ray(
     mut commands: Commands,
     windows: Query<&Window, With<PrimaryWindow>>,
-    rapier_context: Res<RapierContext>,
+    rapier_context: ReadDefaultRapierContext,
     cameras: Query<(&Camera, &GlobalTransform)>,
 ) {
     let window = windows.single();
diff --git a/bevy_rapier_benches3d/src/lib.rs b/bevy_rapier_benches3d/src/lib.rs
index 3e3220aa..6cf4a67d 100644
--- a/bevy_rapier_benches3d/src/lib.rs
+++ b/bevy_rapier_benches3d/src/lib.rs
@@ -26,7 +26,10 @@ pub fn custom_bencher(steps: usize, setup: impl Fn(&mut App)) {
         app.update();
         timer_full_update.pause();
         let elapsed_time = timer_full_update.time() as f32;
-        let rc = app.world().resource::<RapierContext>();
+        let rc = app
+            .world_mut()
+            .query::<&RapierContext>()
+            .single(app.world());
         rapier_step_times.push(rc.pipeline.counters.step_time.time() as f32);
         total_update_times.push(elapsed_time);
     }
diff --git a/src/pipeline/events.rs b/src/pipeline/events.rs
index 850d4a8d..9ae050f6 100644
--- a/src/pipeline/events.rs
+++ b/src/pipeline/events.rs
@@ -1,5 +1,5 @@
 use crate::math::{Real, Vect};
-use bevy::prelude::{Entity, Event, EventWriter};
+use bevy::prelude::{Entity, Event};
 use rapier::dynamics::RigidBodySet;
 use rapier::geometry::{
     ColliderHandle, ColliderSet, CollisionEvent as RapierCollisionEvent, CollisionEventFlags,
@@ -58,8 +58,8 @@ pub(crate) struct EventQueue<'a> {
     // Used to retrieve the entity of colliders that have been removed from the simulation
     // since the last physics step.
     pub deleted_colliders: &'a HashMap<ColliderHandle, Entity>,
-    pub collision_events: RwLock<EventWriter<'a, CollisionEvent>>,
-    pub contact_force_events: RwLock<EventWriter<'a, ContactForceEvent>>,
+    pub collision_events: RwLock<Vec<CollisionEvent>>,
+    pub contact_force_events: RwLock<Vec<ContactForceEvent>>,
 }
 
 impl<'a> EventQueue<'a> {
@@ -94,7 +94,7 @@ impl<'a> EventHandler for EventQueue<'a> {
         };
 
         if let Ok(mut events) = self.collision_events.write() {
-            events.send(event);
+            events.push(event);
         }
     }
 
@@ -118,7 +118,7 @@ impl<'a> EventHandler for EventQueue<'a> {
         };
 
         if let Ok(mut events) = self.contact_force_events.write() {
-            events.send(event);
+            events.push(event);
         }
     }
 }
@@ -155,7 +155,6 @@ mod test {
         pub struct EventsSaver<E: Event> {
             pub events: Vec<E>,
         }
-
         impl<E: Event> Default for EventsSaver<E> {
             fn default() -> Self {
                 Self {
@@ -163,7 +162,6 @@ mod test {
                 }
             }
         }
-
         pub fn save_events<E: Event + Clone>(
             mut events: EventReader<E>,
             mut saver: ResMut<EventsSaver<E>>,
@@ -172,7 +170,6 @@ mod test {
                 saver.events.push(event.clone());
             }
         }
-
         fn run_test(app: &mut App) {
             app.add_systems(PostUpdate, save_events::<CollisionEvent>)
                 .add_systems(PostUpdate, save_events::<ContactForceEvent>)
@@ -192,12 +189,12 @@ mod test {
                 .world()
                 .get_resource::<EventsSaver<CollisionEvent>>()
                 .unwrap();
-            assert_eq!(saved_collisions.events.len(), 3);
+            assert!(saved_collisions.events.len() > 0);
             let saved_contact_forces = app
                 .world()
-                .get_resource::<EventsSaver<ContactForceEvent>>()
+                .get_resource::<EventsSaver<CollisionEvent>>()
                 .unwrap();
-            assert_eq!(saved_contact_forces.events.len(), 1);
+            assert!(saved_contact_forces.events.len() > 0);
         }
 
         /// Adapted from events example
@@ -232,7 +229,7 @@ mod test {
                 TransformBundle::from(Transform::from_xyz(0.0, 13.0, 0.0)),
                 RigidBody::Dynamic,
                 cuboid(0.5, 0.5, 0.5),
-                ActiveEvents::COLLISION_EVENTS | ActiveEvents::CONTACT_FORCE_EVENTS,
+                ActiveEvents::COLLISION_EVENTS,
                 ContactForceEventThreshold(30.0),
             ));
         }
@@ -247,13 +244,10 @@ mod test {
             TransformPlugin,
             RapierPhysicsPlugin::<NoUserData>::default(),
         ))
-        .insert_resource(RapierConfiguration {
-            timestep_mode: TimestepMode::Interpolated {
-                dt: 1.0 / 30.0,
-                time_scale: 1.0,
-                substeps: 2,
-            },
-            ..RapierConfiguration::new(1f32)
+        .insert_resource(TimestepMode::Interpolated {
+            dt: 1.0 / 30.0,
+            time_scale: 1.0,
+            substeps: 2,
         })
         .add_systems(Startup, setup_physics)
         .add_systems(Update, remove_collider);
diff --git a/src/plugin/configuration.rs b/src/plugin/configuration.rs
index fe26fe27..edb3529c 100644
--- a/src/plugin/configuration.rs
+++ b/src/plugin/configuration.rs
@@ -1,20 +1,22 @@
-use bevy::prelude::{FromWorld, Resource, World};
+use bevy::{
+    prelude::{Component, Resource},
+    reflect::Reflect,
+};
 
 use crate::math::{Real, Vect};
-use crate::plugin::RapierContext;
 
 #[cfg(doc)]
 use {crate::prelude::TransformInterpolation, rapier::dynamics::IntegrationParameters};
 
 /// Difference between simulation and rendering time
-#[derive(Resource, Default)]
+#[derive(Component, Default, Reflect)]
 pub struct SimulationToRenderTime {
     /// Difference between simulation and rendering time
     pub diff: f32,
 }
 
-/// The different ways of adjusting the timestep length.
-#[derive(Copy, Clone, Debug, PartialEq)]
+/// The different ways of adjusting the timestep length each frame.
+#[derive(Copy, Clone, Debug, PartialEq, Resource)]
 pub enum TimestepMode {
     /// Use a fixed timestep: the physics simulation will be advanced by the fixed value
     /// `dt` seconds at each Bevy tick by performing `substeps` of length `dt / substeps`.
@@ -53,8 +55,18 @@ pub enum TimestepMode {
     },
 }
 
-#[derive(Resource, Copy, Clone, Debug)]
-/// A resource for specifying configuration information for the physics simulation
+impl Default for TimestepMode {
+    fn default() -> Self {
+        TimestepMode::Variable {
+            max_dt: 1.0 / 60.0,
+            time_scale: 1.0,
+            substeps: 1,
+        }
+    }
+}
+
+#[derive(Component, Copy, Clone, Debug, Reflect)]
+/// A component for specifying configuration information for the physics simulation
 pub struct RapierConfiguration {
     /// Specifying the gravity of the physics simulation.
     pub gravity: Vect,
@@ -62,8 +74,6 @@ pub struct RapierConfiguration {
     pub physics_pipeline_active: bool,
     /// Specifies if the query pipeline is active and update the query pipeline.
     pub query_pipeline_active: bool,
-    /// Specifies the way the timestep length should be adjusted at each frame.
-    pub timestep_mode: TimestepMode,
     /// Specifies the number of subdivisions along each axes a shape should be subdivided
     /// if its scaled representation cannot be represented with the same shape type.
     ///
@@ -76,16 +86,6 @@ pub struct RapierConfiguration {
     pub force_update_from_transform_changes: bool,
 }
 
-impl FromWorld for RapierConfiguration {
-    fn from_world(world: &mut World) -> Self {
-        let length_unit = world
-            .get_resource::<RapierContext>()
-            .map(|ctxt| ctxt.integration_parameters.length_unit)
-            .unwrap_or(1.0);
-        Self::new(length_unit)
-    }
-}
-
 impl RapierConfiguration {
     /// Configures rapier with the specified length unit.
     ///
@@ -98,11 +98,6 @@ impl RapierConfiguration {
             gravity: Vect::Y * -9.81 * length_unit,
             physics_pipeline_active: true,
             query_pipeline_active: true,
-            timestep_mode: TimestepMode::Variable {
-                max_dt: 1.0 / 60.0,
-                time_scale: 1.0,
-                substeps: 1,
-            },
             scaled_shape_subdivision: 10,
             force_update_from_transform_changes: false,
         }
diff --git a/src/plugin/context.rs b/src/plugin/context/mod.rs
similarity index 92%
rename from src/plugin/context.rs
rename to src/plugin/context/mod.rs
index e9de587c..63205b0d 100644
--- a/src/plugin/context.rs
+++ b/src/plugin/context/mod.rs
@@ -1,3 +1,5 @@
+pub mod systemparams;
+
 use bevy::prelude::*;
 use std::collections::HashMap;
 use std::sync::RwLock;
@@ -25,9 +27,25 @@ use rapier::geometry::DefaultBroadPhase;
 #[cfg(doc)]
 use crate::prelude::{ImpulseJoint, MultibodyJoint, RevoluteJoint, TypedJoint};
 
+/// Marker component for to access the default [`RapierContext`].
+///
+/// This is used by [`systemparams::ReadDefaultRapierContext`] and other default accesses
+/// to help with getting a reference to the correct RapierContext.
+///
+/// If you're making a library, you might be interested in [`RapierContextEntityLink`]
+/// and leverage a [`Query<&RapierContext>`] to find the correct [`RapierContext`] of an entity.
+#[derive(Component, Reflect, Debug, Clone, Copy)]
+pub struct DefaultRapierContext;
+
+/// This is a component applied to any entity containing a rapier handle component.
+/// The inner Entity referred to has the component [`RapierContext`] responsible for handling
+/// its rapier data.
+#[derive(Component, Reflect, Debug, Clone, Copy, PartialEq, Eq, Hash)]
+pub struct RapierContextEntityLink(pub Entity);
+
 /// The Rapier context, containing all the state of the physics engine.
 #[cfg_attr(feature = "serde-serialize", derive(Serialize, Deserialize))]
-#[derive(Resource)]
+#[derive(Component)]
 pub struct RapierContext {
     /// The island manager, which detects what object is sleeping
     /// (not moving much) to reduce computations.
@@ -72,6 +90,11 @@ pub struct RapierContext {
     // physics update, to the entity they was attached to.
     #[cfg_attr(feature = "serde-serialize", serde(skip))]
     pub(crate) deleted_colliders: HashMap<ColliderHandle, Entity>,
+
+    #[cfg_attr(feature = "serde-serialize", serde(skip))]
+    pub(crate) collision_events_to_send: Vec<CollisionEvent>,
+    #[cfg_attr(feature = "serde-serialize", serde(skip))]
+    pub(crate) contact_force_events_to_send: Vec<ContactForceEvent>,
     #[cfg_attr(feature = "serde-serialize", serde(skip))]
     pub(crate) character_collisions_collector: Vec<rapier::control::CharacterCollision>,
 }
@@ -97,7 +120,9 @@ impl Default for RapierContext {
             entity2impulse_joint: HashMap::new(),
             entity2multibody_joint: HashMap::new(),
             deleted_colliders: HashMap::new(),
-            character_collisions_collector: vec![],
+            collision_events_to_send: Vec::new(),
+            contact_force_events_to_send: Vec::new(),
+            character_collisions_collector: Vec::new(),
         }
     }
 }
@@ -205,21 +230,28 @@ impl RapierContext {
         &mut self,
         gravity: Vect,
         timestep_mode: TimestepMode,
-        events: Option<(EventWriter<CollisionEvent>, EventWriter<ContactForceEvent>)>,
+        events: Option<(
+            &EventWriter<CollisionEvent>,
+            &EventWriter<ContactForceEvent>,
+        )>,
         hooks: &dyn PhysicsHooks,
         time: &Time,
         sim_to_render_time: &mut SimulationToRenderTime,
         mut interpolation_query: Option<
-            Query<(&RapierRigidBodyHandle, &mut TransformInterpolation)>,
+            &mut Query<(&RapierRigidBodyHandle, &mut TransformInterpolation)>,
         >,
     ) {
-        let event_queue = events.map(|(ce, fe)| EventQueue {
-            deleted_colliders: &self.deleted_colliders,
-            collision_events: RwLock::new(ce),
-            contact_force_events: RwLock::new(fe),
-        });
+        let event_queue = if events.is_some() {
+            Some(EventQueue {
+                deleted_colliders: &self.deleted_colliders,
+                collision_events: RwLock::new(Vec::new()),
+                contact_force_events: RwLock::new(Vec::new()),
+            })
+        } else {
+            None
+        };
 
-        let events = self
+        let event_handler = self
             .event_handler
             .as_deref()
             .or_else(|| event_queue.as_ref().map(|q| q as &dyn EventHandler))
@@ -270,7 +302,7 @@ impl RapierContext {
                             &mut self.ccd_solver,
                             None,
                             hooks,
-                            events,
+                            event_handler,
                         );
                         executed_steps += 1;
                     }
@@ -302,7 +334,7 @@ impl RapierContext {
                         &mut self.ccd_solver,
                         None,
                         hooks,
-                        events,
+                        event_handler,
                     );
                     executed_steps += 1;
                 }
@@ -327,20 +359,42 @@ impl RapierContext {
                         &mut self.ccd_solver,
                         None,
                         hooks,
-                        events,
+                        event_handler,
                     );
                     executed_steps += 1;
                 }
             }
         }
+        if let Some(mut event_queue) = event_queue {
+            // NOTE: event_queue and its inner locks are only accessed from
+            // within `self.pipeline.step` called above, so we can unwrap here safely.
+            self.collision_events_to_send =
+                std::mem::take(event_queue.collision_events.get_mut().unwrap());
+            self.contact_force_events_to_send =
+                std::mem::take(event_queue.contact_force_events.get_mut().unwrap());
+        }
 
         if executed_steps > 0 {
             self.deleted_colliders.clear();
         }
     }
+    /// Generates bevy events for any physics interactions that have happened
+    /// that are stored in the events list
+    pub fn send_bevy_events(
+        &mut self,
+        collision_event_writer: &mut EventWriter<CollisionEvent>,
+        contact_force_event_writer: &mut EventWriter<ContactForceEvent>,
+    ) {
+        for collision_event in self.collision_events_to_send.drain(..) {
+            collision_event_writer.send(collision_event);
+        }
+        for contact_force_event in self.contact_force_events_to_send.drain(..) {
+            contact_force_event_writer.send(contact_force_event);
+        }
+    }
 
     /// This method makes sure that the rigid-body positions have been propagated to
-    /// their attached colliders, without having to perform a stimulation step.
+    /// their attached colliders, without having to perform a simulation step.
     pub fn propagate_modified_body_positions_to_colliders(&mut self) {
         self.bodies
             .propagate_modified_body_positions_to_colliders(&mut self.colliders);
diff --git a/src/plugin/context/systemparams/mod.rs b/src/plugin/context/systemparams/mod.rs
new file mode 100644
index 00000000..93a630e6
--- /dev/null
+++ b/src/plugin/context/systemparams/mod.rs
@@ -0,0 +1,12 @@
+mod rapier_context_systemparam;
+
+use bevy::{ecs::query::QueryData, prelude::Entity};
+pub use rapier_context_systemparam::*;
+
+use super::RapierContextEntityLink;
+
+#[derive(QueryData)]
+pub struct RapierEntity {
+    pub entity: Entity,
+    pub rapier_context_link: &'static RapierContextEntityLink,
+}
diff --git a/src/plugin/context/systemparams/rapier_context_systemparam.rs b/src/plugin/context/systemparams/rapier_context_systemparam.rs
new file mode 100644
index 00000000..0bc5be72
--- /dev/null
+++ b/src/plugin/context/systemparams/rapier_context_systemparam.rs
@@ -0,0 +1,140 @@
+use bevy::ecs::system::SystemParam;
+use bevy::prelude::*;
+use std::ops::{Deref, DerefMut};
+
+use super::super::{DefaultRapierContext, RapierContext, RapierContextEntityLink};
+/// Utility [`SystemParam`] to easily access the single default [`RapierContext`] immutably.
+///
+/// SAFETY: Dereferencing this struct will panic if its underlying query fails.
+/// See [`RapierContextAccess`] for a safer alternative.
+#[derive(SystemParam)]
+pub struct ReadDefaultRapierContext<'w, 's, T: Component = DefaultRapierContext> {
+    rapier_context: Query<'w, 's, &'static RapierContext, With<T>>,
+}
+
+impl<'w, 's, T: Component> ReadDefaultRapierContext<'w, 's, T> {
+    /// Use this method if you only have one [`RapierContext`].
+    ///
+    /// SAFETY: This method will panic if its underlying query fails.
+    /// See [`RapierContextAccess`] for a safe alternative.
+    pub fn single(&'_ self) -> &RapierContext {
+        self.rapier_context.single()
+    }
+}
+
+impl<'w, 's> Deref for ReadDefaultRapierContext<'w, 's> {
+    type Target = RapierContext;
+
+    /// Use this method if you only have one [`RapierContext`].
+    ///
+    /// SAFETY: This method will panic if its underlying query fails.
+    /// See [`RapierContextAccess`] for a safe alternative.
+    fn deref(&self) -> &Self::Target {
+        self.rapier_context.single()
+    }
+}
+
+/// Utility [`SystemParam`] to easily access the single default [`RapierContext`] mutably.
+///
+/// SAFETY: Dereferencing this struct will panic if its underlying query fails.
+/// See [`RapierContextAccess`] for a safer alternative.
+#[derive(SystemParam)]
+pub struct WriteDefaultRapierContext<'w, 's, T: Component = DefaultRapierContext> {
+    rapier_context: Query<'w, 's, &'static mut RapierContext, With<T>>,
+}
+
+impl<'w, 's, T: Component> Deref for WriteDefaultRapierContext<'w, 's, T> {
+    type Target = RapierContext;
+
+    /// Use this method if you only have one [`RapierContext`].
+    ///
+    /// SAFETY: This method will panic if its underlying query fails.
+    /// See [`RapierContextAccess`] for a safe alternative.
+    fn deref(&self) -> &Self::Target {
+        self.rapier_context.single()
+    }
+}
+
+impl<'w, 's> DerefMut for WriteDefaultRapierContext<'w, 's> {
+    /// Use this method if you only have one [`RapierContext`].
+    ///
+    /// SAFETY: This method will panic if its underlying query fails.
+    /// See [`RapierContextAccess`] for a safe alternative.
+    fn deref_mut(&mut self) -> &mut Self::Target {
+        // TODO: should we cache the result ?
+        self.rapier_context.single_mut().into_inner()
+    }
+}
+
+/// Utility [`SystemParam`] to easily access any [`RapierContext`] immutably
+#[derive(SystemParam)]
+pub struct RapierContextAccess<'w, 's> {
+    /// Query used to retrieve a [`RapierContext`].
+    /// It's helpful to iterate over every rapier contexts,
+    /// or get a handle over a specific context, for example through:
+    /// - a marker component such as [`DefaultRapierContext`]
+    /// - a [`RapierContextEntityLink`]. See [context](RapierContextAccess::context)
+    pub rapier_context: Query<'w, 's, &'static RapierContext>,
+}
+
+impl<'w, 's> RapierContextAccess<'w, 's> {
+    /// Retrieves the rapier context responsible for the entity owning the given [`RapierContextEntityLink`].
+    ///
+    /// SAFETY: This method will panic if its underlying query fails.
+    /// See [`Self::try_context`] for a safe alternative.
+    pub fn context(&self, link: &RapierContextEntityLink) -> &'_ RapierContext {
+        self.try_context(link)
+            .expect("RapierContextEntityLink.0 refers to an entity without RapierContext.")
+    }
+
+    /// Retrieves the rapier context responsible for the entity owning the given [`RapierContextEntityLink`].
+    pub fn try_context(&self, link: &RapierContextEntityLink) -> Option<&'_ RapierContext> {
+        self.rapier_context.get(link.0).ok()
+    }
+}
+
+impl<'w, 's> Deref for RapierContextAccess<'w, 's> {
+    type Target = RapierContext;
+
+    fn deref(&self) -> &Self::Target {
+        self.rapier_context.single()
+    }
+}
+
+/// Utility [`SystemParam`] to easily access any [`RapierContext`] mutably
+#[derive(SystemParam)]
+pub struct WriteRapierContext<'w, 's> {
+    /// Query used to retrieve a [`RapierContext`].
+    /// It's helpful to iterate over every rapier contexts,
+    /// or get a handle over a specific context, for example through:
+    /// - a marker component such as [`DefaultRapierContext`]
+    /// - a [`RapierContextEntityLink`]. See [context](RapierContextAccess::context)
+    pub rapier_context: Query<'w, 's, &'static mut RapierContext>,
+}
+
+impl<'w, 's> WriteRapierContext<'w, 's> {
+    /// Retrieves the rapier context responsible for the entity owning the given [`RapierContextEntityLink`].
+    ///
+    /// SAFETY: This method will panic if its underlying query fails.
+    /// See [`Self::try_context`] for a safe alternative.
+    pub fn context(&mut self, link: &RapierContextEntityLink) -> Mut<RapierContext> {
+        self.try_context(link)
+            .expect("RapierContextEntityLink.0 refers to an entity without RapierContext.")
+    }
+
+    /// Retrieves the rapier context responsible for the entity owning the given [`RapierContextEntityLink`].
+    pub fn try_context(&mut self, link: &RapierContextEntityLink) -> Option<Mut<RapierContext>> {
+        self.rapier_context.get_mut(link.0).ok()
+    }
+
+    /// Retrieves the rapier context component on this [`Entity`].
+    ///
+    /// Calling this method on a rapier managed entity (rigid body, collider, joints...) will fail.
+    /// Given entity should have a [`RapierContext`].
+    pub fn try_context_from_entity(
+        &mut self,
+        rapier_context_entity: Entity,
+    ) -> Option<Mut<RapierContext>> {
+        self.rapier_context.get_mut(rapier_context_entity).ok()
+    }
+}
diff --git a/src/plugin/mod.rs b/src/plugin/mod.rs
index 87ae325f..195bcc2b 100644
--- a/src/plugin/mod.rs
+++ b/src/plugin/mod.rs
@@ -1,6 +1,12 @@
 pub use self::configuration::{RapierConfiguration, SimulationToRenderTime, TimestepMode};
-pub use self::context::RapierContext;
-pub use self::plugin::{NoUserData, PhysicsSet, RapierPhysicsPlugin, RapierTransformPropagateSet};
+pub use self::context::{
+    systemparams::{RapierContextAccess, ReadDefaultRapierContext, WriteRapierContext},
+    DefaultRapierContext, RapierContext, RapierContextEntityLink,
+};
+pub use self::plugin::{
+    NoUserData, PhysicsSet, RapierContextInitialization, RapierPhysicsPlugin,
+    RapierTransformPropagateSet,
+};
 pub use narrow_phase::{ContactManifoldView, ContactPairView, ContactView, SolverContactView};
 
 #[allow(clippy::type_complexity)]
diff --git a/src/plugin/plugin.rs b/src/plugin/plugin.rs
index 3a5d6b7d..94a89643 100644
--- a/src/plugin/plugin.rs
+++ b/src/plugin/plugin.rs
@@ -11,6 +11,8 @@ use bevy::{prelude::*, transform::TransformSystem};
 use rapier::dynamics::IntegrationParameters;
 use std::marker::PhantomData;
 
+use super::context::DefaultRapierContext;
+
 /// No specific user-data is associated to the hooks.
 pub type NoUserData = ();
 
@@ -20,8 +22,11 @@ pub type NoUserData = ();
 /// Rapier physics engine.
 pub struct RapierPhysicsPlugin<PhysicsHooks = ()> {
     schedule: Interned<dyn ScheduleLabel>,
-    length_unit: f32,
     default_system_setup: bool,
+    /// Read during [`RapierPhysicsPlugin::build()`],
+    /// to help initializing [`RapierContextInitialization`] resource.
+    /// This will be ignored if that resource already exists.
+    default_world_setup: RapierContextInitialization,
     _phantom: PhantomData<PhysicsHooks>,
 }
 
@@ -37,7 +42,19 @@ where
     /// likely always be 1.0 in 3D. In 2D, this is useful to specify a "pixels-per-meter"
     /// conversion ratio.
     pub fn with_length_unit(mut self, length_unit: f32) -> Self {
-        self.length_unit = length_unit;
+        self.default_world_setup =
+            RapierContextInitialization::InitializeDefaultRapierContext { length_unit };
+        self
+    }
+
+    /// Specifies a default world initialization strategy.
+    ///
+    /// The default is to initialize a [`RapierContext`] with a length unit of 1.
+    pub fn with_custom_initialization(
+        mut self,
+        default_world_initialization: RapierContextInitialization,
+    ) -> Self {
+        self.default_world_setup = default_world_initialization;
         self
     }
 
@@ -56,8 +73,10 @@ where
     #[cfg(feature = "dim2")]
     pub fn pixels_per_meter(pixels_per_meter: f32) -> Self {
         Self {
-            length_unit: pixels_per_meter,
             default_system_setup: true,
+            default_world_setup: RapierContextInitialization::InitializeDefaultRapierContext {
+                length_unit: pixels_per_meter,
+            },
             ..default()
         }
     }
@@ -88,6 +107,9 @@ where
                 )
                     .chain()
                     .in_set(RapierTransformPropagateSet),
+                systems::on_add_entity_with_parent,
+                systems::on_change_world,
+                systems::sync_removals,
                 #[cfg(all(feature = "dim3", feature = "async-collider"))]
                 systems::init_async_scene_colliders,
                 #[cfg(all(feature = "dim3", feature = "async-collider"))]
@@ -95,9 +117,6 @@ where
                 systems::init_rigid_bodies,
                 systems::init_colliders,
                 systems::init_joints,
-                systems::sync_removals,
-                // Run this here so the following systems do not have a 1 frame delay.
-                apply_deferred,
                 systems::apply_scale,
                 systems::apply_collider_user_changes,
                 systems::apply_rigid_body_user_changes,
@@ -127,8 +146,8 @@ impl<PhysicsHooksSystemParam> Default for RapierPhysicsPlugin<PhysicsHooksSystem
     fn default() -> Self {
         Self {
             schedule: PostUpdate.intern(),
-            length_unit: 1.0,
             default_system_setup: true,
+            default_world_setup: default(),
             _phantom: PhantomData,
         }
     }
@@ -181,26 +200,37 @@ where
             .register_type::<SolverGroups>()
             .register_type::<ContactForceEventThreshold>()
             .register_type::<ContactSkin>()
-            .register_type::<Group>();
+            .register_type::<Group>()
+            .register_type::<RapierContextEntityLink>()
+            .register_type::<ColliderDebugColor>()
+            .register_type::<RapierConfiguration>()
+            .register_type::<SimulationToRenderTime>()
+            .register_type::<DefaultRapierContext>()
+            .register_type::<RapierContextInitialization>()
+            .register_type::<ColliderDebugColor>();
 
-        app.insert_resource(SimulationToRenderTime::default())
-            .insert_resource(RapierContext {
-                integration_parameters: IntegrationParameters {
-                    length_unit: self.length_unit,
-                    ..Default::default()
-                },
-                ..Default::default()
-            })
-            .insert_resource(Events::<CollisionEvent>::default())
+        app.insert_resource(Events::<CollisionEvent>::default())
             .insert_resource(Events::<ContactForceEvent>::default())
             .insert_resource(Events::<MassModifiedEvent>::default());
+        let default_world_init = app.world().get_resource::<RapierContextInitialization>();
+        if let Some(world_init) = default_world_init {
+            warn!("RapierPhysicsPlugin added but a `RapierContextInitialization` resource was already existing.\
+            This might overwrite previous configuration made via `RapierPhysicsPlugin::with_custom_initialization`\
+            or `RapierPhysicsPlugin::with_length_unit`.
+            The following resource will be used: {:?}", world_init);
+        } else {
+            app.insert_resource(self.default_world_setup.clone());
+        }
 
-        // Insert all of our required resources. Don’t overwrite
-        // the `RapierConfiguration` if it already exists.
-        //
-        // NOTE: be sure to call this after the `.insert_resource(RapierContext)` so we can
-        //       access the length_unit when initializing the RapierConfiguration.
-        app.init_resource::<RapierConfiguration>();
+        app.add_systems(
+            self.schedule,
+            (
+                setup_rapier_configuration,
+                setup_rapier_simulation_to_render_time,
+            )
+                .before(PhysicsSet::SyncBackend),
+        );
+        app.add_systems(PreStartup, insert_default_world);
 
         // Add each set as necessary
         if self.default_system_setup {
@@ -215,9 +245,6 @@ where
                     .before(TransformSystem::TransformPropagate),
             );
 
-            // These *must* be in the main schedule currently so that they do not miss events.
-            app.add_systems(PostUpdate, (systems::sync_removals,));
-
             app.add_systems(
                 self.schedule,
                 (
@@ -227,11 +254,12 @@ where
                     Self::get_systems(PhysicsSet::Writeback).in_set(PhysicsSet::Writeback),
                 ),
             );
+            app.init_resource::<TimestepMode>();
 
             // Warn user if the timestep mode isn't in Fixed
             if self.schedule.as_dyn_eq().dyn_eq(FixedUpdate.as_dyn_eq()) {
-                let config = app.world_mut().resource::<RapierConfiguration>();
-                match config.timestep_mode {
+                let config = app.world_mut().resource::<TimestepMode>();
+                match config {
                     TimestepMode::Fixed { .. } => {}
                     mode => {
                         warn!("TimestepMode is set to `{:?}`, it is recommended to use `TimestepMode::Fixed` if you have the physics in `FixedUpdate`", mode);
@@ -241,3 +269,215 @@ where
         }
     }
 }
+
+/// Specifies a default configuration for the default [`RapierContext`]
+///
+/// Designed to be passed as parameter to [`RapierPhysicsPlugin::with_custom_initialization`].
+#[derive(Resource, Debug, Reflect, Clone)]
+pub enum RapierContextInitialization {
+    /// [`RapierPhysicsPlugin`] will not spawn any entity containing [`RapierContext`] automatically.
+    ///
+    /// You are responsible for creating a [`RapierContext`],
+    /// before spawning any rapier entities (rigidbodies, colliders, joints).
+    ///
+    /// You might be interested in adding [`DefaultRapierContext`] to the created world.
+    NoAutomaticRapierContext,
+    /// [`RapierPhysicsPlugin`] will spawn an entity containing a [`RapierContext`]
+    /// automatically during [`PreStartup`], with the [`DefaultRapierContext`] marker component.
+    InitializeDefaultRapierContext {
+        /// See [`IntegrationParameters::length_unit`]
+        length_unit: f32,
+    },
+}
+
+impl Default for RapierContextInitialization {
+    fn default() -> Self {
+        RapierContextInitialization::InitializeDefaultRapierContext { length_unit: 1f32 }
+    }
+}
+
+pub fn insert_default_world(
+    mut commands: Commands,
+    initialization_data: Res<RapierContextInitialization>,
+) {
+    match initialization_data.as_ref() {
+        RapierContextInitialization::NoAutomaticRapierContext => {}
+        RapierContextInitialization::InitializeDefaultRapierContext { length_unit } => {
+            commands.spawn((
+                Name::new("Rapier Context"),
+                RapierContext {
+                    integration_parameters: IntegrationParameters {
+                        length_unit: *length_unit,
+                        ..default()
+                    },
+                    ..RapierContext::default()
+                },
+                DefaultRapierContext,
+            ));
+        }
+    }
+}
+
+pub fn setup_rapier_configuration(
+    mut commands: Commands,
+    rapier_context: Query<(Entity, &RapierContext), Without<RapierConfiguration>>,
+) {
+    for (e, rapier_context) in rapier_context.iter() {
+        commands.entity(e).insert(RapierConfiguration::new(
+            rapier_context.integration_parameters.length_unit,
+        ));
+    }
+}
+pub fn setup_rapier_simulation_to_render_time(
+    mut commands: Commands,
+    rapier_context: Query<Entity, (With<RapierContext>, Without<SimulationToRenderTime>)>,
+) {
+    for e in rapier_context.iter() {
+        commands.entity(e).insert(SimulationToRenderTime::default());
+    }
+}
+
+#[cfg(test)]
+mod test {
+
+    use bevy::{
+        ecs::schedule::Stepping,
+        prelude::Component,
+        time::{TimePlugin, TimeUpdateStrategy},
+    };
+    use rapier::{data::Index, dynamics::RigidBodyHandle};
+    use systems::tests::HeadlessRenderPlugin;
+
+    use crate::{plugin::*, prelude::*};
+
+    #[cfg(feature = "dim3")]
+    fn cuboid(hx: Real, hy: Real, hz: Real) -> Collider {
+        Collider::cuboid(hx, hy, hz)
+    }
+    #[cfg(feature = "dim2")]
+    fn cuboid(hx: Real, hy: Real, _hz: Real) -> Collider {
+        Collider::cuboid(hx, hy)
+    }
+
+    #[derive(Component)]
+    pub struct TestMarker;
+
+    #[test]
+    pub fn hierarchy_link_propagation() {
+        return main();
+
+        use bevy::prelude::*;
+
+        fn run_test(app: &mut App) {
+            app.insert_resource(TimeUpdateStrategy::ManualDuration(
+                std::time::Duration::from_secs_f32(1f32 / 60f32),
+            ));
+
+            app.add_systems(Update, setup_physics);
+
+            let mut stepping = Stepping::new();
+
+            app.update();
+
+            stepping
+                .add_schedule(PostUpdate)
+                .add_schedule(Update)
+                .enable()
+                .set_breakpoint(PostUpdate, systems::on_add_entity_with_parent)
+                .set_breakpoint(PostUpdate, systems::init_rigid_bodies)
+                .set_breakpoint(PostUpdate, systems::on_change_world)
+                .set_breakpoint(PostUpdate, systems::sync_removals)
+                .set_breakpoint(Update, setup_physics);
+
+            app.insert_resource(stepping);
+
+            let mut stepping = app.world_mut().resource_mut::<Stepping>();
+            // Advancing once to get the context.
+            stepping.continue_frame();
+            app.update();
+            // arbitrary hardcoded amount to run the simulation for a few frames.
+            // This test uses stepping so the actual amount of frames is this `number / breakpoints`
+            for _ in 0..20 {
+                let world = app.world_mut();
+                let stepping = world.resource_mut::<Stepping>();
+                if let Some(cursor) = &stepping.cursor() {
+                    let system = world
+                        .resource::<Schedules>()
+                        .get(cursor.0)
+                        .unwrap()
+                        .systems()
+                        .unwrap()
+                        .find(|s| s.0 == cursor.1)
+                        .unwrap();
+                    println!(
+                        "next system: {}",
+                        system
+                            .1
+                            .name()
+                            .to_string()
+                            .split_terminator("::")
+                            .last()
+                            .unwrap()
+                    );
+                } else {
+                    println!("no cursor, new frame!");
+                }
+                let mut stepping = world.resource_mut::<Stepping>();
+                stepping.continue_frame();
+                app.update();
+                let context = app
+                    .world_mut()
+                    .query::<&RapierContext>()
+                    .get_single(&app.world())
+                    .unwrap();
+
+                println!("{:?}", &context.entity2body);
+            }
+            let context = app
+                .world_mut()
+                .query::<&RapierContext>()
+                .get_single(&app.world())
+                .unwrap();
+
+            assert_eq!(
+                context.entity2body.iter().next().unwrap().1,
+                // assert the generation is 0, that means we didn't modify it twice (due to change world detection)
+                &RigidBodyHandle(Index::from_raw_parts(0, 0))
+            );
+        }
+
+        fn main() {
+            let mut app = App::new();
+            app.add_plugins((
+                HeadlessRenderPlugin,
+                TransformPlugin,
+                TimePlugin,
+                RapierPhysicsPlugin::<NoUserData>::default(),
+            ));
+            run_test(&mut app);
+        }
+
+        pub fn setup_physics(mut commands: Commands, mut counter: Local<i32>) {
+            // run on the 3rd iteration: I believe current logic is:
+            // - 1st is to setup bevy internals
+            // - 2nd is to wait for having stepping enabled, as I couldnt get it to work for the first update.
+            // - 3rd, we're looking to test adding a rapier entity while playing, opposed to a Startup function,
+            //   which most examples are focused on.
+            let run_at = 3;
+            if *counter == run_at {
+                return;
+            }
+            *counter += 1;
+            if *counter < run_at {
+                return;
+            }
+
+            commands.spawn((
+                TransformBundle::from(Transform::from_xyz(0.0, 13.0, 0.0)),
+                RigidBody::Dynamic,
+                cuboid(0.5, 0.5, 0.5),
+                TestMarker,
+            ));
+        }
+    }
+}
diff --git a/src/plugin/systems/character_controller.rs b/src/plugin/systems/character_controller.rs
index c9e2cb58..e349db78 100644
--- a/src/plugin/systems/character_controller.rs
+++ b/src/plugin/systems/character_controller.rs
@@ -1,8 +1,9 @@
 use crate::control::CharacterCollision;
 use crate::dynamics::RapierRigidBodyHandle;
 use crate::geometry::RapierColliderHandle;
+use crate::plugin::context::RapierContextEntityLink;
 use crate::plugin::RapierConfiguration;
-use crate::plugin::RapierContext;
+use crate::plugin::WriteRapierContext;
 use crate::prelude::KinematicCharacterController;
 use crate::prelude::KinematicCharacterControllerOutput;
 use crate::utils;
@@ -15,10 +16,11 @@ use rapier::pipeline::QueryFilter;
 /// collider.
 pub fn update_character_controls(
     mut commands: Commands,
-    config: Res<RapierConfiguration>,
-    mut context: ResMut<RapierContext>,
+    config: Query<&RapierConfiguration>,
+    mut context_access: WriteRapierContext,
     mut character_controllers: Query<(
         Entity,
+        &RapierContextEntityLink,
         &mut KinematicCharacterController,
         Option<&mut KinematicCharacterControllerOutput>,
         Option<&RapierColliderHandle>,
@@ -27,13 +29,23 @@ pub fn update_character_controls(
     )>,
     mut transforms: Query<&mut Transform>,
 ) {
-    let context = &mut *context;
-    for (entity, mut controller, output, collider_handle, body_handle, glob_transform) in
-        character_controllers.iter_mut()
+    for (
+        entity,
+        rapier_context_link,
+        mut controller,
+        output,
+        collider_handle,
+        body_handle,
+        glob_transform,
+    ) in character_controllers.iter_mut()
     {
         if let (Some(raw_controller), Some(translation)) =
             (controller.to_raw(), controller.translation)
         {
+            let config = config
+                .get(rapier_context_link.0)
+                .expect("Could not get [`RapierConfiguration`]");
+            let context = context_access.context(rapier_context_link).into_inner();
             let scaled_custom_shape =
                 controller
                     .custom_shape
diff --git a/src/plugin/systems/collider.rs b/src/plugin/systems/collider.rs
index f3edc0be..7d094f0d 100644
--- a/src/plugin/systems/collider.rs
+++ b/src/plugin/systems/collider.rs
@@ -1,6 +1,8 @@
 use crate::dynamics::ReadMassProperties;
 use crate::geometry::Collider;
-use crate::plugin::{RapierConfiguration, RapierContext};
+use crate::plugin::context::systemparams::RapierEntity;
+use crate::plugin::context::RapierContextEntityLink;
+use crate::plugin::{DefaultRapierContext, RapierConfiguration, RapierContext, WriteRapierContext};
 use crate::prelude::{
     ActiveCollisionTypes, ActiveEvents, ActiveHooks, ColliderDisabled, ColliderMassProperties,
     ColliderScale, CollidingEntities, CollisionEvent, CollisionGroups, ContactForceEventThreshold,
@@ -22,7 +24,7 @@ use bevy::math::Vec3Swizzles;
 
 /// Components related to colliders.
 pub type ColliderComponents<'a> = (
-    Entity,
+    (Entity, Option<&'a RapierContextEntityLink>),
     &'a Collider,
     Option<&'a Sensor>,
     Option<&'a ColliderMassProperties>,
@@ -41,9 +43,14 @@ pub type ColliderComponents<'a> = (
 /// System responsible for applying [`GlobalTransform`] scale and/or [`ColliderScale`] to
 /// colliders.
 pub fn apply_scale(
-    config: Res<RapierConfiguration>,
+    config: Query<&RapierConfiguration>,
     mut changed_collider_scales: Query<
-        (&mut Collider, &GlobalTransform, Option<&ColliderScale>),
+        (
+            &mut Collider,
+            &RapierContextEntityLink,
+            &GlobalTransform,
+            Option<&ColliderScale>,
+        ),
         Or<(
             Changed<Collider>,
             Changed<GlobalTransform>,
@@ -51,7 +58,8 @@ pub fn apply_scale(
         )>,
     >,
 ) {
-    for (mut shape, transform, custom_scale) in changed_collider_scales.iter_mut() {
+    for (mut shape, link, transform, custom_scale) in changed_collider_scales.iter_mut() {
+        let config = config.get(link.0).unwrap();
         #[cfg(feature = "dim2")]
         let effective_scale = match custom_scale {
             Some(ColliderScale::Absolute(scale)) => *scale,
@@ -75,51 +83,74 @@ pub fn apply_scale(
 
 /// System responsible for applying changes the user made to a collider-related component.
 pub fn apply_collider_user_changes(
-    mut context: ResMut<RapierContext>,
-    config: Res<RapierConfiguration>,
+    mut context: WriteRapierContext,
+    config: Query<&RapierConfiguration>,
     (changed_collider_transforms, parent_query, transform_query): (
         Query<
-            (Entity, &RapierColliderHandle, &GlobalTransform),
+            (RapierEntity, &RapierColliderHandle, &GlobalTransform),
             (Without<RapierRigidBodyHandle>, Changed<GlobalTransform>),
         >,
         Query<&Parent>,
         Query<&Transform>,
     ),
 
-    changed_shapes: Query<(&RapierColliderHandle, &Collider), Changed<Collider>>,
-    changed_active_events: Query<(&RapierColliderHandle, &ActiveEvents), Changed<ActiveEvents>>,
-    changed_active_hooks: Query<(&RapierColliderHandle, &ActiveHooks), Changed<ActiveHooks>>,
+    changed_shapes: Query<(RapierEntity, &RapierColliderHandle, &Collider), Changed<Collider>>,
+    changed_active_events: Query<
+        (RapierEntity, &RapierColliderHandle, &ActiveEvents),
+        Changed<ActiveEvents>,
+    >,
+    changed_active_hooks: Query<
+        (RapierEntity, &RapierColliderHandle, &ActiveHooks),
+        Changed<ActiveHooks>,
+    >,
     changed_active_collision_types: Query<
-        (&RapierColliderHandle, &ActiveCollisionTypes),
+        (RapierEntity, &RapierColliderHandle, &ActiveCollisionTypes),
         Changed<ActiveCollisionTypes>,
     >,
     (changed_friction, changed_restitution, changed_contact_skin): (
-        Query<(&RapierColliderHandle, &Friction), Changed<Friction>>,
-        Query<(&RapierColliderHandle, &Restitution), Changed<Restitution>>,
-        Query<(&RapierColliderHandle, &ContactSkin), Changed<ContactSkin>>,
+        Query<(RapierEntity, &RapierColliderHandle, &Friction), Changed<Friction>>,
+        Query<(RapierEntity, &RapierColliderHandle, &Restitution), Changed<Restitution>>,
+        Query<(RapierEntity, &RapierColliderHandle, &ContactSkin), Changed<ContactSkin>>,
     ),
     changed_collision_groups: Query<
-        (&RapierColliderHandle, &CollisionGroups),
+        (RapierEntity, &RapierColliderHandle, &CollisionGroups),
         Changed<CollisionGroups>,
     >,
-    changed_solver_groups: Query<(&RapierColliderHandle, &SolverGroups), Changed<SolverGroups>>,
-    changed_sensors: Query<(&RapierColliderHandle, &Sensor), Changed<Sensor>>,
-    changed_disabled: Query<(&RapierColliderHandle, &ColliderDisabled), Changed<ColliderDisabled>>,
+    changed_solver_groups: Query<
+        (RapierEntity, &RapierColliderHandle, &SolverGroups),
+        Changed<SolverGroups>,
+    >,
+    changed_sensors: Query<(RapierEntity, &RapierColliderHandle, &Sensor), Changed<Sensor>>,
+    changed_disabled: Query<
+        (RapierEntity, &RapierColliderHandle, &ColliderDisabled),
+        Changed<ColliderDisabled>,
+    >,
     changed_contact_force_threshold: Query<
-        (&RapierColliderHandle, &ContactForceEventThreshold),
+        (
+            RapierEntity,
+            &RapierColliderHandle,
+            &ContactForceEventThreshold,
+        ),
         Changed<ContactForceEventThreshold>,
     >,
     changed_collider_mass_props: Query<
-        (&RapierColliderHandle, &ColliderMassProperties),
+        (RapierEntity, &RapierColliderHandle, &ColliderMassProperties),
         Changed<ColliderMassProperties>,
     >,
 
     mut mass_modified: EventWriter<MassModifiedEvent>,
 ) {
-    for (entity, handle, transform) in changed_collider_transforms.iter() {
-        if context.collider_parent(entity).is_some() {
-            let (_, collider_position) =
-                collider_offset(entity, &context, &parent_query, &transform_query);
+    for (rapier_entity, handle, transform) in changed_collider_transforms.iter() {
+        let context = context
+            .context(rapier_entity.rapier_context_link)
+            .into_inner();
+        if context.collider_parent(rapier_entity.entity).is_some() {
+            let (_, collider_position) = collider_offset(
+                rapier_entity.entity,
+                context,
+                &parent_query,
+                &transform_query,
+            );
 
             if let Some(co) = context.colliders.get_mut(handle.0) {
                 co.set_position_wrt_parent(utils::transform_to_iso(&collider_position));
@@ -129,7 +160,11 @@ pub fn apply_collider_user_changes(
         }
     }
 
-    for (handle, shape) in changed_shapes.iter() {
+    for (rapier_entity, handle, shape) in changed_shapes.iter() {
+        let context = context
+            .context(rapier_entity.rapier_context_link)
+            .into_inner();
+        let config = config.get(rapier_entity.rapier_context_link.0).unwrap();
         if let Some(co) = context.colliders.get_mut(handle.0) {
             let mut scaled_shape = shape.clone();
             scaled_shape.set_scale(shape.scale, config.scaled_shape_subdivision);
@@ -143,75 +178,111 @@ pub fn apply_collider_user_changes(
         }
     }
 
-    for (handle, active_events) in changed_active_events.iter() {
+    for (rapier_entity, handle, active_events) in changed_active_events.iter() {
+        let context = context
+            .context(rapier_entity.rapier_context_link)
+            .into_inner();
         if let Some(co) = context.colliders.get_mut(handle.0) {
             co.set_active_events((*active_events).into())
         }
     }
 
-    for (handle, active_hooks) in changed_active_hooks.iter() {
+    for (rapier_entity, handle, active_hooks) in changed_active_hooks.iter() {
+        let context = context
+            .context(rapier_entity.rapier_context_link)
+            .into_inner();
         if let Some(co) = context.colliders.get_mut(handle.0) {
             co.set_active_hooks((*active_hooks).into())
         }
     }
 
-    for (handle, active_collision_types) in changed_active_collision_types.iter() {
+    for (rapier_entity, handle, active_collision_types) in changed_active_collision_types.iter() {
+        let context = context
+            .context(rapier_entity.rapier_context_link)
+            .into_inner();
         if let Some(co) = context.colliders.get_mut(handle.0) {
             co.set_active_collision_types((*active_collision_types).into())
         }
     }
 
-    for (handle, friction) in changed_friction.iter() {
+    for (rapier_entity, handle, friction) in changed_friction.iter() {
+        let context = context
+            .context(rapier_entity.rapier_context_link)
+            .into_inner();
         if let Some(co) = context.colliders.get_mut(handle.0) {
             co.set_friction(friction.coefficient);
             co.set_friction_combine_rule(friction.combine_rule.into());
         }
     }
 
-    for (handle, restitution) in changed_restitution.iter() {
+    for (rapier_entity, handle, restitution) in changed_restitution.iter() {
+        let context = context
+            .context(rapier_entity.rapier_context_link)
+            .into_inner();
         if let Some(co) = context.colliders.get_mut(handle.0) {
             co.set_restitution(restitution.coefficient);
             co.set_restitution_combine_rule(restitution.combine_rule.into());
         }
     }
 
-    for (handle, contact_skin) in changed_contact_skin.iter() {
+    for (rapier_entity, handle, contact_skin) in changed_contact_skin.iter() {
+        let context = context
+            .context(rapier_entity.rapier_context_link)
+            .into_inner();
         if let Some(co) = context.colliders.get_mut(handle.0) {
             co.set_contact_skin(contact_skin.0);
         }
     }
 
-    for (handle, collision_groups) in changed_collision_groups.iter() {
+    for (rapier_entity, handle, collision_groups) in changed_collision_groups.iter() {
+        let context = context
+            .context(rapier_entity.rapier_context_link)
+            .into_inner();
         if let Some(co) = context.colliders.get_mut(handle.0) {
             co.set_collision_groups((*collision_groups).into());
         }
     }
 
-    for (handle, solver_groups) in changed_solver_groups.iter() {
+    for (rapier_entity, handle, solver_groups) in changed_solver_groups.iter() {
+        let context = context
+            .context(rapier_entity.rapier_context_link)
+            .into_inner();
         if let Some(co) = context.colliders.get_mut(handle.0) {
             co.set_solver_groups((*solver_groups).into());
         }
     }
 
-    for (handle, _) in changed_sensors.iter() {
+    for (rapier_entity, handle, _) in changed_sensors.iter() {
+        let context = context
+            .context(rapier_entity.rapier_context_link)
+            .into_inner();
         if let Some(co) = context.colliders.get_mut(handle.0) {
             co.set_sensor(true);
         }
     }
 
-    for (handle, _) in changed_disabled.iter() {
+    for (rapier_entity, handle, _) in changed_disabled.iter() {
+        let context = context
+            .context(rapier_entity.rapier_context_link)
+            .into_inner();
         if let Some(co) = context.colliders.get_mut(handle.0) {
             co.set_enabled(false);
         }
     }
 
-    for (handle, threshold) in changed_contact_force_threshold.iter() {
+    for (rapier_entity, handle, threshold) in changed_contact_force_threshold.iter() {
+        let context = context
+            .context(rapier_entity.rapier_context_link)
+            .into_inner();
         if let Some(co) = context.colliders.get_mut(handle.0) {
             co.set_contact_force_event_threshold(threshold.0);
         }
     }
 
-    for (handle, mprops) in changed_collider_mass_props.iter() {
+    for (rapier_entity, handle, mprops) in changed_collider_mass_props.iter() {
+        let context = context
+            .context(rapier_entity.rapier_context_link)
+            .into_inner();
         if let Some(co) = context.colliders.get_mut(handle.0) {
             match mprops {
                 ColliderMassProperties::Density(density) => co.set_density(*density),
@@ -269,18 +340,17 @@ pub(crate) fn collider_offset(
 /// System responsible for creating new Rapier colliders from the related `bevy_rapier` components.
 pub fn init_colliders(
     mut commands: Commands,
-    config: Res<RapierConfiguration>,
-    mut context: ResMut<RapierContext>,
+    config: Query<&RapierConfiguration>,
+    mut context_access: WriteRapierContext,
+    default_context_access: Query<Entity, With<DefaultRapierContext>>,
     colliders: Query<(ColliderComponents, Option<&GlobalTransform>), Without<RapierColliderHandle>>,
     mut rigid_body_mprops: Query<&mut ReadMassProperties>,
     parent_query: Query<&Parent>,
     transform_query: Query<&Transform>,
 ) {
-    let context = &mut *context;
-
     for (
         (
-            entity,
+            (entity, entity_context_link),
             shape,
             sensor,
             mprops,
@@ -298,6 +368,29 @@ pub fn init_colliders(
         global_transform,
     ) in colliders.iter()
     {
+        // Get rapier context from RapierContextEntityLink or insert its default value.
+        let context_entity = entity_context_link.map_or_else(
+            || {
+                let context_entity = default_context_access.get_single().ok()?;
+                commands
+                    .entity(entity)
+                    .insert(RapierContextEntityLink(context_entity));
+                Some(context_entity)
+            },
+            |link| Some(link.0),
+        );
+        let Some(context_entity) = context_entity else {
+            continue;
+        };
+
+        let config = config.get(context_entity).unwrap_or_else(|_| {
+            panic!("Failed to retrieve `RapierConfiguration` on entity {context_entity}.")
+        });
+        let Some(context) = context_access.try_context_from_entity(context_entity) else {
+            log::error!("Could not find entity {context_entity} with rapier context while initializing {entity}");
+            continue;
+        };
+        let context = context.into_inner();
         let mut scaled_shape = shape.clone();
         scaled_shape.set_scale(shape.scale, config.scaled_shape_subdivision);
         let mut builder = ColliderBuilder::new(scaled_shape.raw.clone());
@@ -354,7 +447,6 @@ pub fn init_colliders(
         if let Some(threshold) = contact_force_event_threshold {
             builder = builder.contact_force_event_threshold(threshold.0);
         }
-
         let body_entity = entity;
         let (body_handle, child_transform) =
             collider_offset(entity, context, &parent_query, &transform_query);
diff --git a/src/plugin/systems/joint.rs b/src/plugin/systems/joint.rs
index df3e489d..f162a0ef 100644
--- a/src/plugin/systems/joint.rs
+++ b/src/plugin/systems/joint.rs
@@ -2,20 +2,47 @@ use crate::dynamics::ImpulseJoint;
 use crate::dynamics::MultibodyJoint;
 use crate::dynamics::RapierImpulseJointHandle;
 use crate::dynamics::RapierMultibodyJointHandle;
-use crate::plugin::RapierContext;
+use crate::plugin::context::RapierContextEntityLink;
+use crate::plugin::DefaultRapierContext;
+use crate::plugin::WriteRapierContext;
 use bevy::prelude::*;
 
 /// System responsible for creating new Rapier joints from the related `bevy_rapier` components.
 pub fn init_joints(
     mut commands: Commands,
-    mut context: ResMut<RapierContext>,
-    impulse_joints: Query<(Entity, &ImpulseJoint), Without<RapierImpulseJointHandle>>,
-    multibody_joints: Query<(Entity, &MultibodyJoint), Without<RapierMultibodyJointHandle>>,
+    mut context_access: WriteRapierContext,
+    default_context_access: Query<Entity, With<DefaultRapierContext>>,
+    impulse_joints: Query<
+        (Entity, Option<&RapierContextEntityLink>, &ImpulseJoint),
+        Without<RapierImpulseJointHandle>,
+    >,
+    multibody_joints: Query<
+        (Entity, Option<&RapierContextEntityLink>, &MultibodyJoint),
+        Without<RapierMultibodyJointHandle>,
+    >,
     parent_query: Query<&Parent>,
 ) {
-    let context = &mut *context;
+    for (entity, entity_context_link, joint) in impulse_joints.iter() {
+        // Get rapier context from RapierContextEntityLink or insert its default value.
+        let context_entity = entity_context_link.map_or_else(
+            || {
+                let context_entity = default_context_access.get_single().ok()?;
+                commands
+                    .entity(entity)
+                    .insert(RapierContextEntityLink(context_entity));
+                Some(context_entity)
+            },
+            |link| Some(link.0),
+        );
+        let Some(context_entity) = context_entity else {
+            continue;
+        };
 
-    for (entity, joint) in impulse_joints.iter() {
+        let Some(context) = context_access.try_context_from_entity(context_entity) else {
+            log::error!("Could not find entity {context_entity} with rapier context while initializing {entity}");
+            continue;
+        };
+        let context = context.into_inner();
         let mut target = None;
         let mut body_entity = entity;
         while target.is_none() {
@@ -41,7 +68,27 @@ pub fn init_joints(
         }
     }
 
-    for (entity, joint) in multibody_joints.iter() {
+    for (entity, entity_context_link, joint) in multibody_joints.iter() {
+        // Get rapier context from RapierContextEntityLink or insert its default value.
+        let context_entity = entity_context_link.map_or_else(
+            || {
+                let context_entity = default_context_access.get_single().ok()?;
+                commands
+                    .entity(entity)
+                    .insert(RapierContextEntityLink(context_entity));
+                Some(context_entity)
+            },
+            |link| Some(link.0),
+        );
+        let Some(context_entity) = context_entity else {
+            continue;
+        };
+
+        let Some(context) = context_access.try_context_from_entity(context_entity) else {
+            log::error!("Could not find entity {context_entity} with rapier context while initializing {entity}");
+            continue;
+        };
+        let context = context.into_inner();
         let target = context.entity2body.get(&entity);
 
         if let (Some(target), Some(source)) = (target, context.entity2body.get(&joint.parent)) {
@@ -64,25 +111,35 @@ pub fn init_joints(
 
 /// System responsible for applying changes the user made to a joint component.
 pub fn apply_joint_user_changes(
-    mut context: ResMut<RapierContext>,
+    mut context: WriteRapierContext,
     changed_impulse_joints: Query<
-        (&RapierImpulseJointHandle, &ImpulseJoint),
+        (
+            &RapierContextEntityLink,
+            &RapierImpulseJointHandle,
+            &ImpulseJoint,
+        ),
         Changed<ImpulseJoint>,
     >,
     changed_multibody_joints: Query<
-        (&RapierMultibodyJointHandle, &MultibodyJoint),
+        (
+            &RapierContextEntityLink,
+            &RapierMultibodyJointHandle,
+            &MultibodyJoint,
+        ),
         Changed<MultibodyJoint>,
     >,
 ) {
     // TODO: right now, we only support propagating changes made to the joint data.
     //       Re-parenting the joint isn’t supported yet.
-    for (handle, changed_joint) in changed_impulse_joints.iter() {
+    for (link, handle, changed_joint) in changed_impulse_joints.iter() {
+        let context = context.context(link).into_inner();
         if let Some(joint) = context.impulse_joints.get_mut(handle.0) {
             joint.data = changed_joint.data.as_ref().into_rapier();
         }
     }
 
-    for (handle, changed_joint) in changed_multibody_joints.iter() {
+    for (link, handle, changed_joint) in changed_multibody_joints.iter() {
+        let context = context.context(link).into_inner();
         // TODO: not sure this will always work properly, e.g., if the number of Dofs is changed.
         if let Some((mb, link_id)) = context.multibody_joints.get_mut(handle.0) {
             if let Some(link) = mb.link_mut(link_id) {
diff --git a/src/plugin/systems/mod.rs b/src/plugin/systems/mod.rs
index 658ddf0a..b1cc80f6 100644
--- a/src/plugin/systems/mod.rs
+++ b/src/plugin/systems/mod.rs
@@ -3,6 +3,7 @@
 mod character_controller;
 mod collider;
 mod joint;
+mod multiple_rapier_contexts;
 mod remove;
 mod rigid_body;
 mod writeback;
@@ -10,6 +11,7 @@ mod writeback;
 pub use character_controller::*;
 pub use collider::*;
 pub use joint::*;
+pub use multiple_rapier_contexts::*;
 pub use remove::*;
 pub use rigid_body::*;
 pub use writeback::*;
@@ -17,7 +19,7 @@ pub use writeback::*;
 use crate::dynamics::{RapierRigidBodyHandle, TransformInterpolation};
 use crate::pipeline::{CollisionEvent, ContactForceEvent};
 use crate::plugin::configuration::SimulationToRenderTime;
-use crate::plugin::{RapierConfiguration, RapierContext};
+use crate::plugin::{RapierConfiguration, RapierContext, TimestepMode};
 use crate::prelude::{BevyPhysicsHooks, BevyPhysicsHooksAdapter};
 use bevy::ecs::system::{StaticSystemParam, SystemParamItem};
 use bevy::prelude::*;
@@ -25,37 +27,44 @@ use bevy::prelude::*;
 /// System responsible for advancing the physics simulation, and updating the internal state
 /// for scene queries.
 pub fn step_simulation<Hooks>(
-    mut context: ResMut<RapierContext>,
-    config: Res<RapierConfiguration>,
+    mut context: Query<(
+        &mut RapierContext,
+        &RapierConfiguration,
+        &mut SimulationToRenderTime,
+    )>,
+    timestep_mode: Res<TimestepMode>,
     hooks: StaticSystemParam<Hooks>,
     time: Res<Time>,
-    mut sim_to_render_time: ResMut<SimulationToRenderTime>,
-    collision_events: EventWriter<CollisionEvent>,
-    contact_force_events: EventWriter<ContactForceEvent>,
-    interpolation_query: Query<(&RapierRigidBodyHandle, &mut TransformInterpolation)>,
+    mut collision_events: EventWriter<CollisionEvent>,
+    mut contact_force_events: EventWriter<ContactForceEvent>,
+    mut interpolation_query: Query<(&RapierRigidBodyHandle, &mut TransformInterpolation)>,
 ) where
     Hooks: 'static + BevyPhysicsHooks,
     for<'w, 's> SystemParamItem<'w, 's, Hooks>: BevyPhysicsHooks,
 {
-    let context = &mut *context;
     let hooks_adapter = BevyPhysicsHooksAdapter::new(hooks.into_inner());
 
-    if config.physics_pipeline_active {
-        context.step_simulation(
-            config.gravity,
-            config.timestep_mode,
-            Some((collision_events, contact_force_events)),
-            &hooks_adapter,
-            &time,
-            &mut sim_to_render_time,
-            Some(interpolation_query),
-        );
-    } else {
-        context.propagate_modified_body_positions_to_colliders();
-    }
+    for (mut context, config, mut sim_to_render_time) in context.iter_mut() {
+        let context = &mut *context;
+
+        if config.physics_pipeline_active {
+            context.step_simulation(
+                config.gravity,
+                *timestep_mode,
+                Some((&collision_events, &contact_force_events)),
+                &hooks_adapter,
+                &time,
+                &mut sim_to_render_time,
+                Some(&mut interpolation_query),
+            );
+        } else {
+            context.propagate_modified_body_positions_to_colliders();
+        }
 
-    if config.query_pipeline_active {
-        context.update_query_pipeline();
+        if config.query_pipeline_active {
+            context.update_query_pipeline();
+        }
+        context.send_bevy_events(&mut collision_events, &mut contact_force_events);
     }
 }
 
@@ -211,8 +220,9 @@ pub mod tests {
 
             app.update();
 
-            let child_transform = app.world().entity(child).get::<GlobalTransform>().unwrap();
-            let context = app.world().resource::<RapierContext>();
+            let world = app.world_mut();
+            let context = world.query::<&RapierContext>().iter(&world).next().unwrap();
+            let child_transform = world.entity(child).get::<GlobalTransform>().unwrap();
             let child_handle = context.entity2body[&child];
             let child_body = context.bodies.get(child_handle).unwrap();
             let body_transform = utils::iso_to_transform(child_body.position());
@@ -274,7 +284,8 @@ pub mod tests {
                 .get::<GlobalTransform>()
                 .unwrap()
                 .compute_transform();
-            let context = app.world().resource::<RapierContext>();
+            let world = app.world_mut();
+            let context = world.query::<&RapierContext>().iter(&world).next().unwrap();
             let parent_handle = context.entity2body[&parent];
             let parent_body = context.bodies.get(parent_handle).unwrap();
             let child_collider_handle = parent_body.colliders()[0];
diff --git a/src/plugin/systems/multiple_rapier_contexts.rs b/src/plugin/systems/multiple_rapier_contexts.rs
new file mode 100644
index 00000000..062cf688
--- /dev/null
+++ b/src/plugin/systems/multiple_rapier_contexts.rs
@@ -0,0 +1,223 @@
+//! systems to support multiple worlds, and changes between them.
+
+use crate::dynamics::{
+    RapierImpulseJointHandle, RapierMultibodyJointHandle, RapierRigidBodyHandle,
+};
+use crate::geometry::RapierColliderHandle;
+use crate::plugin::{RapierContext, RapierContextEntityLink};
+use bevy::prelude::*;
+
+/// If an entity is turned into the child of something with a physics context link,
+/// the child should become a part of that physics context
+///
+/// If this fails to happen, weirdness will ensue.
+pub fn on_add_entity_with_parent(
+    q_add_entity_without_parent: Query<
+        (Entity, &Parent),
+        (
+            With<RapierContextEntityLink>,
+            Or<(Changed<RapierContextEntityLink>, Changed<Parent>)>,
+        ),
+    >,
+    q_parent: Query<&Parent>,
+    q_physics_world: Query<&RapierContextEntityLink>,
+    mut commands: Commands,
+) {
+    for (ent, parent) in &q_add_entity_without_parent {
+        let mut parent = Some(parent.get());
+        while let Some(parent_entity) = parent {
+            if let Ok(pw) = q_physics_world.get(parent_entity) {
+                // Change rapier context link only if the existing link isn't the correct one.
+                if q_physics_world.get(ent).map(|x| x != pw).unwrap_or(true) {
+                    remove_old_physics(ent, &mut commands);
+                    commands.entity(ent).insert(*pw);
+                }
+                break;
+            }
+            parent = q_parent.get(parent_entity).ok().map(|x| x.get());
+        }
+    }
+}
+
+/// Flags the entity to have its old physics removed
+fn remove_old_physics(entity: Entity, commands: &mut Commands) {
+    commands
+        .entity(entity)
+        .remove::<RapierColliderHandle>()
+        .remove::<RapierRigidBodyHandle>()
+        .remove::<RapierMultibodyJointHandle>()
+        .remove::<RapierImpulseJointHandle>();
+}
+
+/// Flags the entity to have its physics updated to reflect new world
+///
+/// Also recursively bubbles down world changes to children & flags them to apply any needed physics changes
+pub fn on_change_world(
+    q_changed_worlds: Query<
+        (Entity, Ref<RapierContextEntityLink>),
+        Changed<RapierContextEntityLink>,
+    >,
+    q_children: Query<&Children>,
+    q_physics_world: Query<&RapierContextEntityLink>,
+    q_context: Query<&RapierContext>,
+    mut commands: Commands,
+) {
+    for (entity, new_physics_world) in &q_changed_worlds {
+        let context = q_context.get(new_physics_world.0);
+        // Ensure the world actually changed before removing them from the world
+        if !context
+            .map(|x| {
+                // They are already apart of this world if any of these are true
+                x.entity2collider.contains_key(&entity)
+                    || x.entity2body.contains_key(&entity)
+                    || x.entity2impulse_joint.contains_key(&entity)
+                    || x.entity2multibody_joint.contains_key(&entity)
+            })
+            .unwrap_or(false)
+        {
+            remove_old_physics(dbg!(entity), &mut commands);
+            bubble_down_world_change(
+                &mut commands,
+                entity,
+                &q_children,
+                *new_physics_world,
+                &q_physics_world,
+            );
+        }
+    }
+}
+
+fn bubble_down_world_change(
+    commands: &mut Commands,
+    entity: Entity,
+    q_children: &Query<&Children>,
+    new_physics_world: RapierContextEntityLink,
+    q_physics_world: &Query<&RapierContextEntityLink>,
+) {
+    let Ok(children) = q_children.get(entity) else {
+        return;
+    };
+
+    children.iter().for_each(|&child| {
+        if q_physics_world
+            .get(child)
+            .map(|x| *x == new_physics_world)
+            .unwrap_or(false)
+        {
+            return;
+        }
+
+        remove_old_physics(child, commands);
+        commands.entity(child).insert(new_physics_world);
+
+        bubble_down_world_change(
+            commands,
+            child,
+            q_children,
+            new_physics_world,
+            q_physics_world,
+        );
+    });
+}
+
+#[cfg(test)]
+mod test {
+    use crate::plugin::systems::tests::HeadlessRenderPlugin;
+    use crate::plugin::{
+        NoUserData, PhysicsSet, RapierContext, RapierContextEntityLink, RapierPhysicsPlugin,
+    };
+    use crate::prelude::{ActiveEvents, Collider, ContactForceEventThreshold, RigidBody, Sensor};
+    use bevy::prelude::*;
+    use bevy::time::{TimePlugin, TimeUpdateStrategy};
+    use rapier::math::Real;
+
+    #[test]
+    pub fn multi_world_hierarchy_update() {
+        let mut app = App::new();
+        app.add_plugins((
+            HeadlessRenderPlugin,
+            TransformPlugin,
+            TimePlugin,
+            RapierPhysicsPlugin::<NoUserData>::default(),
+        ))
+        .add_systems(
+            PostUpdate,
+            setup_physics
+                .run_if(run_once())
+                .before(PhysicsSet::SyncBackend),
+        );
+        // Simulates 60 updates per seconds
+        app.insert_resource(TimeUpdateStrategy::ManualDuration(
+            std::time::Duration::from_secs_f32(1f32 / 60f32),
+        ));
+        app.update();
+        // Verify all rapier entities have a `RapierContextEntityLink`.
+        let world = app.world_mut();
+        let mut query = world.query_filtered::<Entity, With<Marker<'R'>>>();
+        for entity in query.iter(&world) {
+            world
+                .get::<RapierContextEntityLink>(entity)
+                .unwrap_or_else(|| panic!("no link to rapier context entity from {entity}."));
+        }
+        // Verify link is correctly updated for children.
+        let new_rapier_context = world.spawn(RapierContext::default()).id();
+        // FIXME: We need to wait 1 frame when creating a world.
+        // Ideally we should be able to order the systems so that we don't have to wait.
+        app.update();
+        let mut world = app.world_mut();
+        let mut query = world.query_filtered::<&mut RapierContextEntityLink, With<Marker<'P'>>>();
+        let mut link_parent = query.get_single_mut(&mut world).unwrap();
+        link_parent.0 = new_rapier_context;
+        app.update();
+        let mut world = app.world_mut();
+        let mut query = world.query_filtered::<&RapierContextEntityLink, With<Marker<'C'>>>();
+        let link_child = query.get_single_mut(&mut world).unwrap();
+        assert_eq!(link_child.0, new_rapier_context);
+        return;
+
+        #[derive(Component)]
+        pub struct Marker<const MARKER: char>;
+
+        #[cfg(feature = "dim3")]
+        fn cuboid(hx: Real, hy: Real, hz: Real) -> Collider {
+            Collider::cuboid(hx, hy, hz)
+        }
+        #[cfg(feature = "dim2")]
+        fn cuboid(hx: Real, hy: Real, _hz: Real) -> Collider {
+            Collider::cuboid(hx, hy)
+        }
+        pub fn setup_physics(mut commands: Commands) {
+            commands.spawn((
+                TransformBundle::from(Transform::from_xyz(0.0, -1.2, 0.0)),
+                cuboid(4.0, 1.0, 1.0),
+                Marker::<'R'>,
+            ));
+
+            commands.spawn((
+                TransformBundle::from(Transform::from_xyz(0.0, 5.0, 0.0)),
+                cuboid(4.0, 1.5, 1.0),
+                Sensor,
+                Marker::<'R'>,
+            ));
+
+            commands
+                .spawn((
+                    TransformBundle::from(Transform::from_xyz(0.0, 13.0, 0.0)),
+                    RigidBody::Dynamic,
+                    cuboid(0.5, 0.5, 0.5),
+                    ActiveEvents::COLLISION_EVENTS,
+                    ContactForceEventThreshold(30.0),
+                    Marker::<'P'>,
+                    Marker::<'R'>,
+                ))
+                .with_children(|child_builder| {
+                    child_builder.spawn((
+                        TransformBundle::from(Transform::from_xyz(0.0, -1.2, 0.0)),
+                        cuboid(4.0, 1.0, 1.0),
+                        Marker::<'C'>,
+                        Marker::<'R'>,
+                    ));
+                });
+        }
+    }
+}
diff --git a/src/plugin/systems/remove.rs b/src/plugin/systems/remove.rs
index 69933986..0342a1b9 100644
--- a/src/plugin/systems/remove.rs
+++ b/src/plugin/systems/remove.rs
@@ -7,6 +7,7 @@ use crate::dynamics::RigidBody;
 use crate::geometry::Collider;
 use crate::geometry::ColliderDisabled;
 use crate::geometry::RapierColliderHandle;
+use crate::plugin::context::systemparams::WriteRapierContext;
 use crate::plugin::RapierContext;
 use crate::prelude::MassModifiedEvent;
 use crate::prelude::RigidBodyDisabled;
@@ -18,7 +19,7 @@ use bevy::prelude::*;
 /// despawn).
 pub fn sync_removals(
     mut commands: Commands,
-    mut context: ResMut<RapierContext>,
+    mut context_writer: WriteRapierContext,
     mut removed_bodies: RemovedComponents<RapierRigidBodyHandle>,
     mut removed_colliders: RemovedComponents<RapierColliderHandle>,
     mut removed_impulse_joints: RemovedComponents<RapierImpulseJointHandle>,
@@ -40,24 +41,30 @@ pub fn sync_removals(
     /*
      * Rigid-bodies removal detection.
      */
-    let context = &mut *context;
     for entity in removed_bodies.read() {
-        if let Some(handle) = context.entity2body.remove(&entity) {
-            let _ = context.last_body_transform_set.remove(&handle);
-            context.bodies.remove(
-                handle,
-                &mut context.islands,
-                &mut context.colliders,
-                &mut context.impulse_joints,
-                &mut context.multibody_joints,
-                false,
-            );
-        }
+        let Some((mut context, handle)) = find_context(&mut context_writer, |context| {
+            context.entity2body.remove(&entity)
+        }) else {
+            continue;
+        };
+        let context = &mut *context;
+
+        let _ = context.last_body_transform_set.remove(&handle);
+        context.bodies.remove(
+            handle,
+            &mut context.islands,
+            &mut context.colliders,
+            &mut context.impulse_joints,
+            &mut context.multibody_joints,
+            false,
+        );
     }
 
-    let context = &mut *context;
     for entity in orphan_bodies.iter() {
-        if let Some(handle) = context.entity2body.remove(&entity) {
+        if let Some((mut context, handle)) = find_context(&mut context_writer, |context| {
+            context.entity2body.remove(&entity)
+        }) {
+            let context = &mut *context;
             let _ = context.last_body_transform_set.remove(&handle);
             context.bodies.remove(
                 handle,
@@ -75,24 +82,31 @@ pub fn sync_removals(
      * Collider removal detection.
      */
     for entity in removed_colliders.read() {
+        let Some((mut context, handle)) = find_context(&mut context_writer, |context| {
+            context.entity2collider.remove(&entity)
+        }) else {
+            continue;
+        };
+        let context = &mut *context;
         if let Some(parent) = context.collider_parent(entity) {
             mass_modified.send(parent.into());
         }
 
-        if let Some(handle) = context.entity2collider.remove(&entity) {
-            context
-                .colliders
-                .remove(handle, &mut context.islands, &mut context.bodies, true);
-            context.deleted_colliders.insert(handle, entity);
-        }
+        context
+            .colliders
+            .remove(handle, &mut context.islands, &mut context.bodies, true);
+        context.deleted_colliders.insert(handle, entity);
     }
 
     for entity in orphan_colliders.iter() {
-        if let Some(parent) = context.collider_parent(entity) {
-            mass_modified.send(parent.into());
-        }
+        if let Some((mut context, handle)) = find_context(&mut context_writer, |context| {
+            context.entity2collider.remove(&entity)
+        }) {
+            let context = &mut *context;
+            if let Some(parent) = context.collider_parent(entity) {
+                mass_modified.send(parent.into());
+            }
 
-        if let Some(handle) = context.entity2collider.remove(&entity) {
             context
                 .colliders
                 .remove(handle, &mut context.islands, &mut context.bodies, true);
@@ -105,13 +119,20 @@ pub fn sync_removals(
      * Impulse joint removal detection.
      */
     for entity in removed_impulse_joints.read() {
-        if let Some(handle) = context.entity2impulse_joint.remove(&entity) {
-            context.impulse_joints.remove(handle, true);
-        }
+        let Some((mut context, handle)) = find_context(&mut context_writer, |context| {
+            context.entity2impulse_joint.remove(&entity)
+        }) else {
+            continue;
+        };
+        let context = &mut *context;
+        context.impulse_joints.remove(handle, true);
     }
 
     for entity in orphan_impulse_joints.iter() {
-        if let Some(handle) = context.entity2impulse_joint.remove(&entity) {
+        if let Some((mut context, handle)) = find_context(&mut context_writer, |context| {
+            context.entity2impulse_joint.remove(&entity)
+        }) {
+            let context = &mut *context;
             context.impulse_joints.remove(handle, true);
         }
         commands.entity(entity).remove::<RapierImpulseJointHandle>();
@@ -121,13 +142,20 @@ pub fn sync_removals(
      * Multibody joint removal detection.
      */
     for entity in removed_multibody_joints.read() {
-        if let Some(handle) = context.entity2multibody_joint.remove(&entity) {
-            context.multibody_joints.remove(handle, true);
-        }
+        let Some((mut context, handle)) = find_context(&mut context_writer, |context| {
+            context.entity2multibody_joint.remove(&entity)
+        }) else {
+            continue;
+        };
+        let context = &mut *context;
+        context.multibody_joints.remove(handle, true);
     }
 
     for entity in orphan_multibody_joints.iter() {
-        if let Some(handle) = context.entity2multibody_joint.remove(&entity) {
+        if let Some((mut context, handle)) = find_context(&mut context_writer, |context| {
+            context.entity2multibody_joint.remove(&entity)
+        }) {
+            let context = &mut *context;
             context.multibody_joints.remove(handle, true);
         }
         commands
@@ -139,24 +167,30 @@ pub fn sync_removals(
      * Marker components removal detection.
      */
     for entity in removed_sensors.read() {
-        if let Some(handle) = context.entity2collider.get(&entity) {
-            if let Some(co) = context.colliders.get_mut(*handle) {
+        if let Some((mut context, handle)) = find_context(&mut context_writer, |context| {
+            context.entity2collider.get(&entity).copied()
+        }) {
+            if let Some(co) = context.colliders.get_mut(handle) {
                 co.set_sensor(false);
             }
         }
     }
 
     for entity in removed_colliders_disabled.read() {
-        if let Some(handle) = context.entity2collider.get(&entity) {
-            if let Some(co) = context.colliders.get_mut(*handle) {
+        if let Some((mut context, handle)) = find_context(&mut context_writer, |context| {
+            context.entity2collider.get(&entity).copied()
+        }) {
+            if let Some(co) = context.colliders.get_mut(handle) {
                 co.set_enabled(true);
             }
         }
     }
 
     for entity in removed_rigid_body_disabled.read() {
-        if let Some(handle) = context.entity2body.get(&entity) {
-            if let Some(rb) = context.bodies.get_mut(*handle) {
+        if let Some((mut context, handle)) = find_context(&mut context_writer, |context| {
+            context.entity2body.get(&entity).copied()
+        }) {
+            if let Some(rb) = context.bodies.get_mut(handle) {
                 rb.set_enabled(true);
             }
         }
@@ -164,3 +198,13 @@ pub fn sync_removals(
 
     // TODO: what about removing forces?
 }
+
+fn find_context<'a, T>(
+    context_writer: &'a mut WriteRapierContext,
+    item_finder: impl Fn(&mut RapierContext) -> Option<T>,
+) -> Option<(Mut<'a, RapierContext>, T)> {
+    context_writer
+        .rapier_context
+        .iter_mut()
+        .find_map(|mut context| item_finder(&mut context).map(|handle| (context, handle)))
+}
diff --git a/src/plugin/systems/rigid_body.rs b/src/plugin/systems/rigid_body.rs
index ed7cb466..67a91886 100644
--- a/src/plugin/systems/rigid_body.rs
+++ b/src/plugin/systems/rigid_body.rs
@@ -1,4 +1,5 @@
 use crate::dynamics::RapierRigidBodyHandle;
+use crate::plugin::context::RapierContextEntityLink;
 use crate::plugin::{configuration::TimestepMode, RapierConfiguration, RapierContext};
 use crate::{dynamics::RigidBody, plugin::configuration::SimulationToRenderTime};
 use crate::{prelude::*, utils};
@@ -9,6 +10,7 @@ use std::collections::HashMap;
 /// Components that will be updated after a physics step.
 pub type RigidBodyWritebackComponents<'a> = (
     &'a RapierRigidBodyHandle,
+    &'a RapierContextEntityLink,
     Option<&'a Parent>,
     Option<&'a mut Transform>,
     Option<&'a mut TransformInterpolation>,
@@ -18,7 +20,7 @@ pub type RigidBodyWritebackComponents<'a> = (
 
 /// Components related to rigid-bodies.
 pub type RigidBodyComponents<'a> = (
-    Entity,
+    (Entity, Option<&'a RapierContextEntityLink>),
     &'a RigidBody,
     Option<&'a GlobalTransform>,
     Option<&'a Velocity>,
@@ -37,50 +39,107 @@ pub type RigidBodyComponents<'a> = (
 
 /// System responsible for applying changes the user made to a rigid-body-related component.
 pub fn apply_rigid_body_user_changes(
-    mut context: ResMut<RapierContext>,
-    config: Res<RapierConfiguration>,
-    changed_rb_types: Query<(&RapierRigidBodyHandle, &RigidBody), Changed<RigidBody>>,
+    mut context: WriteRapierContext,
+    config: Query<&RapierConfiguration>,
+    changed_rb_types: Query<
+        (&RapierRigidBodyHandle, &RapierContextEntityLink, &RigidBody),
+        Changed<RigidBody>,
+    >,
     mut changed_transforms: Query<
         (
             &RapierRigidBodyHandle,
+            &RapierContextEntityLink,
             &GlobalTransform,
             Option<&mut TransformInterpolation>,
         ),
         Changed<GlobalTransform>,
     >,
-    changed_velocities: Query<(&RapierRigidBodyHandle, &Velocity), Changed<Velocity>>,
+    changed_velocities: Query<
+        (&RapierRigidBodyHandle, &RapierContextEntityLink, &Velocity),
+        Changed<Velocity>,
+    >,
     changed_additional_mass_props: Query<
-        (Entity, &RapierRigidBodyHandle, &AdditionalMassProperties),
+        (
+            Entity,
+            &RapierContextEntityLink,
+            &RapierRigidBodyHandle,
+            &AdditionalMassProperties,
+        ),
         Changed<AdditionalMassProperties>,
     >,
-    changed_locked_axes: Query<(&RapierRigidBodyHandle, &LockedAxes), Changed<LockedAxes>>,
-    changed_forces: Query<(&RapierRigidBodyHandle, &ExternalForce), Changed<ExternalForce>>,
+    changed_locked_axes: Query<
+        (
+            &RapierRigidBodyHandle,
+            &RapierContextEntityLink,
+            &LockedAxes,
+        ),
+        Changed<LockedAxes>,
+    >,
+    changed_forces: Query<
+        (
+            &RapierRigidBodyHandle,
+            &RapierContextEntityLink,
+            &ExternalForce,
+        ),
+        Changed<ExternalForce>,
+    >,
     mut changed_impulses: Query<
-        (&RapierRigidBodyHandle, &mut ExternalImpulse),
+        (
+            &RapierRigidBodyHandle,
+            &RapierContextEntityLink,
+            &mut ExternalImpulse,
+        ),
         Changed<ExternalImpulse>,
     >,
-    changed_gravity_scale: Query<(&RapierRigidBodyHandle, &GravityScale), Changed<GravityScale>>,
+    changed_gravity_scale: Query<
+        (
+            &RapierRigidBodyHandle,
+            &RapierContextEntityLink,
+            &GravityScale,
+        ),
+        Changed<GravityScale>,
+    >,
     (changed_ccd, changed_soft_ccd): (
-        Query<(&RapierRigidBodyHandle, &Ccd), Changed<Ccd>>,
-        Query<(&RapierRigidBodyHandle, &SoftCcd), Changed<SoftCcd>>,
+        Query<(&RapierRigidBodyHandle, &RapierContextEntityLink, &Ccd), Changed<Ccd>>,
+        Query<(&RapierRigidBodyHandle, &RapierContextEntityLink, &SoftCcd), Changed<SoftCcd>>,
     ),
-    changed_dominance: Query<(&RapierRigidBodyHandle, &Dominance), Changed<Dominance>>,
-    changed_sleeping: Query<(&RapierRigidBodyHandle, &Sleeping), Changed<Sleeping>>,
-    changed_damping: Query<(&RapierRigidBodyHandle, &Damping), Changed<Damping>>,
+    changed_dominance: Query<
+        (&RapierRigidBodyHandle, &RapierContextEntityLink, &Dominance),
+        Changed<Dominance>,
+    >,
+    changed_sleeping: Query<
+        (&RapierRigidBodyHandle, &RapierContextEntityLink, &Sleeping),
+        Changed<Sleeping>,
+    >,
+    changed_damping: Query<
+        (&RapierRigidBodyHandle, &RapierContextEntityLink, &Damping),
+        Changed<Damping>,
+    >,
     (changed_disabled, changed_additional_solver_iterations): (
-        Query<(&RapierRigidBodyHandle, &RigidBodyDisabled), Changed<RigidBodyDisabled>>,
         Query<
-            (&RapierRigidBodyHandle, &AdditionalSolverIterations),
+            (
+                &RapierRigidBodyHandle,
+                &RapierContextEntityLink,
+                &RigidBodyDisabled,
+            ),
+            Changed<RigidBodyDisabled>,
+        >,
+        Query<
+            (
+                &RapierRigidBodyHandle,
+                &RapierContextEntityLink,
+                &AdditionalSolverIterations,
+            ),
             Changed<AdditionalSolverIterations>,
         >,
     ),
     mut mass_modified: EventWriter<MassModifiedEvent>,
 ) {
-    let context = &mut *context;
-
     // Deal with sleeping first, because other changes may then wake-up the
     // rigid-body again.
-    for (handle, sleeping) in changed_sleeping.iter() {
+    for (handle, link, sleeping) in changed_sleeping.iter() {
+        let context = context.context(link).into_inner();
+
         if let Some(rb) = context.bodies.get_mut(handle.0) {
             let activation = rb.activation_mut();
             activation.normalized_linear_threshold = sleeping.normalized_linear_threshold;
@@ -100,7 +159,8 @@ pub fn apply_rigid_body_user_changes(
     //       Similarly, if the rigid-body was kinematic position-based before and
     //       changed to anything else, a transform change would modify the next
     //       position instead of the current one.
-    for (handle, rb_type) in changed_rb_types.iter() {
+    for (handle, link, rb_type) in changed_rb_types.iter() {
+        let context = context.context(link).into_inner();
         if let Some(rb) = context.bodies.get_mut(handle.0) {
             rb.set_body_type((*rb_type).into(), true);
         }
@@ -112,6 +172,7 @@ pub fn apply_rigid_body_user_changes(
     // system.
     let transform_changed_fn =
         |handle: &RigidBodyHandle,
+         config: &RapierConfiguration,
          transform: &GlobalTransform,
          last_transform_set: &HashMap<RigidBodyHandle, GlobalTransform>| {
             if config.force_update_from_transform_changes {
@@ -123,7 +184,11 @@ pub fn apply_rigid_body_user_changes(
             }
         };
 
-    for (handle, global_transform, mut interpolation) in changed_transforms.iter_mut() {
+    for (handle, link, global_transform, mut interpolation) in changed_transforms.iter_mut() {
+        let context = context.context(link).into_inner();
+        let config = config
+            .get(link.0)
+            .expect("Could not get `RapierConfiguration`");
         // Use an Option<bool> to avoid running the check twice.
         let mut transform_changed = None;
 
@@ -131,6 +196,7 @@ pub fn apply_rigid_body_user_changes(
             transform_changed = transform_changed.or_else(|| {
                 Some(transform_changed_fn(
                     &handle.0,
+                    config,
                     global_transform,
                     &context.last_body_transform_set,
                 ))
@@ -143,11 +209,12 @@ pub fn apply_rigid_body_user_changes(
                 interpolation.end = None;
             }
         }
-
+        // TODO: avoid to run multiple times the mutable deref ?
         if let Some(rb) = context.bodies.get_mut(handle.0) {
             transform_changed = transform_changed.or_else(|| {
                 Some(transform_changed_fn(
                     &handle.0,
+                    config,
                     global_transform,
                     &context.last_body_transform_set,
                 ))
@@ -179,7 +246,8 @@ pub fn apply_rigid_body_user_changes(
         }
     }
 
-    for (handle, velocity) in changed_velocities.iter() {
+    for (handle, link, velocity) in changed_velocities.iter() {
+        let context = context.context(link).into_inner();
         if let Some(rb) = context.bodies.get_mut(handle.0) {
             rb.set_linvel(velocity.linvel.into(), true);
             #[allow(clippy::useless_conversion)] // Need to convert if dim3 enabled
@@ -187,7 +255,8 @@ pub fn apply_rigid_body_user_changes(
         }
     }
 
-    for (entity, handle, mprops) in changed_additional_mass_props.iter() {
+    for (entity, link, handle, mprops) in changed_additional_mass_props.iter() {
+        let context = context.context(link).into_inner();
         if let Some(rb) = context.bodies.get_mut(handle.0) {
             match mprops {
                 AdditionalMassProperties::MassProperties(mprops) => {
@@ -202,19 +271,22 @@ pub fn apply_rigid_body_user_changes(
         }
     }
 
-    for (handle, additional_solver_iters) in changed_additional_solver_iterations.iter() {
+    for (handle, link, additional_solver_iters) in changed_additional_solver_iterations.iter() {
+        let context = context.context(link).into_inner();
         if let Some(rb) = context.bodies.get_mut(handle.0) {
             rb.set_additional_solver_iterations(additional_solver_iters.0);
         }
     }
 
-    for (handle, locked_axes) in changed_locked_axes.iter() {
+    for (handle, link, locked_axes) in changed_locked_axes.iter() {
+        let context = context.context(link).into_inner();
         if let Some(rb) = context.bodies.get_mut(handle.0) {
             rb.set_locked_axes((*locked_axes).into(), true);
         }
     }
 
-    for (handle, forces) in changed_forces.iter() {
+    for (handle, link, forces) in changed_forces.iter() {
+        let context = context.context(link).into_inner();
         if let Some(rb) = context.bodies.get_mut(handle.0) {
             rb.reset_forces(true);
             rb.reset_torques(true);
@@ -224,7 +296,8 @@ pub fn apply_rigid_body_user_changes(
         }
     }
 
-    for (handle, mut impulses) in changed_impulses.iter_mut() {
+    for (handle, link, mut impulses) in changed_impulses.iter_mut() {
+        let context = context.context(link).into_inner();
         if let Some(rb) = context.bodies.get_mut(handle.0) {
             rb.apply_impulse(impulses.impulse.into(), true);
             #[allow(clippy::useless_conversion)] // Need to convert if dim3 enabled
@@ -233,38 +306,44 @@ pub fn apply_rigid_body_user_changes(
         }
     }
 
-    for (handle, gravity_scale) in changed_gravity_scale.iter() {
+    for (handle, link, gravity_scale) in changed_gravity_scale.iter() {
+        let context = context.context(link).into_inner();
         if let Some(rb) = context.bodies.get_mut(handle.0) {
             rb.set_gravity_scale(gravity_scale.0, true);
         }
     }
 
-    for (handle, ccd) in changed_ccd.iter() {
+    for (handle, link, ccd) in changed_ccd.iter() {
+        let context = context.context(link).into_inner();
         if let Some(rb) = context.bodies.get_mut(handle.0) {
             rb.enable_ccd(ccd.enabled);
         }
     }
 
-    for (handle, soft_ccd) in changed_soft_ccd.iter() {
+    for (handle, link, soft_ccd) in changed_soft_ccd.iter() {
+        let context = context.context(link).into_inner();
         if let Some(rb) = context.bodies.get_mut(handle.0) {
             rb.set_soft_ccd_prediction(soft_ccd.prediction);
         }
     }
 
-    for (handle, dominance) in changed_dominance.iter() {
+    for (handle, link, dominance) in changed_dominance.iter() {
+        let context = context.context(link).into_inner();
         if let Some(rb) = context.bodies.get_mut(handle.0) {
             rb.set_dominance_group(dominance.groups);
         }
     }
 
-    for (handle, damping) in changed_damping.iter() {
+    for (handle, link, damping) in changed_damping.iter() {
+        let context = context.context(link).into_inner();
         if let Some(rb) = context.bodies.get_mut(handle.0) {
             rb.set_linear_damping(damping.linear_damping);
             rb.set_angular_damping(damping.angular_damping);
         }
     }
 
-    for (handle, _) in changed_disabled.iter() {
+    for (handle, link, _) in changed_disabled.iter() {
+        let context = context.context(link).into_inner();
         if let Some(co) = context.bodies.get_mut(handle.0) {
             co.set_enabled(false);
         }
@@ -274,148 +353,154 @@ pub fn apply_rigid_body_user_changes(
 /// System responsible for writing the result of the last simulation step into our `bevy_rapier`
 /// components and the [`GlobalTransform`] component.
 pub fn writeback_rigid_bodies(
-    mut context: ResMut<RapierContext>,
-    config: Res<RapierConfiguration>,
-    sim_to_render_time: Res<SimulationToRenderTime>,
+    mut context: WriteRapierContext,
+    timestep_mode: Res<TimestepMode>,
+    config: Query<&RapierConfiguration>,
+    sim_to_render_time: Query<&SimulationToRenderTime>,
     global_transforms: Query<&GlobalTransform>,
     mut writeback: Query<
         RigidBodyWritebackComponents,
         (With<RigidBody>, Without<RigidBodyDisabled>),
     >,
 ) {
-    let context = &mut *context;
+    for (handle, link, parent, transform, mut interpolation, mut velocity, mut sleeping) in
+        writeback.iter_mut()
+    {
+        let config = config
+            .get(link.0)
+            .expect("Could not get `RapierConfiguration`");
+        if !config.physics_pipeline_active {
+            continue;
+        }
+        let handle = handle.0;
+
+        let context = context.context(link).into_inner();
+        let sim_to_render_time = sim_to_render_time
+            .get(link.0)
+            .expect("Could not get `SimulationToRenderTime`");
+        // TODO: do this the other way round: iterate through Rapier’s RigidBodySet on the active bodies,
+        // and update the components accordingly. That way, we don’t have to iterate through the entities that weren’t changed
+        // by physics (for example because they are sleeping).
+        if let Some(rb) = context.bodies.get(handle) {
+            let mut interpolated_pos = utils::iso_to_transform(rb.position());
+
+            if let TimestepMode::Interpolated { dt, .. } = *timestep_mode {
+                if let Some(interpolation) = interpolation.as_deref_mut() {
+                    if interpolation.end.is_none() {
+                        interpolation.end = Some(*rb.position());
+                    }
 
-    if config.physics_pipeline_active {
-        for (handle, parent, transform, mut interpolation, mut velocity, mut sleeping) in
-            writeback.iter_mut()
-        {
-            let handle = handle.0;
-
-            // TODO: do this the other way round: iterate through Rapier’s RigidBodySet on the active bodies,
-            // and update the components accordingly. That way, we don’t have to iterate through the entities that weren’t changed
-            // by physics (for example because they are sleeping).
-            if let Some(rb) = context.bodies.get(handle) {
-                let mut interpolated_pos = utils::iso_to_transform(rb.position());
-
-                if let TimestepMode::Interpolated { dt, .. } = config.timestep_mode {
-                    if let Some(interpolation) = interpolation.as_deref_mut() {
-                        if interpolation.end.is_none() {
-                            interpolation.end = Some(*rb.position());
-                        }
-
-                        if let Some(interpolated) =
-                            interpolation.lerp_slerp((dt + sim_to_render_time.diff) / dt)
-                        {
-                            interpolated_pos = utils::iso_to_transform(&interpolated);
-                        }
+                    if let Some(interpolated) =
+                        interpolation.lerp_slerp((dt + sim_to_render_time.diff) / dt)
+                    {
+                        interpolated_pos = utils::iso_to_transform(&interpolated);
                     }
                 }
+            }
 
-                if let Some(mut transform) = transform {
-                    // NOTE: Rapier's `RigidBody` doesn't know its own scale as it is encoded
-                    //       directly within its collider, so we have to retrieve it from
-                    //       the scale of its bevy transform.
-                    interpolated_pos = interpolated_pos.with_scale(transform.scale);
-
-                    // NOTE: we query the parent’s global transform here, which is a bit
-                    //       unfortunate (performance-wise). An alternative would be to
-                    //       deduce the parent’s global transform from the current entity’s
-                    //       global transform. However, this makes it nearly impossible
-                    //       (because of rounding errors) to predict the exact next value this
-                    //       entity’s global transform will get after the next transform
-                    //       propagation, which breaks our transform modification detection
-                    //       that we do to detect if the user’s transform has to be written
-                    //       into the rigid-body.
-                    if let Some(parent_global_transform) =
-                        parent.and_then(|p| global_transforms.get(**p).ok())
+            if let Some(mut transform) = transform {
+                // NOTE: Rapier's `RigidBody` doesn't know its own scale as it is encoded
+                //       directly within its collider, so we have to retrieve it from
+                //       the scale of its bevy transform.
+                interpolated_pos = interpolated_pos.with_scale(transform.scale);
+
+                // NOTE: we query the parent’s global transform here, which is a bit
+                //       unfortunate (performance-wise). An alternative would be to
+                //       deduce the parent’s global transform from the current entity’s
+                //       global transform. However, this makes it nearly impossible
+                //       (because of rounding errors) to predict the exact next value this
+                //       entity’s global transform will get after the next transform
+                //       propagation, which breaks our transform modification detection
+                //       that we do to detect if the user’s transform has to be written
+                //       into the rigid-body.
+                if let Some(parent_global_transform) =
+                    parent.and_then(|p| global_transforms.get(**p).ok())
+                {
+                    // We need to compute the new local transform such that:
+                    // curr_parent_global_transform * new_transform = interpolated_pos
+                    // new_transform = curr_parent_global_transform.inverse() * interpolated_pos
+                    let (_, inverse_parent_rotation, inverse_parent_translation) =
+                        parent_global_transform
+                            .affine()
+                            .inverse()
+                            .to_scale_rotation_translation();
+                    let new_rotation = inverse_parent_rotation * interpolated_pos.rotation;
+
+                    #[allow(unused_mut)] // mut is needed in 2D but not in 3D.
+                    let mut new_translation = inverse_parent_rotation
+                        * interpolated_pos.translation
+                        + inverse_parent_translation;
+
+                    // In 2D, preserve the transform `z` component that may have been set by the user
+                    #[cfg(feature = "dim2")]
                     {
-                        // We need to compute the new local transform such that:
-                        // curr_parent_global_transform * new_transform = interpolated_pos
-                        // new_transform = curr_parent_global_transform.inverse() * interpolated_pos
-                        let (_, inverse_parent_rotation, inverse_parent_translation) =
-                            parent_global_transform
-                                .affine()
-                                .inverse()
-                                .to_scale_rotation_translation();
-                        let new_rotation = inverse_parent_rotation * interpolated_pos.rotation;
-
-                        #[allow(unused_mut)] // mut is needed in 2D but not in 3D.
-                        let mut new_translation = inverse_parent_rotation
-                            * interpolated_pos.translation
-                            + inverse_parent_translation;
-
-                        // In 2D, preserve the transform `z` component that may have been set by the user
-                        #[cfg(feature = "dim2")]
-                        {
-                            new_translation.z = transform.translation.z;
-                        }
-
-                        if transform.rotation != new_rotation
-                            || transform.translation != new_translation
-                        {
-                            // NOTE: we write the new value only if there was an
-                            //       actual change, in order to not trigger bevy’s
-                            //       change tracking when the values didn’t change.
-                            transform.rotation = new_rotation;
-                            transform.translation = new_translation;
-                        }
-
-                        // NOTE: we need to compute the result of the next transform propagation
-                        //       to make sure that our change detection for transforms is exact
-                        //       despite rounding errors.
-                        let new_global_transform =
-                            parent_global_transform.mul_transform(*transform);
+                        new_translation.z = transform.translation.z;
+                    }
 
-                        context
-                            .last_body_transform_set
-                            .insert(handle, new_global_transform);
-                    } else {
-                        // In 2D, preserve the transform `z` component that may have been set by the user
-                        #[cfg(feature = "dim2")]
-                        {
-                            interpolated_pos.translation.z = transform.translation.z;
-                        }
-
-                        if transform.rotation != interpolated_pos.rotation
-                            || transform.translation != interpolated_pos.translation
-                        {
-                            // NOTE: we write the new value only if there was an
-                            //       actual change, in order to not trigger bevy’s
-                            //       change tracking when the values didn’t change.
-                            transform.rotation = interpolated_pos.rotation;
-                            transform.translation = interpolated_pos.translation;
-                        }
+                    if transform.rotation != new_rotation
+                        || transform.translation != new_translation
+                    {
+                        // NOTE: we write the new value only if there was an
+                        //       actual change, in order to not trigger bevy’s
+                        //       change tracking when the values didn’t change.
+                        transform.rotation = new_rotation;
+                        transform.translation = new_translation;
+                    }
 
-                        context
-                            .last_body_transform_set
-                            .insert(handle, GlobalTransform::from(interpolated_pos));
+                    // NOTE: we need to compute the result of the next transform propagation
+                    //       to make sure that our change detection for transforms is exact
+                    //       despite rounding errors.
+                    let new_global_transform = parent_global_transform.mul_transform(*transform);
+
+                    context
+                        .last_body_transform_set
+                        .insert(handle, new_global_transform);
+                } else {
+                    // In 2D, preserve the transform `z` component that may have been set by the user
+                    #[cfg(feature = "dim2")]
+                    {
+                        interpolated_pos.translation.z = transform.translation.z;
                     }
-                }
 
-                if let Some(velocity) = &mut velocity {
-                    let new_vel = Velocity {
-                        linvel: (*rb.linvel()).into(),
-                        #[cfg(feature = "dim3")]
-                        angvel: (*rb.angvel()).into(),
-                        #[cfg(feature = "dim2")]
-                        angvel: rb.angvel(),
-                    };
-
-                    // NOTE: we write the new value only if there was an
-                    //       actual change, in order to not trigger bevy’s
-                    //       change tracking when the values didn’t change.
-                    if **velocity != new_vel {
-                        **velocity = new_vel;
+                    if transform.rotation != interpolated_pos.rotation
+                        || transform.translation != interpolated_pos.translation
+                    {
+                        // NOTE: we write the new value only if there was an
+                        //       actual change, in order to not trigger bevy’s
+                        //       change tracking when the values didn’t change.
+                        transform.rotation = interpolated_pos.rotation;
+                        transform.translation = interpolated_pos.translation;
                     }
+
+                    context
+                        .last_body_transform_set
+                        .insert(handle, GlobalTransform::from(interpolated_pos));
                 }
+            }
 
-                if let Some(sleeping) = &mut sleeping {
-                    // NOTE: we write the new value only if there was an
-                    //       actual change, in order to not trigger bevy’s
-                    //       change tracking when the values didn’t change.
-                    if sleeping.sleeping != rb.is_sleeping() {
-                        sleeping.sleeping = rb.is_sleeping();
-                    }
+            if let Some(velocity) = &mut velocity {
+                let new_vel = Velocity {
+                    linvel: (*rb.linvel()).into(),
+                    #[cfg(feature = "dim3")]
+                    angvel: (*rb.angvel()).into(),
+                    #[cfg(feature = "dim2")]
+                    angvel: rb.angvel(),
+                };
+
+                // NOTE: we write the new value only if there was an
+                //       actual change, in order to not trigger bevy’s
+                //       change tracking when the values didn’t change.
+                if **velocity != new_vel {
+                    **velocity = new_vel;
+                }
+            }
+
+            if let Some(sleeping) = &mut sleeping {
+                // NOTE: we write the new value only if there was an
+                //       actual change, in order to not trigger bevy’s
+                //       change tracking when the values didn’t change.
+                if sleeping.sleeping != rb.is_sleeping() {
+                    sleeping.sleeping = rb.is_sleeping();
                 }
             }
         }
@@ -425,11 +510,12 @@ pub fn writeback_rigid_bodies(
 /// System responsible for creating new Rapier rigid-bodies from the related `bevy_rapier` components.
 pub fn init_rigid_bodies(
     mut commands: Commands,
-    mut context: ResMut<RapierContext>,
+    default_context_access: Query<Entity, With<DefaultRapierContext>>,
+    mut context: Query<(Entity, &mut RapierContext)>,
     rigid_bodies: Query<RigidBodyComponents, Without<RapierRigidBodyHandle>>,
 ) {
     for (
-        entity,
+        (entity, entity_context_link),
         rb,
         transform,
         vel,
@@ -520,7 +606,25 @@ pub fn init_rigid_bodies(
             activation.normalized_linear_threshold = sleep.normalized_linear_threshold;
             activation.angular_threshold = sleep.angular_threshold;
         }
+        // Get rapier context from RapierContextEntityLink or insert its default value.
+        let context_entity = entity_context_link.map_or_else(
+            || {
+                let context_entity = default_context_access.get_single().ok()?;
+                commands
+                    .entity(entity)
+                    .insert(RapierContextEntityLink(context_entity));
+                Some(context_entity)
+            },
+            |link| Some(link.0),
+        );
+        let Some(context_entity) = context_entity else {
+            continue;
+        };
 
+        let Ok((_, mut context)) = context.get_mut(context_entity) else {
+            log::error!("Could not find entity {context_entity} with rapier context while initializing {entity}");
+            continue;
+        };
         let handle = context.bodies.insert(rb);
         commands
             .entity(entity)
@@ -539,14 +643,16 @@ pub fn init_rigid_bodies(
 /// mass to be available, which it was not because colliders were not created yet. As a
 /// result, we run this system after the collider creation.
 pub fn apply_initial_rigid_body_impulses(
-    mut context: ResMut<RapierContext>,
+    mut context: WriteRapierContext,
     // We can’t use RapierRigidBodyHandle yet because its creation command hasn’t been
     // executed yet.
-    mut init_impulses: Query<(Entity, &mut ExternalImpulse), Without<RapierRigidBodyHandle>>,
+    mut init_impulses: Query<
+        (Entity, &RapierContextEntityLink, &mut ExternalImpulse),
+        Without<RapierRigidBodyHandle>,
+    >,
 ) {
-    let context = &mut *context;
-
-    for (entity, mut impulse) in init_impulses.iter_mut() {
+    for (entity, link, mut impulse) in init_impulses.iter_mut() {
+        let context = context.context(link).into_inner();
         let bodies = &mut context.bodies;
         if let Some(rb) = context
             .entity2body
diff --git a/src/plugin/systems/writeback.rs b/src/plugin/systems/writeback.rs
index d9c7ec8b..f4eead69 100644
--- a/src/plugin/systems/writeback.rs
+++ b/src/plugin/systems/writeback.rs
@@ -1,22 +1,30 @@
 use crate::dynamics::MassProperties;
 use crate::dynamics::ReadMassProperties;
+use crate::plugin::context::RapierContextEntityLink;
 use crate::plugin::RapierConfiguration;
-use crate::plugin::RapierContext;
+use crate::plugin::RapierContextAccess;
 use crate::prelude::MassModifiedEvent;
 use bevy::prelude::*;
 
 /// System responsible for writing updated mass properties back into the [`ReadMassProperties`] component.
 pub fn writeback_mass_properties(
-    mut context: ResMut<RapierContext>,
-    config: Res<RapierConfiguration>,
+    link: Query<&RapierContextEntityLink>,
+    context: RapierContextAccess,
+    config: Query<&RapierConfiguration>,
 
     mut mass_props: Query<&mut ReadMassProperties>,
     mut mass_modified: EventReader<MassModifiedEvent>,
 ) {
-    let context = &mut *context;
+    for entity in mass_modified.read() {
+        let link = link
+            .get(entity.0)
+            .expect("Could not find `RapierContextEntityLink`");
+        let config = config
+            .get(link.0)
+            .expect("Could not find `RapierConfiguration`");
+        if config.physics_pipeline_active {
+            let context = context.context(link);
 
-    if config.physics_pipeline_active {
-        for entity in mass_modified.read() {
             if let Some(handle) = context.entity2body.get(entity).copied() {
                 if let Some(rb) = context.bodies.get(handle) {
                     if let Ok(mut mass_props) = mass_props.get_mut(**entity) {
diff --git a/src/render/mod.rs b/src/render/mod.rs
index e55761ab..abdd20b4 100644
--- a/src/render/mod.rs
+++ b/src/render/mod.rs
@@ -14,7 +14,7 @@ use crate::prelude::Collider;
 /// Insert this component alongside the [`Collider`] component to
 /// force to a specific value the color used to render the
 /// collider.
-#[derive(Copy, Clone, Component, PartialEq, Debug)]
+#[derive(Copy, Clone, Component, PartialEq, Debug, Reflect)]
 pub struct ColliderDebugColor(pub Hsla);
 
 /// Overrides the global [`DebugRenderContext`] for a single collider.
@@ -120,15 +120,17 @@ impl Plugin for RapierDebugRenderPlugin {
     }
 }
 
-struct BevyLinesRenderBackend<'world, 'state, 'a, 'b> {
-    custom_colors: Query<'world, 'state, &'a ColliderDebugColor>,
+struct BevyLinesRenderBackend<'world, 'state, 'world2, 'state2, 'a, 'b, 'c, 'v, 'p> {
+    custom_colors: &'c Query<'world, 'state, &'a ColliderDebugColor>,
     default_collider_debug: ColliderDebug,
-    override_visibility: Query<'world, 'state, &'a ColliderDebug>,
+    override_visibility: &'v Query<'world, 'state, &'a ColliderDebug>,
     context: &'b RapierContext,
-    gizmos: Gizmos<'world, 'state>,
+    gizmos: &'p mut Gizmos<'world2, 'state2>,
 }
 
-impl<'world, 'state, 'a, 'b> BevyLinesRenderBackend<'world, 'state, 'a, 'b> {
+impl<'world, 'state, 'world2, 'state2, 'a, 'b, 'c, 'v, 'p>
+    BevyLinesRenderBackend<'world, 'state, 'world2, 'state2, 'a, 'b, 'c, 'v, 'p>
+{
     fn object_color(&self, object: DebugRenderObject, default: [f32; 4]) -> [f32; 4] {
         let color = match object {
             DebugRenderObject::Collider(h, ..) => self.context.colliders.get(h).and_then(|co| {
@@ -164,7 +166,9 @@ impl<'world, 'state, 'a, 'b> BevyLinesRenderBackend<'world, 'state, 'a, 'b> {
     }
 }
 
-impl<'world, 'state, 'a, 'b> DebugRenderBackend for BevyLinesRenderBackend<'world, 'state, 'a, 'b> {
+impl<'world, 'state, 'world2, 'state2, 'a, 'b, 'c, 'v, 'p> DebugRenderBackend
+    for BevyLinesRenderBackend<'world, 'state, 'world2, 'state2, 'a, 'b, 'c, 'v, 'p>
+{
     #[cfg(feature = "dim2")]
     fn draw_line(
         &mut self,
@@ -207,32 +211,33 @@ impl<'world, 'state, 'a, 'b> DebugRenderBackend for BevyLinesRenderBackend<'worl
 }
 
 fn debug_render_scene<'a>(
-    rapier_context: Res<RapierContext>,
+    rapier_context: Query<&RapierContext>,
     mut render_context: ResMut<DebugRenderContext>,
-    gizmos: Gizmos,
+    mut gizmos: Gizmos,
     custom_colors: Query<&'a ColliderDebugColor>,
     override_visibility: Query<&'a ColliderDebug>,
 ) {
     if !render_context.enabled {
         return;
     }
+    for rapier_context in rapier_context.iter() {
+        let mut backend = BevyLinesRenderBackend {
+            custom_colors: &custom_colors,
+            default_collider_debug: render_context.default_collider_debug,
+            override_visibility: &override_visibility,
+            context: rapier_context,
+            gizmos: &mut gizmos,
+        };
 
-    let mut backend = BevyLinesRenderBackend {
-        custom_colors,
-        default_collider_debug: render_context.default_collider_debug,
-        override_visibility,
-        context: &rapier_context,
-        gizmos,
-    };
-
-    let unscaled_style = render_context.pipeline.style;
-    render_context.pipeline.render(
-        &mut backend,
-        &rapier_context.bodies,
-        &rapier_context.colliders,
-        &rapier_context.impulse_joints,
-        &rapier_context.multibody_joints,
-        &rapier_context.narrow_phase,
-    );
-    render_context.pipeline.style = unscaled_style;
+        let unscaled_style = render_context.pipeline.style;
+        render_context.pipeline.render(
+            &mut backend,
+            &rapier_context.bodies,
+            &rapier_context.colliders,
+            &rapier_context.impulse_joints,
+            &rapier_context.multibody_joints,
+            &rapier_context.narrow_phase,
+        );
+        render_context.pipeline.style = unscaled_style;
+    }
 }