diff --git a/bevy_rapier2d/examples/player_movement2.rs b/bevy_rapier2d/examples/player_movement2.rs
index 99e01f0e..e6e21df1 100644
--- a/bevy_rapier2d/examples/player_movement2.rs
+++ b/bevy_rapier2d/examples/player_movement2.rs
@@ -24,9 +24,13 @@ 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_context: ResMut<RapierContext>) {
     // Set gravity to 0.0 and spawn camera.
-    rapier_config.gravity = Vec2::ZERO;
+    rapier_context
+        .get_world_mut(DEFAULT_WORLD_ID)
+        .expect("Default world should exist")
+        .set_gravity(Vec2::ZERO);
+
     commands.spawn(Camera2dBundle::default());
 
     let sprite_size = 100.0;
diff --git a/bevy_rapier2d/examples/testbed2.rs b/bevy_rapier2d/examples/testbed2.rs
index e7a52a97..a81657b6 100644
--- a/bevy_rapier2d/examples/testbed2.rs
+++ b/bevy_rapier2d/examples/testbed2.rs
@@ -145,13 +145,12 @@ fn main() {
         )
         .add_systems(
             OnExit(Examples::PlayerMovement2),
-            (
-                cleanup,
-                |mut rapier_config: ResMut<RapierConfiguration>, ctxt: Res<RapierContext>| {
-                    rapier_config.gravity =
-                        RapierConfiguration::new(ctxt.integration_parameters.length_unit).gravity;
-                },
-            ),
+            (cleanup, |mut rapier_context: ResMut<RapierContext>| {
+                rapier_context
+                    .get_world_mut(DEFAULT_WORLD_ID)
+                    .expect("Default world should exist")
+                    .set_gravity(Vect::Y * -9.81)
+            }),
         )
         //
         //testbed
diff --git a/bevy_rapier3d/examples/change_world3.rs b/bevy_rapier3d/examples/change_world3.rs
new file mode 100644
index 00000000..011549a7
--- /dev/null
+++ b/bevy_rapier3d/examples/change_world3.rs
@@ -0,0 +1,103 @@
+use bevy::prelude::*;
+use bevy_rapier3d::prelude::*;
+
+const N_WORLDS: usize = 5;
+const WORLD_CHANGE_DELAY_SEC: f32 = 3.0;
+
+#[derive(Component)]
+/// Denotes which object(s) to change the world of
+struct ChangeWorld;
+
+fn main() {
+    App::new()
+        .insert_resource(ClearColor(Color::rgb(
+            0xF9 as f32 / 255.0,
+            0xF9 as f32 / 255.0,
+            0xFF as f32 / 255.0,
+        )))
+        .add_plugins((
+            DefaultPlugins,
+            RapierPhysicsPlugin::<NoUserData>::default(),
+            RapierDebugRenderPlugin::default(),
+        ))
+        .add_systems(Startup, (setup_graphics, setup_physics))
+        .add_systems(Update, change_world)
+        .run();
+}
+
+fn change_world(mut query: Query<&mut PhysicsWorld, With<ChangeWorld>>, time: Res<Time>) {
+    for mut bw in query.iter_mut() {
+        if time.elapsed_seconds() > (bw.world_id.0 as f32 + 1.0) * WORLD_CHANGE_DELAY_SEC {
+            let new_world_id = bw.world_id.0 + 1;
+
+            if new_world_id != N_WORLDS {
+                println!("Changing world to {new_world_id}.");
+                bw.world_id = WorldId::new(new_world_id);
+            }
+        }
+    }
+}
+
+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()
+    });
+}
+
+pub fn setup_physics(mut context: ResMut<RapierContext>, mut commands: Commands) {
+    for _ in 1..N_WORLDS {
+        context.add_world(RapierWorld::default());
+    }
+
+    for world_id in 0..N_WORLDS {
+        let color = [
+            Color::hsl(220.0, 1.0, 0.3),
+            Color::hsl(180.0, 1.0, 0.3),
+            Color::hsl(260.0, 1.0, 0.7),
+        ][world_id % 3];
+
+        /*
+         * Ground
+         */
+        let ground_size = 5.1;
+        let ground_height = 0.1;
+
+        commands.spawn((
+            TransformBundle::from(Transform::from_xyz(
+                0.0,
+                (world_id as f32) * -0.5 - ground_height,
+                0.0,
+            )),
+            Collider::cuboid(ground_size, ground_height, ground_size),
+            ColliderDebugColor(color),
+            RigidBody::Fixed,
+            PhysicsWorld {
+                world_id: WorldId::new(world_id),
+            },
+        ));
+    }
+
+    /*
+     * Create the cube
+     *
+     * The child is just there to show that physics world changes will also change the children.
+     */
+    commands
+        .spawn((
+            TransformBundle::from(Transform::from_xyz(0.0, 3.0, 0.0)),
+            RigidBody::Dynamic,
+            PhysicsWorld {
+                world_id: DEFAULT_WORLD_ID,
+            },
+            ChangeWorld,
+        ))
+        .with_children(|p| {
+            p.spawn((
+                TransformBundle::from_transform(Transform::from_xyz(0.0, 0.0, 0.0)),
+                Collider::cuboid(0.5, 0.5, 0.5),
+                ColliderDebugColor(Color::hsl(260.0, 1.0, 0.7)),
+            ));
+        });
+}
diff --git a/bevy_rapier3d/examples/multi_world3.rs b/bevy_rapier3d/examples/multi_world3.rs
new file mode 100644
index 00000000..55f5596b
--- /dev/null
+++ b/bevy_rapier3d/examples/multi_world3.rs
@@ -0,0 +1,109 @@
+use bevy::prelude::*;
+use bevy_rapier3d::prelude::*;
+
+const N_WORLDS: usize = 5;
+
+fn main() {
+    App::new()
+        .insert_resource(ClearColor(Color::rgb(
+            0xF9 as f32 / 255.0,
+            0xF9 as f32 / 255.0,
+            0xFF as f32 / 255.0,
+        )))
+        .add_plugins((
+            DefaultPlugins,
+            RapierPhysicsPlugin::<NoUserData>::default(),
+            RapierDebugRenderPlugin::default(),
+        ))
+        .add_systems(Startup, (setup_physics, setup_graphics))
+        .add_systems(Update, move_middle_world)
+        // .add_systems(Update, change_world)
+        // .add_systems(Update, despawn_last)
+        .run();
+}
+
+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)]
+struct Platform {
+    starting_y: f32,
+}
+
+fn move_middle_world(
+    time: Res<Time>,
+    mut query: Query<(&mut Transform, &PhysicsWorld, &Platform)>,
+) {
+    for (mut transform, world, platform) in query.iter_mut() {
+        if world.world_id.0 == N_WORLDS / 2 {
+            transform.translation.y = platform.starting_y + -time.elapsed_seconds().sin();
+        }
+    }
+}
+
+/// Demonstrates despawning an entity removing it from its world
+// fn despawn_last(query: Query<(&PhysicsWorld, Entity)>, mut commands: Commands) {
+//     for (bw, entity) in query.iter() {
+//         if bw.world_id == N_WORLDS - 1 {
+//             commands.entity(entity).despawn_recursive();
+//         }
+//     }
+// }
+
+/// Demonstrates how easy it is to move one entity to another world.
+// fn change_world(mut query: Query<&mut PhysicsWorld>) {
+//     for mut bw in query.iter_mut() {
+//         if bw.world_id == 1 {
+//             bw.world_id = 0;
+//         }
+//     }
+// }
+
+pub fn setup_physics(mut context: ResMut<RapierContext>, mut commands: Commands) {
+    for _ in 1..N_WORLDS {
+        context.add_world(RapierWorld::default());
+    }
+
+    for world_id in 0..N_WORLDS {
+        let world_id = WorldId::new(world_id);
+
+        let color = [
+            Color::hsl(220.0, 1.0, 0.3),
+            Color::hsl(180.0, 1.0, 0.3),
+            Color::hsl(260.0, 1.0, 0.7),
+        ][world_id.0 % 3];
+
+        /*
+         * Ground
+         */
+        let ground_size = 5.1;
+        let ground_height = 0.1;
+
+        let starting_y = (world_id.0 as f32) * -0.5 - ground_height;
+
+        commands.spawn((
+            TransformBundle::from(Transform::from_xyz(0.0, starting_y, 0.0)),
+            Collider::cuboid(ground_size, ground_height, ground_size),
+            ColliderDebugColor(color),
+            Platform { starting_y },
+            PhysicsWorld { world_id },
+        ));
+
+        /*
+         * Create the cube
+         */
+
+        commands.spawn((
+            TransformBundle::from(Transform::from_xyz(0.0, 1.0 + world_id.0 as f32 * 5.0, 0.0)),
+            RigidBody::Dynamic,
+            Collider::cuboid(0.5, 0.5, 0.5),
+            ColliderDebugColor(color),
+            PhysicsWorld { world_id },
+        ));
+    }
+}
diff --git a/bevy_rapier3d/examples/ray_casting3.rs b/bevy_rapier3d/examples/ray_casting3.rs
index 4599a722..9320ded9 100644
--- a/bevy_rapier3d/examples/ray_casting3.rs
+++ b/bevy_rapier3d/examples/ray_casting3.rs
@@ -92,13 +92,16 @@ pub fn cast_ray(
         };
 
         // Then cast the ray.
-        let hit = rapier_context.cast_ray(
-            ray.origin,
-            ray.direction.into(),
-            f32::MAX,
-            true,
-            QueryFilter::only_dynamic(),
-        );
+        let hit = rapier_context
+            .cast_ray(
+                DEFAULT_WORLD_ID,
+                ray.origin,
+                *ray.direction,
+                f32::MAX,
+                true,
+                QueryFilter::only_dynamic(),
+            )
+            .expect("Default world should exist.");
 
         if let Some((entity, _toi)) = hit {
             // Color in blue the entity we just hit.
diff --git a/src/control/character_controller.rs b/src/control/character_controller.rs
index 8edfd41f..33511218 100644
--- a/src/control/character_controller.rs
+++ b/src/control/character_controller.rs
@@ -1,8 +1,8 @@
 use crate::geometry::{Collider, CollisionGroups, ShapeCastHit};
 use crate::math::{Real, Rot, Vect};
+use crate::plugin::context::RapierWorld;
 use bevy::prelude::*;
 
-use crate::plugin::RapierContext;
 pub use rapier::control::CharacterAutostep;
 pub use rapier::control::CharacterLength;
 use rapier::prelude::{ColliderSet, QueryFilterFlags};
@@ -26,10 +26,10 @@ pub struct CharacterCollision {
 
 impl CharacterCollision {
     pub(crate) fn from_raw(
-        ctxt: &RapierContext,
+        world: &RapierWorld,
         c: &rapier::control::CharacterCollision,
     ) -> Option<Self> {
-        Self::from_raw_with_set(&ctxt.colliders, c, true)
+        Self::from_raw_with_set(&world.colliders, c, true)
     }
 
     pub(crate) fn from_raw_with_set(
@@ -37,7 +37,7 @@ impl CharacterCollision {
         c: &rapier::control::CharacterCollision,
         details_always_computed: bool,
     ) -> Option<Self> {
-        RapierContext::collider_entity_with_set(colliders, c.handle).map(|entity| {
+        RapierWorld::collider_entity_with_set(colliders, c.handle).map(|entity| {
             CharacterCollision {
                 entity,
                 character_translation: c.character_pos.translation.vector.into(),
diff --git a/src/dynamics/rigid_body.rs b/src/dynamics/rigid_body.rs
index 77369576..1f68663b 100644
--- a/src/dynamics/rigid_body.rs
+++ b/src/dynamics/rigid_body.rs
@@ -1,4 +1,5 @@
 use crate::math::Vect;
+use crate::plugin::context::WorldId;
 use bevy::prelude::*;
 use rapier::prelude::{
     Isometry, LockedAxes as RapierLockedAxes, RigidBodyActivation, RigidBodyHandle, RigidBodyType,
@@ -178,7 +179,7 @@ impl Default for AdditionalMassProperties {
 /// This only reads the mass from entities with a [`RigidBody`] component.
 #[derive(Copy, Clone, Debug, Default, PartialEq, Component, Reflect)]
 #[reflect(Component, PartialEq)]
-pub struct ReadMassProperties(MassProperties);
+pub struct ReadMassProperties(pub MassProperties);
 
 impl ReadMassProperties {
     /// Get the [`MassProperties`] of this [`RigidBody`].
@@ -458,6 +459,14 @@ impl Default for GravityScale {
     }
 }
 
+/// Denotes which world this body is a part of. If omitted, the default world is assumed.
+#[derive(Copy, Clone, Debug, Default, PartialEq, Eq, Component, Reflect)]
+#[reflect(Component, PartialEq)]
+pub struct PhysicsWorld {
+    /// The world which this body is in. Use DEFAULT_WORLD_ID for the default world.
+    pub world_id: WorldId,
+}
+
 /// Information used for Continuous-Collision-Detection.
 #[derive(Copy, Clone, Debug, Default, PartialEq, Eq, Component, Reflect)]
 #[reflect(Component, PartialEq)]
diff --git a/src/geometry/collider.rs b/src/geometry/collider.rs
index 456c0acf..4ffb673c 100644
--- a/src/geometry/collider.rs
+++ b/src/geometry/collider.rs
@@ -341,6 +341,7 @@ bitflags::bitflags! {
 
         /// All of the groups.
         const ALL = u32::MAX;
+
         /// None of the groups.
         const NONE = 0;
     }
diff --git a/src/lib.rs b/src/lib.rs
index 557cd268..ca3271ad 100644
--- a/src/lib.rs
+++ b/src/lib.rs
@@ -16,10 +16,13 @@
 #[cfg(feature = "serde-serialize")]
 extern crate serde;
 
+/// nalgebra used by bevy_rapier
 pub extern crate nalgebra as na;
 #[cfg(feature = "dim2")]
+/// rapier2d used by bevy_rapier
 pub extern crate rapier2d as rapier;
 #[cfg(feature = "dim3")]
+/// rapier3d used by bevy_rapier
 pub extern crate rapier3d as rapier;
 pub use rapier::parry;
 
@@ -66,6 +69,8 @@ pub mod render;
 /// Miscellaneous helper functions.
 pub mod utils;
 
+// pub use crate::plugin::context::{RapierWorld, WorldId, DEFAULT_WORLD_ID};
+
 /// Groups the most often used types.
 pub mod prelude {
     pub use crate::control::*;
diff --git a/src/pipeline/events.rs b/src/pipeline/events.rs
index 85b50926..43df9b79 100644
--- a/src/pipeline/events.rs
+++ b/src/pipeline/events.rs
@@ -1,5 +1,6 @@
 use crate::math::{Real, Vect};
-use bevy::prelude::{Entity, Event, EventWriter};
+use crate::plugin::WorldId;
+use bevy::prelude::{Entity, Event};
 use rapier::dynamics::RigidBodySet;
 use rapier::geometry::{
     ColliderHandle, ColliderSet, CollisionEvent as RapierCollisionEvent, CollisionEventFlags,
@@ -16,9 +17,9 @@ use std::sync::RwLock;
 #[derive(Event, Copy, Clone, Debug, PartialEq, Eq)]
 pub enum CollisionEvent {
     /// Event occurring when two colliders start colliding
-    Started(Entity, Entity, CollisionEventFlags),
+    Started(Entity, Entity, CollisionEventFlags, WorldId),
     /// Event occurring when two colliders stop colliding
-    Stopped(Entity, Entity, CollisionEventFlags),
+    Stopped(Entity, Entity, CollisionEventFlags, WorldId),
 }
 
 /// Event occurring when the sum of the magnitudes of the contact forces
@@ -52,20 +53,21 @@ pub struct ContactForceEvent {
 // issue).
 /// A set of queues collecting events emitted by the physics engine.
 pub(crate) struct EventQueue<'a> {
-    // Used ot retrieve the entity of colliders that have been removed from the simulation
+    pub world_id: WorldId,
+
+    // 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: &'a mut RwLock<Vec<CollisionEvent>>,
+    pub contact_force_events: &'a mut RwLock<Vec<ContactForceEvent>>,
 }
 
 impl<'a> EventQueue<'a> {
-    fn collider2entity(&self, colliders: &ColliderSet, handle: ColliderHandle) -> Entity {
+    fn collider2entity(&self, colliders: &ColliderSet, handle: ColliderHandle) -> Option<Entity> {
         colliders
             .get(handle)
             .map(|co| Entity::from_bits(co.user_data as u64))
             .or_else(|| self.deleted_colliders.get(&handle).copied())
-            .expect("Internal error: entity not found for collision event.")
     }
 }
 
@@ -79,19 +81,29 @@ impl<'a> EventHandler for EventQueue<'a> {
     ) {
         let event = match event {
             RapierCollisionEvent::Started(h1, h2, flags) => {
-                let e1 = self.collider2entity(colliders, h1);
-                let e2 = self.collider2entity(colliders, h2);
-                CollisionEvent::Started(e1, e2, flags)
+                let Some(e1) = self.collider2entity(colliders, h1) else {
+                    return;
+                };
+                let Some(e2) = self.collider2entity(colliders, h2) else {
+                    return;
+                };
+
+                CollisionEvent::Started(e1, e2, flags, self.world_id)
             }
             RapierCollisionEvent::Stopped(h1, h2, flags) => {
-                let e1 = self.collider2entity(colliders, h1);
-                let e2 = self.collider2entity(colliders, h2);
-                CollisionEvent::Stopped(e1, e2, flags)
+                let Some(e1) = self.collider2entity(colliders, h1) else {
+                    return;
+                };
+                let Some(e2) = self.collider2entity(colliders, h2) else {
+                    return;
+                };
+
+                CollisionEvent::Stopped(e1, e2, flags, self.world_id)
             }
         };
 
         if let Ok(mut events) = self.collision_events.write() {
-            events.send(event);
+            events.push(event);
         }
     }
 
@@ -105,9 +117,17 @@ impl<'a> EventHandler for EventQueue<'a> {
     ) {
         let rapier_event =
             RapierContactForceEvent::from_contact_pair(dt, contact_pair, total_force_magnitude);
+
+        let Some(collider1) = self.collider2entity(colliders, rapier_event.collider1) else {
+            return;
+        };
+        let Some(collider2) = self.collider2entity(colliders, rapier_event.collider2) else {
+            return;
+        };
+
         let event = ContactForceEvent {
-            collider1: self.collider2entity(colliders, rapier_event.collider1),
-            collider2: self.collider2entity(colliders, rapier_event.collider2),
+            collider1,
+            collider2,
             total_force: rapier_event.total_force.into(),
             total_force_magnitude: rapier_event.total_force_magnitude,
             max_force_direction: rapier_event.max_force_direction.into(),
@@ -115,7 +135,7 @@ impl<'a> EventHandler for EventQueue<'a> {
         };
 
         if let Ok(mut events) = self.contact_force_events.write() {
-            events.send(event);
+            events.push(event);
         }
     }
 }
diff --git a/src/pipeline/mod.rs b/src/pipeline/mod.rs
index f857e1f9..1784dbd0 100644
--- a/src/pipeline/mod.rs
+++ b/src/pipeline/mod.rs
@@ -1,4 +1,4 @@
-pub(crate) use self::events::EventQueue;
+// pub(crate) use self::events::EventQueue;
 pub use self::events::{CollisionEvent, ContactForceEvent};
 pub(crate) use self::physics_hooks::BevyPhysicsHooksAdapter;
 pub use self::physics_hooks::{
@@ -6,6 +6,6 @@ pub use self::physics_hooks::{
 };
 pub use query_filter::{QueryFilter, QueryFilterFlags};
 
-mod events;
+pub(crate) mod events;
 mod physics_hooks;
 mod query_filter;
diff --git a/src/plugin/configuration.rs b/src/plugin/configuration.rs
index 8d4b7d3b..f25029d2 100644
--- a/src/plugin/configuration.rs
+++ b/src/plugin/configuration.rs
@@ -1,7 +1,5 @@
-use bevy::prelude::{FromWorld, Resource, World};
+use bevy::prelude::Resource;
 
-use crate::math::{Real, Vect};
-use crate::plugin::RapierContext;
 
 /// Difference between simulation and rendering time
 #[derive(Resource, Default)]
@@ -53,8 +51,6 @@ pub enum TimestepMode {
 #[derive(Resource, Copy, Clone, Debug)]
 /// A resource for specifying configuration information for the physics simulation
 pub struct RapierConfiguration {
-    /// Specifying the gravity of the physics simulation.
-    pub gravity: Vect,
     /// Specifies if the physics simulation is active and update the physics world.
     pub physics_pipeline_active: bool,
     /// Specifies if the query pipeline is active and update the query pipeline.
@@ -73,13 +69,9 @@ 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 Default for RapierConfiguration {
+    fn default() -> Self {
+        Self::new()
     }
 }
 
@@ -90,9 +82,8 @@ impl RapierConfiguration {
     /// on that argument.
     ///
     /// The default gravity is automatically scaled by that length unit.
-    pub fn new(length_unit: Real) -> Self {
+    pub fn new() -> Self {
         Self {
-            gravity: Vect::Y * -9.81 * length_unit,
             physics_pipeline_active: true,
             query_pipeline_active: true,
             timestep_mode: TimestepMode::Variable {
diff --git a/src/plugin/context.rs b/src/plugin/context.rs
index e842a411..80d2efe5 100644
--- a/src/plugin/context.rs
+++ b/src/plugin/context.rs
@@ -1,7 +1,13 @@
 use bevy::prelude::*;
+use core::fmt;
 use std::collections::HashMap;
 use std::sync::RwLock;
 
+use crate::geometry::{Collider, PointProjection, RayIntersection};
+use crate::math::{Rot, Vect};
+use crate::pipeline::{CollisionEvent, ContactForceEvent, QueryFilter};
+use crate::prelude::events::EventQueue;
+use rapier::control::CharacterAutostep;
 use rapier::prelude::{
     CCDSolver, ColliderHandle, ColliderSet, EventHandler, FeatureId, ImpulseJointHandle,
     ImpulseJointSet, IntegrationParameters, IslandManager, MultibodyJointHandle, MultibodyJointSet,
@@ -9,9 +15,7 @@ use rapier::prelude::{
     Ray, Real, RigidBodyHandle, RigidBodySet,
 };
 
-use crate::geometry::{Collider, PointProjection, RayIntersection, ShapeCastHit};
-use crate::math::{Rot, Vect};
-use crate::pipeline::{CollisionEvent, ContactForceEvent, EventQueue, QueryFilter};
+use crate::geometry::ShapeCastHit;
 use bevy::prelude::{Entity, EventWriter, GlobalTransform, Query};
 
 use crate::control::{CharacterCollision, MoveShapeOptions, MoveShapeOutput};
@@ -19,13 +23,39 @@ use crate::dynamics::TransformInterpolation;
 use crate::parry::query::details::ShapeCastOptions;
 use crate::plugin::configuration::{SimulationToRenderTime, TimestepMode};
 use crate::prelude::{CollisionGroups, RapierRigidBodyHandle};
-use rapier::control::CharacterAutostep;
 use rapier::geometry::DefaultBroadPhase;
 
+/// Points to the [`RapierWorld`] within the [`RapierContext`].
+#[cfg_attr(feature = "serde-serialize", derive(Serialize, Deserialize))]
+#[derive(Debug, Default, Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash, Reflect)]
+pub struct WorldId(pub usize);
+
+impl std::fmt::Display for WorldId {
+    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+        f.write_str(format!("{}", self.0).as_str())
+    }
+}
+
+impl WorldId {
+    /// This references a [`RapierWorld`] within the [`RapierContext`]
+    ///
+    /// This id is not checked for validity.
+    pub fn new(id: usize) -> Self {
+        Self(id)
+    }
+}
+
+/// This world id is the default world that is created when the physics plugin is initialized.
+///
+/// This world CAN be removed from the simulation if [`RapierContext::remove_world`] is called with this ID,
+/// so it may not always be valid.
+pub const DEFAULT_WORLD_ID: WorldId = WorldId(0);
+
 /// The Rapier context, containing all the state of the physics engine.
 #[cfg_attr(feature = "serde-serialize", derive(Serialize, Deserialize))]
-#[derive(Resource)]
-pub struct RapierContext {
+pub struct RapierWorld {
+    /// Specifying the gravity of the physics simulation.
+    pub gravity: Vect,
     /// The island manager, which detects what object is sleeping
     /// (not moving much) to reduce computations.
     pub islands: IslandManager,
@@ -70,10 +100,14 @@ pub struct RapierContext {
     #[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: RwLock<Vec<CollisionEvent>>,
+    #[cfg_attr(feature = "serde-serialize", serde(skip))]
+    pub(crate) contact_force_events_to_send: RwLock<Vec<ContactForceEvent>>,
+    #[cfg_attr(feature = "serde-serialize", serde(skip))]
     pub(crate) character_collisions_collector: Vec<rapier::control::CharacterCollision>,
 }
 
-impl Default for RapierContext {
+impl Default for RapierWorld {
     fn default() -> Self {
         Self {
             islands: IslandManager::new(),
@@ -95,11 +129,54 @@ impl Default for RapierContext {
             entity2multibody_joint: HashMap::new(),
             deleted_colliders: HashMap::new(),
             character_collisions_collector: vec![],
+            collision_events_to_send: RwLock::new(Vec::new()),
+            contact_force_events_to_send: RwLock::new(Vec::new()),
+            gravity: Vect::Y * -9.81,
         }
     }
 }
 
-impl RapierContext {
+impl RapierWorld {
+    /// 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>,
+    ) {
+        if let Ok(mut collision_events_to_send) = self.collision_events_to_send.write() {
+            for collision_event in collision_events_to_send.iter() {
+                collision_event_writer.send(*collision_event);
+            }
+
+            collision_events_to_send.clear();
+        }
+
+        if let Ok(mut contact_force_events_to_send) = self.contact_force_events_to_send.write() {
+            for contact_force_event in contact_force_events_to_send.iter() {
+                contact_force_event_writer.send(*contact_force_event);
+            }
+
+            contact_force_events_to_send.clear();
+        }
+    }
+
+    /// Sets the gravity of this world with respect to its integration parameters.
+    ///
+    /// Prefer using this over setting gravity manually
+    pub fn set_gravity(&mut self, gravity: Vect) {
+        self.gravity = gravity * self.integration_parameters.length_unit;
+    }
+
+    /// Sets the gravity of this world with respect to its integration parameters.
+    ///
+    /// Prefer using this over setting gravity manually
+    pub fn with_gravity(mut self, gravity: Vect) -> Self {
+        self.set_gravity(gravity);
+
+        self
+    }
+
     /// If the collider attached to `entity` is attached to a rigid-body, this
     /// returns the `Entity` containing that rigid-body.
     pub fn collider_parent(&self, entity: Entity) -> Option<Entity> {
@@ -113,7 +190,7 @@ impl RapierContext {
     /// If entity is a rigid-body, this returns the collider `Entity`s attached
     /// to that rigid-body.
     pub fn rigid_body_colliders(&self, entity: Entity) -> impl Iterator<Item = Entity> + '_ {
-        self.entity2body()
+        self.entity2body
             .get(&entity)
             .and_then(|handle| self.bodies.get(*handle))
             .map(|body| {
@@ -200,21 +277,28 @@ impl RapierContext {
     #[allow(clippy::too_many_arguments)]
     pub fn step_simulation(
         &mut self,
-        gravity: Vect,
+        world_id: WorldId,
         timestep_mode: TimestepMode,
-        events: Option<(EventWriter<CollisionEvent>, EventWriter<ContactForceEvent>)>,
+        create_bevy_events: bool,
         hooks: &dyn PhysicsHooks,
         time: &Time,
         sim_to_render_time: &mut SimulationToRenderTime,
-        mut interpolation_query: Option<
-            Query<(&RapierRigidBodyHandle, &mut TransformInterpolation)>,
+        interpolation_query: &mut Option<
+            &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 gravity = self.gravity;
+
+        let event_queue = if create_bevy_events {
+            Some(EventQueue {
+                world_id,
+                deleted_colliders: &self.deleted_colliders,
+                collision_events: &mut self.collision_events_to_send,
+                contact_force_events: &mut self.contact_force_events_to_send,
+            })
+        } else {
+            None
+        };
 
         let events = self
             .event_handler
@@ -328,7 +412,7 @@ impl RapierContext {
         }
     }
 
-    /// This method makes sure tha the rigid-body positions have been propagated to
+    /// This method makes sure that the rigid-body positions have been propagated to
     /// their attached colliders, without having to perform a srimulation step.
     pub fn propagate_modified_body_positions_to_colliders(&mut self) {
         self.bodies
@@ -341,26 +425,6 @@ impl RapierContext {
         self.query_pipeline.update(&self.bodies, &self.colliders);
     }
 
-    /// The map from entities to rigid-body handles.
-    pub fn entity2body(&self) -> &HashMap<Entity, RigidBodyHandle> {
-        &self.entity2body
-    }
-
-    /// The map from entities to collider handles.
-    pub fn entity2collider(&self) -> &HashMap<Entity, ColliderHandle> {
-        &self.entity2collider
-    }
-
-    /// The map from entities to impulse joint handles.
-    pub fn entity2impulse_joint(&self) -> &HashMap<Entity, ImpulseJointHandle> {
-        &self.entity2impulse_joint
-    }
-
-    /// The map from entities to multibody joint handles.
-    pub fn entity2multibody_joint(&self) -> &HashMap<Entity, MultibodyJointHandle> {
-        &self.entity2multibody_joint
-    }
-
     /// Attempts to move shape, optionally sliding or climbing obstacles.
     ///
     /// # Parameters
@@ -383,7 +447,7 @@ impl RapierContext {
         shape_mass: Real,
         options: &MoveShapeOptions,
         filter: QueryFilter,
-        mut events: impl FnMut(CharacterCollision),
+        events: &mut impl FnMut(CharacterCollision),
     ) -> MoveShapeOutput {
         let mut scaled_shape = shape.clone();
         // TODO: how to set a good number of subdivisions, we don’t have access to the
@@ -883,3 +947,609 @@ impl RapierContext {
         });
     }
 }
+
+#[derive(Debug)]
+pub enum WorldError {
+    WorldNotFound { world_id: WorldId },
+}
+
+impl fmt::Display for WorldError {
+    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+        match *self {
+            Self::WorldNotFound { world_id } => write!(f, "World with id {world_id} not found."),
+        }
+    }
+}
+
+impl std::error::Error for WorldError {}
+
+/// The Rapier context, containing all the state of the physics engine.
+#[cfg_attr(feature = "serde-serialize", derive(Serialize, Deserialize))]
+#[derive(Resource)]
+pub struct RapierContext {
+    /// Stores all the worlds in the simulation.
+    pub worlds: HashMap<WorldId, RapierWorld>,
+
+    next_world_id: WorldId,
+}
+
+impl RapierContext {}
+
+impl Default for RapierContext {
+    fn default() -> Self {
+        Self::new(RapierWorld::default())
+    }
+}
+
+impl RapierContext {
+    /// Creates a new RapierContext with a custom starting world
+    pub fn new(world: RapierWorld) -> Self {
+        let mut worlds = HashMap::new();
+        worlds.insert(DEFAULT_WORLD_ID, world);
+
+        Self {
+            worlds,
+            next_world_id: WorldId::new(1),
+        }
+    }
+
+    /// Adds a world to the simulation
+    ///
+    /// Returns that world's id
+    pub fn add_world(&mut self, world: RapierWorld) -> WorldId {
+        let world_id = self.next_world_id;
+
+        self.worlds.insert(world_id, world);
+
+        self.next_world_id.0 += 1;
+
+        world_id
+    }
+
+    /// Removes a world from the simulation. This does NOT despawn entities within that world.
+    /// Make sure all entities within that world are despawned or moved to a seperate world.
+    ///
+    /// Returns the removed world or an err if that world wasn't found or you tried to remove the default world.
+    pub fn remove_world(&mut self, world_id: WorldId) -> Result<RapierWorld, WorldError> {
+        self.worlds
+            .remove(&world_id)
+            .ok_or(WorldError::WorldNotFound { world_id })
+    }
+
+    /// Gets the world at the given id. If the world does not exist, an Err result will be returned
+    pub fn get_world(&self, world_id: WorldId) -> Result<&RapierWorld, WorldError> {
+        self.worlds
+            .get(&world_id)
+            .ok_or(WorldError::WorldNotFound { world_id })
+    }
+
+    /// Gets the mutable world at the given id. If the world does not exist, an Err result will be returned
+    pub fn get_world_mut(&mut self, world_id: WorldId) -> Result<&mut RapierWorld, WorldError> {
+        self.worlds
+            .get_mut(&world_id)
+            .ok_or(WorldError::WorldNotFound { world_id })
+    }
+
+    fn get_collider_parent_from_world(
+        &self,
+        entity: Entity,
+        world: &RapierWorld,
+    ) -> Option<Entity> {
+        world
+            .entity2collider
+            .get(&entity)
+            .and_then(|h| world.colliders.get(*h))
+            .and_then(|co| co.parent())
+            .and_then(|h| self.rigid_body_entity(h))
+    }
+
+    /// If the collider attached to `entity` is attached to a rigid-body, this
+    /// returns the `Entity` containing that rigid-body.
+    pub fn collider_parent(&self, entity: Entity) -> Option<Entity> {
+        for (_, world) in self.worlds.iter() {
+            if let Some(entity) = self.get_collider_parent_from_world(entity, world) {
+                return Some(entity);
+            }
+        }
+
+        None
+    }
+
+    /// If the collider attached to `entity` is attached to a rigid-body, this
+    /// returns the `Entity` containing that rigid-body.
+    ///
+    /// If the world does not exist, this returns None
+    pub fn collider_parent_for_world(&self, entity: Entity, world_id: WorldId) -> Option<Entity> {
+        if let Some(world) = self.worlds.get(&world_id) {
+            self.get_collider_parent_from_world(entity, world)
+        } else {
+            None
+        }
+    }
+
+    /// Retrieve the Bevy entity the given Rapier collider (identified by its handle) is attached.
+    pub fn collider_entity(&self, handle: ColliderHandle) -> Option<Entity> {
+        for (_, world) in self.worlds.iter() {
+            let entity = RapierWorld::collider_entity_with_set(&world.colliders, handle);
+            if entity.is_some() {
+                return entity;
+            }
+        }
+
+        None
+    }
+
+    /// Retrieve the Bevy entity the given Rapier rigid-body (identified by its handle) is attached.
+    pub fn rigid_body_entity(&self, handle: RigidBodyHandle) -> Option<Entity> {
+        for (_, world) in self.worlds.iter() {
+            let entity = world.rigid_body_entity(handle);
+            if entity.is_some() {
+                return entity;
+            }
+        }
+
+        None
+    }
+
+    /// Retrieve the Bevy entity the given Rapier rigid-body (identified by its handle) is attached.
+    ///
+    /// Returns None if this world does not exist
+    pub fn rigid_body_entity_in_world(
+        &self,
+        handle: RigidBodyHandle,
+        world_id: WorldId,
+    ) -> Option<Entity> {
+        self.worlds
+            .get(&world_id)
+            .map(|world| world.rigid_body_entity(handle))
+            .unwrap_or(None)
+    }
+
+    /// Advance the simulation, based on the given timestep mode.
+    #[allow(clippy::too_many_arguments)]
+    pub fn step_simulation(
+        mut self,
+        timestep_mode: TimestepMode,
+        mut events: Option<(EventWriter<CollisionEvent>, EventWriter<ContactForceEvent>)>,
+        hooks: &dyn PhysicsHooks,
+        time: &Time,
+        sim_to_render_time: &mut SimulationToRenderTime,
+        mut interpolation_query: Option<
+            &mut Query<(&RapierRigidBodyHandle, &mut TransformInterpolation)>,
+        >,
+    ) {
+        for (world_id, world) in self.worlds.iter_mut() {
+            world.step_simulation(
+                *world_id,
+                timestep_mode,
+                events.is_some(),
+                hooks,
+                time,
+                sim_to_render_time,
+                &mut interpolation_query,
+            );
+
+            if let Some((collision_event_writer, contact_force_event_writer)) = &mut events {
+                world.send_bevy_events(collision_event_writer, contact_force_event_writer);
+            }
+        }
+    }
+
+    /// This method makes sure that the rigid-body positions have been propagated to
+    /// their attached colliders, without having to perform a srimulation step.
+    pub fn propagate_modified_body_positions_to_colliders(&mut self) {
+        for (_, world) in self.worlds.iter_mut() {
+            world.propagate_modified_body_positions_to_colliders();
+        }
+    }
+
+    /// This method makes sure that the rigid-body positions have been propagated to
+    /// their attached colliders, without having to perform a srimulation step.
+    ///
+    /// Returns Ok if the world was found, Err(WorldError::WorldNotFound) if the world was not found.
+    pub fn propagate_modified_body_positions_to_colliders_for_world(
+        &mut self,
+        world_id: WorldId,
+    ) -> Result<(), WorldError> {
+        match self.worlds.get_mut(&world_id) {
+            Some(world) => {
+                world.propagate_modified_body_positions_to_colliders();
+
+                Ok(())
+            }
+            None => Err(WorldError::WorldNotFound { world_id }),
+        }
+    }
+
+    /// Updates the state of the query pipeline, based on the collider positions known
+    /// from the last timestep or the last call to `self.propagate_modified_body_positions_to_colliders()`.
+    pub fn update_query_pipeline(&mut self) {
+        for (_, world) in self.worlds.iter_mut() {
+            world.update_query_pipeline();
+        }
+    }
+
+    /// The map from entities to rigid-body handles.
+    ///
+    /// Returns Err if the world doesn't exist, or the entity2body if it does
+    pub fn entity2body(
+        &self,
+        world_id: WorldId,
+    ) -> Result<&HashMap<Entity, RigidBodyHandle>, WorldError> {
+        self.worlds
+            .get(&world_id)
+            .map_or(Err(WorldError::WorldNotFound { world_id }), |x| {
+                Ok(&x.entity2body)
+            })
+    }
+
+    /// The map from entities to collider handles.
+    pub fn entity2collider(
+        &self,
+        world_id: WorldId,
+    ) -> Result<&HashMap<Entity, ColliderHandle>, WorldError> {
+        self.worlds
+            .get(&world_id)
+            .map_or(Err(WorldError::WorldNotFound { world_id }), |x| {
+                Ok(&x.entity2collider)
+            })
+    }
+
+    /// The map from entities to impulse joint handles.
+    pub fn entity2impulse_joint(
+        &self,
+        world_id: WorldId,
+    ) -> Result<&HashMap<Entity, ImpulseJointHandle>, WorldError> {
+        self.worlds
+            .get(&world_id)
+            .map_or(Err(WorldError::WorldNotFound { world_id }), |x| {
+                Ok(&x.entity2impulse_joint)
+            })
+    }
+
+    /// The map from entities to multibody joint handles.
+    pub fn entity2multibody_joint(
+        &self,
+        world_id: WorldId,
+    ) -> Result<&HashMap<Entity, MultibodyJointHandle>, WorldError> {
+        self.worlds
+            .get(&world_id)
+            .map_or(Err(WorldError::WorldNotFound { world_id }), |x| {
+                Ok(&x.entity2multibody_joint)
+            })
+    }
+
+    /// Attempts to move shape, optionally sliding or climbing obstacles.
+    ///
+    /// # Parameters
+    /// * `movement`: the translational movement to apply.
+    /// * `shape`: the shape to move.
+    /// * `shape_translation`: the initial position of the shape.
+    /// * `shape_rotation`: the rotation of the shape.
+    /// * `shape_mass`: the mass of the shape to be considered by the impulse calculation if
+    ///                 `MoveShapeOptions::apply_impulse_to_dynamic_bodies` is set to true.
+    /// * `options`: configures the behavior of the automatic sliding and climbing.
+    /// * `filter`: indicates what collider or rigid-body needs to be ignored by the obstacle detection.
+    /// * `events`: callback run on each obstacle hit by the shape on its path.
+    #[allow(clippy::too_many_arguments)]
+    pub fn move_shape(
+        &mut self,
+        world_id: WorldId,
+        movement: Vect,
+        shape: &Collider,
+        shape_translation: Vect,
+        shape_rotation: Rot,
+        shape_mass: Real,
+        options: &MoveShapeOptions,
+        filter: QueryFilter,
+        events: &mut impl FnMut(CharacterCollision),
+    ) -> Result<MoveShapeOutput, WorldError> {
+        self.worlds.get_mut(&world_id).map_or(
+            Err(WorldError::WorldNotFound { world_id }),
+            |world| {
+                Ok(world.move_shape(
+                    movement,
+                    shape,
+                    shape_translation,
+                    shape_rotation,
+                    shape_mass,
+                    options,
+                    filter,
+                    events,
+                ))
+            },
+        )
+    }
+
+    /// Find the closest intersection between a ray and a set of collider.
+    ///
+    /// # Parameters
+    /// * `world_id`: the world to cast this ray in. Use DEFAULT_WORLD_ID for a single-world simulation
+    /// * `ray_origin`: the starting point of the ray to cast.
+    /// * `ray_dir`: the direction of the ray to cast.
+    /// * `max_toi`: the maximum time-of-impact that can be reported by this cast. This effectively
+    ///   limits the length of the ray to `ray.dir.norm() * max_toi`. Use `Real::MAX` for an unbounded ray.
+    /// * `solid`: if this is `true` an impact at time 0.0 (i.e. at the ray origin) is returned if
+    ///            it starts inside of a shape. If this `false` then the ray will hit the shape's boundary
+    ///            even if its starts inside of it.
+    /// * `filter`: set of rules used to determine which collider is taken into account by this scene query.
+    pub fn cast_ray(
+        &self,
+        world_id: WorldId,
+        ray_origin: Vect,
+        ray_dir: Vect,
+        max_toi: Real,
+        solid: bool,
+        filter: QueryFilter,
+    ) -> Result<Option<(Entity, Real)>, WorldError> {
+        self.worlds
+            .get(&world_id)
+            .map_or(Err(WorldError::WorldNotFound { world_id }), |world| {
+                Ok(world.cast_ray(ray_origin, ray_dir, max_toi, solid, filter))
+            })
+    }
+
+    /// Find the closest intersection between a ray and a set of collider.
+    ///
+    /// # Parameters
+    /// * `world_id`: the world to cast this ray in. Use DEFAULT_WORLD_ID for a single-world simulation
+    /// * `ray_origin`: the starting point of the ray to cast.
+    /// * `ray_dir`: the direction of the ray to cast.
+    /// * `max_toi`: the maximum time-of-impact that can be reported by this cast. This effectively
+    ///   limits the length of the ray to `ray.dir.norm() * max_toi`. Use `Real::MAX` for an unbounded ray.
+    /// * `solid`: if this is `true` an impact at time 0.0 (i.e. at the ray origin) is returned if
+    ///            it starts inside of a shape. If this `false` then the ray will hit the shape's boundary
+    ///            even if its starts inside of it.
+    /// * `filter`: set of rules used to determine which collider is taken into account by this scene query.
+    pub fn cast_ray_and_get_normal(
+        &self,
+        world_id: WorldId,
+        ray_origin: Vect,
+        ray_dir: Vect,
+        max_toi: Real,
+        solid: bool,
+        filter: QueryFilter,
+    ) -> Result<Option<(Entity, RayIntersection)>, WorldError> {
+        self.worlds
+            .get(&world_id)
+            .map_or(Err(WorldError::WorldNotFound { world_id }), |world| {
+                Ok(world.cast_ray_and_get_normal(ray_origin, ray_dir, max_toi, solid, filter))
+            })
+    }
+
+    /// Find the all intersections between a ray and a set of collider and passes them to a callback.
+    ///
+    /// # Parameters
+    /// * `world_id`: the world to cast this ray in. Use DEFAULT_WORLD_ID for a single-world simulation
+    /// * `ray_origin`: the starting point of the ray to cast.
+    /// * `ray_dir`: the direction of the ray to cast.
+    /// * `max_toi`: the maximum time-of-impact that can be reported by this cast. This effectively
+    ///   limits the length of the ray to `ray.dir.norm() * max_toi`. Use `Real::MAX` for an unbounded ray.
+    /// * `solid`: if this is `true` an impact at time 0.0 (i.e. at the ray origin) is returned if
+    ///            it starts inside of a shape. If this `false` then the ray will hit the shape's boundary
+    ///            even if its starts inside of it.
+    /// * `filter`: set of rules used to determine which collider is taken into account by this scene query.
+    /// * `callback`: function executed on each collider for which a ray intersection has been found.
+    ///               There is no guarantees on the order the results will be yielded. If this callback returns `false`,
+    ///               this method will exit early, ignore any further raycast.
+    #[allow(clippy::too_many_arguments)]
+    pub fn intersections_with_ray(
+        &self,
+        world_id: WorldId,
+        ray_origin: Vect,
+        ray_dir: Vect,
+        max_toi: Real,
+        solid: bool,
+        filter: QueryFilter,
+        callback: impl FnMut(Entity, RayIntersection) -> bool,
+    ) -> Result<(), WorldError> {
+        self.worlds
+            .get(&world_id)
+            .map_or(Err(WorldError::WorldNotFound { world_id }), |world| {
+                world.intersections_with_ray(ray_origin, ray_dir, max_toi, solid, filter, callback);
+                Ok(())
+            })
+    }
+
+    /// Gets the handle of up to one collider intersecting the given shape.
+    ///
+    /// # Parameters
+    /// * `shape_pos` - The position of the shape used for the intersection test.
+    /// * `shape` - The shape used for the intersection test.
+    /// * `filter`: set of rules used to determine which collider is taken into account by this scene query.
+    pub fn intersection_with_shape(
+        &self,
+        world_id: WorldId,
+        shape_pos: Vect,
+        shape_rot: Rot,
+        shape: &Collider,
+        filter: QueryFilter,
+    ) -> Result<Option<Entity>, WorldError> {
+        self.worlds
+            .get(&world_id)
+            .map_or(Err(WorldError::WorldNotFound { world_id }), |world| {
+                Ok(world.intersection_with_shape(shape_pos, shape_rot, shape, filter))
+            })
+    }
+
+    /// Find the projection of a point on the closest collider.
+    ///
+    /// # Parameters
+    /// * `point` - The point to project.
+    /// * `solid` - If this is set to `true` then the collider shapes are considered to
+    ///   be plain (if the point is located inside of a plain shape, its projection is the point
+    ///   itself). If it is set to `false` the collider shapes are considered to be hollow
+    ///   (if the point is located inside of an hollow shape, it is projected on the shape's
+    ///   boundary).
+    /// * `filter`: set of rules used to determine which collider is taken into account by this scene query.
+    pub fn project_point(
+        &self,
+        world_id: WorldId,
+        point: Vect,
+        solid: bool,
+        filter: QueryFilter,
+    ) -> Result<Option<(Entity, PointProjection)>, WorldError> {
+        self.worlds
+            .get(&world_id)
+            .map_or(Err(WorldError::WorldNotFound { world_id }), |world| {
+                Ok(world.project_point(point, solid, filter))
+            })
+    }
+
+    /// Find all the colliders containing the given point.
+    ///
+    /// # Parameters
+    /// * `point` - The point used for the containment test.
+    /// * `filter`: set of rules used to determine which collider is taken into account by this scene query.
+    /// * `callback` - A function called with each collider with a shape containing the `point`.
+    ///                If this callback returns `false`, this method will exit early, ignore any
+    ///                further point projection.
+    pub fn intersections_with_point(
+        &self,
+        world_id: WorldId,
+        point: Vect,
+        filter: QueryFilter,
+        callback: impl FnMut(Entity) -> bool,
+    ) -> Result<(), WorldError> {
+        self.worlds
+            .get(&world_id)
+            .map_or(Err(WorldError::WorldNotFound { world_id }), |world| {
+                world.intersections_with_point(point, filter, callback);
+                Ok(())
+            })
+    }
+
+    /// Find the projection of a point on the closest collider.
+    ///
+    /// The results include the ID of the feature hit by the point.
+    ///
+    /// # Parameters
+    /// * `point` - The point to project.
+    /// * `solid` - If this is set to `true` then the collider shapes are considered to
+    ///   be plain (if the point is located inside of a plain shape, its projection is the point
+    ///   itself). If it is set to `false` the collider shapes are considered to be hollow
+    ///   (if the point is located inside of an hollow shape, it is projected on the shape's
+    ///   boundary).
+    /// * `filter`: set of rules used to determine which collider is taken into account by this scene query.
+    pub fn project_point_and_get_feature(
+        &self,
+        world_id: WorldId,
+        point: Vect,
+        filter: QueryFilter,
+    ) -> Result<Option<(Entity, PointProjection, FeatureId)>, WorldError> {
+        self.worlds
+            .get(&world_id)
+            .map_or(Err(WorldError::WorldNotFound { world_id }), |world| {
+                Ok(world.project_point_and_get_feature(point, filter))
+            })
+    }
+
+    /// Finds all entities of all the colliders with an Aabb intersecting the given Aabb.
+    pub fn colliders_with_aabb_intersecting_aabb(
+        &self,
+        world_id: WorldId,
+        aabb: bevy::render::primitives::Aabb,
+        callback: impl FnMut(Entity) -> bool,
+    ) -> Result<(), WorldError> {
+        self.worlds
+            .get(&world_id)
+            .map_or(Err(WorldError::WorldNotFound { world_id }), |world| {
+                world.colliders_with_aabb_intersecting_aabb(aabb, callback);
+                Ok(())
+            })
+    }
+
+    /// Casts a shape at a constant linear velocity and retrieve the first collider it hits.
+    ///
+    /// This is similar to ray-casting except that we are casting a whole shape instead of just a
+    /// point (the ray origin). In the resulting `TOI`, witness and normal 1 refer to the world
+    /// collider, and are in world space.
+    ///
+    /// # Parameters
+    /// * `shape_pos` - The initial position of the shape to cast.
+    /// * `shape_vel` - The constant velocity of the shape to cast (i.e. the cast direction).
+    /// * `shape` - The shape to cast.
+    /// * `max_toi` - The maximum time-of-impact that can be reported by this cast. This effectively
+    ///   limits the distance traveled by the shape to `shapeVel.norm() * maxToi`.
+    /// * `filter`: set of rules used to determine which collider is taken into account by this scene query.
+    #[allow(clippy::too_many_arguments)]
+    pub fn cast_shape(
+        &self,
+        world_id: WorldId,
+        shape_pos: Vect,
+        shape_rot: Rot,
+        shape_vel: Vect,
+        shape: &Collider,
+        options: ShapeCastOptions,
+        filter: QueryFilter,
+    ) -> Result<Option<(Entity, ShapeCastHit)>, WorldError> {
+        self.worlds
+            .get(&world_id)
+            .map_or(Err(WorldError::WorldNotFound { world_id }), |world| {
+                Ok(world.cast_shape(shape_pos, shape_rot, shape_vel, shape, options, filter))
+            })
+    }
+
+    /* TODO: we need to wrap the NonlinearRigidMotion somehow.
+     *
+    /// Casts a shape with an arbitrary continuous motion and retrieve the first collider it hits.
+    ///
+    /// In the resulting `TOI`, witness and normal 1 refer to the world collider, and are in world
+    /// space.
+    ///
+    /// # Parameters
+    /// * `shape_motion` - The motion of the shape.
+    /// * `shape` - The shape to cast.
+    /// * `start_time` - The starting time of the interval where the motion takes place.
+    /// * `end_time` - The end time of the interval where the motion takes place.
+    /// * `stop_at_penetration` - If the casted shape starts in a penetration state with any
+    ///    collider, two results are possible. If `stop_at_penetration` is `true` then, the
+    ///    result will have a `toi` equal to `start_time`. If `stop_at_penetration` is `false`
+    ///    then the nonlinear shape-casting will see if further motion wrt. the penetration normal
+    ///    would result in tunnelling. If it does not (i.e. we have a separating velocity along
+    ///    that normal) then the nonlinear shape-casting will attempt to find another impact,
+    ///    at a time `> start_time` that could result in tunnelling.
+    /// * `filter`: set of rules used to determine which collider is taken into account by this scene query.
+    pub fn nonlinear_cast_shape(
+        &self,
+        world_id: WorldId,
+        shape_motion: &NonlinearRigidMotion,
+        shape: &Collider,
+        start_time: Real,
+        end_time: Real,
+        stop_at_penetration: bool,
+        filter: QueryFilter,
+    ) -> Result<Option<(Entity, Toi)>, WorldError> {
+        self.worlds
+            .get(&world_id)
+            .map_or(Err(WorldError::WorldNotFound { world_id }), |world| {
+                Ok(world.nonlinear_cast_shape(shape_motion, shape, start_time, end_time, stop_at_penetration, filter))
+            })
+    }
+     */
+
+    /// Retrieve all the colliders intersecting the given shape.
+    ///
+    /// # Parameters
+    /// * `shapePos` - The position of the shape to test.
+    /// * `shapeRot` - The orientation of the shape to test.
+    /// * `shape` - The shape to test.
+    /// * `filter`: set of rules used to determine which collider is taken into account by this scene query.
+    /// * `callback` - A function called with the entities of each collider intersecting the `shape`.
+    pub fn intersections_with_shape(
+        &self,
+        world_id: WorldId,
+        shape_pos: Vect,
+        shape_rot: Rot,
+        shape: &Collider,
+        filter: QueryFilter,
+        callback: impl FnMut(Entity) -> bool,
+    ) -> Result<(), WorldError> {
+        self.worlds
+            .get(&world_id)
+            .map_or(Err(WorldError::WorldNotFound { world_id }), |world| {
+                world.intersections_with_shape(shape_pos, shape_rot, shape, filter, callback);
+                Ok(())
+            })
+    }
+}
diff --git a/src/plugin/mod.rs b/src/plugin/mod.rs
index fbbb9e7d..ad3a6e54 100644
--- a/src/plugin/mod.rs
+++ b/src/plugin/mod.rs
@@ -1,13 +1,42 @@
+use crate::prelude::PhysicsWorld;
+
 pub use self::configuration::{RapierConfiguration, SimulationToRenderTime, TimestepMode};
 pub use self::context::RapierContext;
-pub use self::plugin::{NoUserData, PhysicsSet, RapierPhysicsPlugin, RapierTransformPropagateSet};
+pub use self::plugin::{
+    NoUserData, PhysicsSet, RapierPhysicsPlugin, RapierTransformPropagateSet, RapierWorld, WorldId,
+    DEFAULT_WORLD_ID,
+};
 
 #[allow(clippy::type_complexity)]
 #[allow(clippy::too_many_arguments)]
 pub mod systems;
 
 mod configuration;
-mod context;
+pub(crate) mod context;
 mod narrow_phase;
 #[allow(clippy::module_inception)]
-mod plugin;
+pub(crate) mod plugin;
+
+fn get_world<'a>(
+    world_within: Option<&'a PhysicsWorld>,
+    context: &'a mut RapierContext,
+) -> &'a mut RapierWorld {
+    let world_id = world_within.map(|x| x.world_id).unwrap_or(DEFAULT_WORLD_ID);
+
+    context
+        .get_world_mut(world_id)
+        .expect("World {world_id} does not exist")
+}
+
+fn find_item_and_world<T>(
+    context: &mut RapierContext,
+    item_finder: impl Fn(&mut RapierWorld) -> Option<T>,
+) -> Option<(&mut RapierWorld, T)> {
+    for (_, world) in context.worlds.iter_mut() {
+        if let Some(handle) = item_finder(world) {
+            return Some((world, handle));
+        }
+    }
+
+    None
+}
diff --git a/src/plugin/narrow_phase.rs b/src/plugin/narrow_phase.rs
index 8e6162c7..15d187ae 100644
--- a/src/plugin/narrow_phase.rs
+++ b/src/plugin/narrow_phase.rs
@@ -1,9 +1,9 @@
+use super::context::RapierWorld;
 use crate::math::{Real, Vect};
-use crate::plugin::RapierContext;
 use bevy::prelude::*;
 use rapier::geometry::{Contact, ContactManifold, ContactPair, SolverContact, SolverFlags};
 
-impl RapierContext {
+impl RapierWorld {
     /// All the contact pairs involving the non-sensor collider attached to the given entity.
     ///
     /// The returned contact pairs identify pairs of colliders with intersecting bounding-volumes.
@@ -94,7 +94,7 @@ impl RapierContext {
 
 /// Read-only access to the properties of a contact manifold.
 pub struct ContactManifoldView<'a> {
-    context: &'a RapierContext,
+    context: &'a RapierWorld,
     /// The raw contact manifold from Rapier.
     pub raw: &'a ContactManifold,
 }
@@ -299,7 +299,7 @@ impl<'a> SolverContactView<'a> {
 
 /// Read-only access to the properties of a contact pair.
 pub struct ContactPairView<'a> {
-    context: &'a RapierContext,
+    context: &'a RapierWorld,
     /// The raw contact pair from Rapier.
     pub raw: &'a ContactPair,
 }
diff --git a/src/plugin/plugin.rs b/src/plugin/plugin.rs
index 8bdc358f..208a3e67 100644
--- a/src/plugin/plugin.rs
+++ b/src/plugin/plugin.rs
@@ -1,10 +1,7 @@
-use crate::pipeline::{CollisionEvent, ContactForceEvent};
-use crate::plugin::configuration::SimulationToRenderTime;
-use crate::plugin::{systems, RapierConfiguration, RapierContext};
 use crate::prelude::*;
 use bevy::{
     ecs::{
-        event::{event_update_system, Events},
+        event::event_update_system,
         schedule::{ScheduleLabel, SystemConfigs},
         system::SystemParamItem,
     },
@@ -14,6 +11,10 @@ use bevy::{prelude::*, transform::TransformSystem};
 use rapier::dynamics::IntegrationParameters;
 use std::marker::PhantomData;
 
+pub use super::context::RapierWorld;
+pub use super::context::WorldId;
+pub use super::context::DEFAULT_WORLD_ID;
+
 /// No specific user-data is associated to the hooks.
 pub type NoUserData = ();
 
@@ -98,31 +99,31 @@ where
                 systems::init_rigid_bodies,
                 systems::init_colliders,
                 systems::init_joints,
-                systems::sync_removals,
-                // Run this here so the folowwing systems do not have a 1 frame delay.
+                // 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,
                 systems::apply_joint_user_changes,
                 systems::apply_initial_rigid_body_impulses,
+                systems::sync_vel,
             )
                 .chain()
                 .into_configs(),
             PhysicsSet::StepSimulation => (
+                event_update_system::<CollisionEvent>,
+                event_update_system::<ContactForceEvent>,
                 systems::step_simulation::<PhysicsHooks>,
-                event_update_system::<CollisionEvent>
-                    .before(systems::step_simulation::<PhysicsHooks>),
-                event_update_system::<ContactForceEvent>
-                    .before(systems::step_simulation::<PhysicsHooks>),
             )
+                .chain()
                 .into_configs(),
             PhysicsSet::Writeback => (
                 systems::update_colliding_entities,
                 systems::writeback_rigid_bodies,
                 systems::writeback_mass_properties,
-                event_update_system::<MassModifiedEvent>.after(systems::writeback_mass_properties),
+                event_update_system::<MassModifiedEvent>,
             )
+                .chain()
                 .into_configs(),
         }
     }
@@ -191,17 +192,18 @@ where
             .register_type::<CollisionGroups>()
             .register_type::<SolverGroups>()
             .register_type::<ContactForceEventThreshold>()
-            .register_type::<ContactSkin>()
-            .register_type::<Group>();
+            .register_type::<Group>()
+            .register_type::<PhysicsWorld>()
+            .register_type::<ContactSkin>();
 
         app.insert_resource(SimulationToRenderTime::default())
-            .insert_resource(RapierContext {
+            .insert_resource(RapierContext::new(RapierWorld {
                 integration_parameters: IntegrationParameters {
                     length_unit: self.length_unit,
                     ..Default::default()
                 },
                 ..Default::default()
-            })
+            }))
             .insert_resource(Events::<CollisionEvent>::default())
             .insert_resource(Events::<ContactForceEvent>::default())
             .insert_resource(Events::<MassModifiedEvent>::default());
@@ -223,11 +225,23 @@ where
                     PhysicsSet::Writeback,
                 )
                     .chain()
-                    .before(TransformSystem::TransformPropagate),
+                    .before(TransformSystem::TransformPropagate)
+                    .after(systems::sync_removals),
             );
 
             // 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(
+                PostUpdate,
+                (
+                    // Change any worlds needed before doing any calculations
+                    systems::on_add_entity_with_parent,
+                    systems::on_change_world,
+                    // Make sure to remove any dead bodies after changing_worlds but before everything else
+                    // to avoid it deleting something right after adding it
+                    systems::sync_removals,
+                )
+                    .chain(),
+            );
 
             app.add_systems(
                 self.schedule,
diff --git a/src/plugin/systems/character_controller.rs b/src/plugin/systems/character_controller.rs
index 4b25f6be..410eec64 100644
--- a/src/plugin/systems/character_controller.rs
+++ b/src/plugin/systems/character_controller.rs
@@ -1,10 +1,12 @@
 use crate::control::CharacterCollision;
 use crate::dynamics::RapierRigidBodyHandle;
 use crate::geometry::RapierColliderHandle;
+use crate::plugin::get_world;
 use crate::plugin::RapierConfiguration;
 use crate::plugin::RapierContext;
 use crate::prelude::KinematicCharacterController;
 use crate::prelude::KinematicCharacterControllerOutput;
+use crate::prelude::PhysicsWorld;
 use crate::utils;
 use bevy::prelude::*;
 use rapier::math::Isometry;
@@ -24,13 +26,22 @@ pub fn update_character_controls(
         Option<&RapierColliderHandle>,
         Option<&RapierRigidBodyHandle>,
         Option<&GlobalTransform>,
+        Option<&PhysicsWorld>,
     )>,
     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,
+        mut controller,
+        output,
+        collider_handle,
+        body_handle,
+        glob_transform,
+        world_within,
+    ) in character_controllers.iter_mut()
     {
+        let world = get_world(world_within, &mut context);
+
         if let (Some(raw_controller), Some(translation)) =
             (controller.to_raw(), controller.translation)
         {
@@ -48,11 +59,11 @@ pub fn update_character_controls(
 
             let parent_rigid_body = body_handle.map(|h| h.0).or_else(|| {
                 collider_handle
-                    .and_then(|h| context.colliders.get(h.0))
+                    .and_then(|h| world.colliders.get(h.0))
                     .and_then(|c| c.parent())
             });
             let entity_to_move = parent_rigid_body
-                .and_then(|rb| context.rigid_body_entity(rb))
+                .and_then(|rb| world.rigid_body_entity(rb))
                 .unwrap_or(entity);
 
             let (character_shape, character_pos) = if let Some((scaled_shape, tra, rot)) =
@@ -60,15 +71,14 @@ pub fn update_character_controls(
             {
                 let mut shape_pos: Isometry<Real> = (*tra, *rot).into();
 
-                if let Some(body) = body_handle.and_then(|h| context.bodies.get(h.0)) {
+                if let Some(body) = body_handle.and_then(|h| world.bodies.get(h.0)) {
                     shape_pos = body.position() * shape_pos
                 } else if let Some(gtransform) = glob_transform {
                     shape_pos = utils::transform_to_iso(&gtransform.compute_transform()) * shape_pos
                 }
 
                 (&*scaled_shape.raw, shape_pos)
-            } else if let Some(collider) = collider_handle.and_then(|h| context.colliders.get(h.0))
-            {
+            } else if let Some(collider) = collider_handle.and_then(|h| world.colliders.get(h.0)) {
                 (collider.shape(), *collider.position())
             } else {
                 continue;
@@ -80,7 +90,7 @@ pub fn update_character_controls(
                 .custom_mass
                 .or_else(|| {
                     parent_rigid_body
-                        .and_then(|h| context.bodies.get(h))
+                        .and_then(|h| world.bodies.get(h))
                         .map(|rb| rb.mass())
                 })
                 .unwrap_or(0.0);
@@ -99,14 +109,14 @@ pub fn update_character_controls(
                 filter = filter.exclude_collider(excl_co)
             };
 
-            let collisions = &mut context.character_collisions_collector;
+            let collisions = &mut world.character_collisions_collector;
             collisions.clear();
 
             let movement = raw_controller.move_shape(
-                context.integration_parameters.dt,
-                &context.bodies,
-                &context.colliders,
-                &context.query_pipeline,
+                world.integration_parameters.dt,
+                &world.bodies,
+                &world.colliders,
+                &world.query_pipeline,
                 character_shape,
                 &character_pos,
                 translation.into(),
@@ -115,12 +125,12 @@ pub fn update_character_controls(
             );
 
             if controller.apply_impulse_to_dynamic_bodies {
-                for collision in &*collisions {
+                for collision in collisions.iter() {
                     raw_controller.solve_character_collision_impulses(
-                        context.integration_parameters.dt,
-                        &mut context.bodies,
-                        &context.colliders,
-                        &context.query_pipeline,
+                        world.integration_parameters.dt,
+                        &mut world.bodies,
+                        &world.colliders,
+                        &world.query_pipeline,
                         character_shape,
                         character_mass,
                         collision,
@@ -139,10 +149,10 @@ pub fn update_character_controls(
                 }
             }
 
-            let converted_collisions = context
+            let converted_collisions = world
                 .character_collisions_collector
                 .iter()
-                .filter_map(|c| CharacterCollision::from_raw(context, c));
+                .filter_map(|c| CharacterCollision::from_raw(world, c));
 
             if let Some(mut output) = output {
                 output.desired_translation = controller.translation.unwrap();
diff --git a/src/plugin/systems/collider.rs b/src/plugin/systems/collider.rs
index d546cba7..91e1fb00 100644
--- a/src/plugin/systems/collider.rs
+++ b/src/plugin/systems/collider.rs
@@ -1,10 +1,10 @@
 use crate::dynamics::ReadMassProperties;
 use crate::geometry::Collider;
-use crate::plugin::{RapierConfiguration, RapierContext};
+use crate::plugin::{get_world, RapierConfiguration, RapierContext, RapierWorld};
 use crate::prelude::{
     ActiveCollisionTypes, ActiveEvents, ActiveHooks, ColliderDisabled, ColliderMassProperties,
     ColliderScale, CollidingEntities, CollisionEvent, CollisionGroups, ContactForceEventThreshold,
-    ContactSkin, Friction, MassModifiedEvent, MassProperties, RapierColliderHandle,
+    ContactSkin, Friction, MassModifiedEvent, MassProperties, PhysicsWorld, RapierColliderHandle,
     RapierRigidBodyHandle, Restitution, Sensor, SolverGroups,
 };
 use crate::utils;
@@ -79,140 +79,210 @@ pub fn apply_collider_user_changes(
     config: Res<RapierConfiguration>,
     (changed_collider_transforms, parent_query, transform_query): (
         Query<
-            (Entity, &RapierColliderHandle, &GlobalTransform),
+            (
+                Entity,
+                &RapierColliderHandle,
+                &GlobalTransform,
+                Option<&PhysicsWorld>,
+            ),
             (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<
+        (&RapierColliderHandle, &Collider, Option<&PhysicsWorld>),
+        Changed<Collider>,
+    >,
+    changed_active_events: Query<
+        (&RapierColliderHandle, &ActiveEvents, Option<&PhysicsWorld>),
+        Changed<ActiveEvents>,
+    >,
+    changed_active_hooks: Query<
+        (&RapierColliderHandle, &ActiveHooks, Option<&PhysicsWorld>),
+        Changed<ActiveHooks>,
+    >,
     changed_active_collision_types: Query<
-        (&RapierColliderHandle, &ActiveCollisionTypes),
+        (
+            &RapierColliderHandle,
+            &ActiveCollisionTypes,
+            Option<&PhysicsWorld>,
+        ),
         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<(&RapierColliderHandle, &Friction, Option<&PhysicsWorld>), Changed<Friction>>,
+        Query<(&RapierColliderHandle, &Restitution, Option<&PhysicsWorld>), Changed<Restitution>>,
+        Query<(&RapierColliderHandle, &ContactSkin, Option<&PhysicsWorld>), Changed<ContactSkin>>,
     ),
     changed_collision_groups: Query<
-        (&RapierColliderHandle, &CollisionGroups),
+        (
+            &RapierColliderHandle,
+            &CollisionGroups,
+            Option<&PhysicsWorld>,
+        ),
         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<
+        (&RapierColliderHandle, &SolverGroups, Option<&PhysicsWorld>),
+        Changed<SolverGroups>,
+    >,
+    changed_sensors: Query<
+        (&RapierColliderHandle, &Sensor, Option<&PhysicsWorld>),
+        Changed<Sensor>,
+    >,
+    changed_disabled: Query<
+        (
+            &RapierColliderHandle,
+            &ColliderDisabled,
+            Option<&PhysicsWorld>,
+        ),
+        Changed<ColliderDisabled>,
+    >,
     changed_contact_force_threshold: Query<
-        (&RapierColliderHandle, &ContactForceEventThreshold),
+        (
+            &RapierColliderHandle,
+            &ContactForceEventThreshold,
+            Option<&PhysicsWorld>,
+        ),
         Changed<ContactForceEventThreshold>,
     >,
     changed_collider_mass_props: Query<
-        (&RapierColliderHandle, &ColliderMassProperties),
+        (
+            &RapierColliderHandle,
+            &ColliderMassProperties,
+            Option<&PhysicsWorld>,
+        ),
         Changed<ColliderMassProperties>,
     >,
 
     mut mass_modified: EventWriter<MassModifiedEvent>,
 ) {
-    for (entity, handle, transform) in changed_collider_transforms.iter() {
-        if context.collider_parent(entity).is_some() {
+    for (entity, handle, transform, world_within) in changed_collider_transforms.iter() {
+        let world = get_world(world_within, &mut context);
+
+        if world.collider_parent(entity).is_some() {
             let (_, collider_position) =
-                collider_offset(entity, &context, &parent_query, &transform_query);
+                collider_offset(entity, world, &parent_query, &transform_query);
 
-            if let Some(co) = context.colliders.get_mut(handle.0) {
+            if let Some(co) = world.colliders.get_mut(handle.0) {
                 co.set_position_wrt_parent(utils::transform_to_iso(&collider_position));
             }
-        } else if let Some(co) = context.colliders.get_mut(handle.0) {
+        } else if let Some(co) = world.colliders.get_mut(handle.0) {
             co.set_position(utils::transform_to_iso(&transform.compute_transform()))
         }
     }
 
-    for (handle, shape) in changed_shapes.iter() {
-        if let Some(co) = context.colliders.get_mut(handle.0) {
+    for (handle, shape, world_within) in changed_shapes.iter() {
+        let world = get_world(world_within, &mut context);
+
+        if let Some(co) = world.colliders.get_mut(handle.0) {
             let mut scaled_shape = shape.clone();
             scaled_shape.set_scale(shape.scale, config.scaled_shape_subdivision);
             co.set_shape(scaled_shape.raw.clone());
 
             if let Some(body) = co.parent() {
-                if let Some(body_entity) = context.rigid_body_entity(body) {
+                if let Some(body_entity) = world.rigid_body_entity(body) {
                     mass_modified.send(body_entity.into());
                 }
             }
         }
     }
 
-    for (handle, active_events) in changed_active_events.iter() {
-        if let Some(co) = context.colliders.get_mut(handle.0) {
+    for (handle, active_events, world_within) in changed_active_events.iter() {
+        let world = get_world(world_within, &mut context);
+
+        if let Some(co) = world.colliders.get_mut(handle.0) {
             co.set_active_events((*active_events).into())
         }
     }
 
-    for (handle, active_hooks) in changed_active_hooks.iter() {
-        if let Some(co) = context.colliders.get_mut(handle.0) {
+    for (handle, active_hooks, world_within) in changed_active_hooks.iter() {
+        let world = get_world(world_within, &mut context);
+
+        if let Some(co) = world.colliders.get_mut(handle.0) {
             co.set_active_hooks((*active_hooks).into())
         }
     }
 
-    for (handle, active_collision_types) in changed_active_collision_types.iter() {
-        if let Some(co) = context.colliders.get_mut(handle.0) {
+    for (handle, active_collision_types, world_within) in changed_active_collision_types.iter() {
+        let world = get_world(world_within, &mut context);
+
+        if let Some(co) = world.colliders.get_mut(handle.0) {
             co.set_active_collision_types((*active_collision_types).into())
         }
     }
 
-    for (handle, friction) in changed_friction.iter() {
-        if let Some(co) = context.colliders.get_mut(handle.0) {
+    for (handle, friction, world_within) in changed_friction.iter() {
+        let world = get_world(world_within, &mut context);
+
+        if let Some(co) = world.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() {
-        if let Some(co) = context.colliders.get_mut(handle.0) {
+    for (handle, restitution, world_within) in changed_restitution.iter() {
+        let world = get_world(world_within, &mut context);
+
+        if let Some(co) = world.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() {
-        if let Some(co) = context.colliders.get_mut(handle.0) {
+    for (handle, contact_skin, world_within) in changed_contact_skin.iter() {
+        let world = get_world(world_within, &mut context);
+
+        if let Some(co) = world.colliders.get_mut(handle.0) {
             co.set_contact_skin(contact_skin.0);
         }
     }
 
-    for (handle, collision_groups) in changed_collision_groups.iter() {
-        if let Some(co) = context.colliders.get_mut(handle.0) {
+    for (handle, collision_groups, world_within) in changed_collision_groups.iter() {
+        let world = get_world(world_within, &mut context);
+
+        if let Some(co) = world.colliders.get_mut(handle.0) {
             co.set_collision_groups((*collision_groups).into());
         }
     }
 
-    for (handle, solver_groups) in changed_solver_groups.iter() {
-        if let Some(co) = context.colliders.get_mut(handle.0) {
+    for (handle, solver_groups, world_within) in changed_solver_groups.iter() {
+        let world = get_world(world_within, &mut context);
+
+        if let Some(co) = world.colliders.get_mut(handle.0) {
             co.set_solver_groups((*solver_groups).into());
         }
     }
 
-    for (handle, _) in changed_sensors.iter() {
-        if let Some(co) = context.colliders.get_mut(handle.0) {
+    for (handle, _, world_within) in changed_sensors.iter() {
+        let world = get_world(world_within, &mut context);
+
+        if let Some(co) = world.colliders.get_mut(handle.0) {
             co.set_sensor(true);
         }
     }
 
-    for (handle, _) in changed_disabled.iter() {
-        if let Some(co) = context.colliders.get_mut(handle.0) {
+    for (handle, _, world_within) in changed_disabled.iter() {
+        let world = get_world(world_within, &mut context);
+
+        if let Some(co) = world.colliders.get_mut(handle.0) {
             co.set_enabled(false);
         }
     }
 
-    for (handle, threshold) in changed_contact_force_threshold.iter() {
-        if let Some(co) = context.colliders.get_mut(handle.0) {
+    for (handle, threshold, world_within) in changed_contact_force_threshold.iter() {
+        let world = get_world(world_within, &mut context);
+
+        if let Some(co) = world.colliders.get_mut(handle.0) {
             co.set_contact_force_event_threshold(threshold.0);
         }
     }
 
-    for (handle, mprops) in changed_collider_mass_props.iter() {
-        if let Some(co) = context.colliders.get_mut(handle.0) {
+    for (handle, mprops, world_within) in changed_collider_mass_props.iter() {
+        let world = get_world(world_within, &mut context);
+
+        if let Some(co) = world.colliders.get_mut(handle.0) {
             match mprops {
                 ColliderMassProperties::Density(density) => co.set_density(*density),
                 ColliderMassProperties::Mass(mass) => co.set_mass(*mass),
@@ -222,7 +292,7 @@ pub fn apply_collider_user_changes(
             }
 
             if let Some(body) = co.parent() {
-                if let Some(body_entity) = context.rigid_body_entity(body) {
+                if let Some(body_entity) = world.rigid_body_entity(body) {
                     mass_modified.send(body_entity.into());
                 }
             }
@@ -232,12 +302,12 @@ pub fn apply_collider_user_changes(
 
 pub(crate) fn collider_offset(
     entity: Entity,
-    context: &RapierContext,
+    world: &RapierWorld,
     parent_query: &Query<&Parent>,
     transform_query: &Query<&Transform>,
 ) -> (Option<RigidBodyHandle>, Transform) {
     let mut body_entity = entity;
-    let mut body_handle = context.entity2body.get(&body_entity).copied();
+    let mut body_handle = world.entity2body.get(&body_entity).copied();
     let mut child_transform = Transform::default();
     while body_handle.is_none() {
         if let Ok(parent_entity) = parent_query.get(body_entity) {
@@ -249,7 +319,7 @@ pub(crate) fn collider_offset(
             break;
         }
 
-        body_handle = context.entity2body.get(&body_entity).copied();
+        body_handle = world.entity2body.get(&body_entity).copied();
     }
 
     if body_handle.is_some() {
@@ -271,13 +341,18 @@ pub fn init_colliders(
     mut commands: Commands,
     config: Res<RapierConfiguration>,
     mut context: ResMut<RapierContext>,
-    colliders: Query<(ColliderComponents, Option<&GlobalTransform>), Without<RapierColliderHandle>>,
+    colliders: Query<
+        (
+            ColliderComponents,
+            Option<&GlobalTransform>,
+            Option<&PhysicsWorld>,
+        ),
+        Without<RapierColliderHandle>,
+    >,
     mut rigid_body_mprops: Query<&mut ReadMassProperties>,
     parent_query: Query<&Parent>,
     transform_query: Query<&Transform>,
 ) {
-    let context = &mut *context;
-
     for (
         (
             entity,
@@ -296,8 +371,11 @@ pub fn init_colliders(
             disabled,
         ),
         global_transform,
+        world_within,
     ) in colliders.iter()
     {
+        let world = get_world(world_within, &mut context);
+
         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());
@@ -357,20 +435,20 @@ pub fn init_colliders(
 
         let body_entity = entity;
         let (body_handle, child_transform) =
-            collider_offset(entity, context, &parent_query, &transform_query);
+            collider_offset(entity, world, &parent_query, &transform_query);
 
         builder = builder.user_data(entity.to_bits() as u128);
 
         let handle = if let Some(body_handle) = body_handle {
             builder = builder.position(utils::transform_to_iso(&child_transform));
             let handle =
-                context
+                world
                     .colliders
-                    .insert_with_parent(builder, body_handle, &mut context.bodies);
+                    .insert_with_parent(builder, body_handle, &mut world.bodies);
             if let Ok(mut mprops) = rigid_body_mprops.get_mut(body_entity) {
                 // Inserting the collider changed the rigid-body’s mass properties.
                 // Read them back from the engine.
-                if let Some(parent_body) = context.bodies.get(body_handle) {
+                if let Some(parent_body) = world.bodies.get(body_handle) {
                     mprops.set(MassProperties::from_rapier(
                         parent_body.mass_properties().local_mprops,
                     ));
@@ -382,14 +460,14 @@ pub fn init_colliders(
             builder = builder.position(utils::transform_to_iso(
                 &global_transform.compute_transform(),
             ));
-            context.colliders.insert(builder)
+            world.colliders.insert(builder)
         };
 
         commands.entity(entity).insert(RapierColliderHandle(handle));
-        context.entity2collider.insert(entity, handle);
+
+        world.entity2collider.insert(entity, handle);
     }
 }
-
 /// System responsible for creating `Collider` components from `AsyncCollider` components if the
 /// corresponding mesh has become available.
 #[cfg(all(feature = "dim3", feature = "async-collider"))]
@@ -460,7 +538,7 @@ pub fn update_colliding_entities(
 ) {
     for event in collision_events.read() {
         match event.to_owned() {
-            CollisionEvent::Started(entity1, entity2, _) => {
+            CollisionEvent::Started(entity1, entity2, _, _) => {
                 if let Ok(mut entities) = colliding_entities.get_mut(entity1) {
                     entities.0.insert(entity2);
                 }
@@ -468,7 +546,7 @@ pub fn update_colliding_entities(
                     entities.0.insert(entity1);
                 }
             }
-            CollisionEvent::Stopped(entity1, entity2, _) => {
+            CollisionEvent::Stopped(entity1, entity2, _, _) => {
                 if let Ok(mut entities) = colliding_entities.get_mut(entity1) {
                     entities.0.remove(&entity2);
                 }
diff --git a/src/plugin/systems/joint.rs b/src/plugin/systems/joint.rs
index ff79dcd1..98068e90 100644
--- a/src/plugin/systems/joint.rs
+++ b/src/plugin/systems/joint.rs
@@ -2,24 +2,32 @@ use crate::dynamics::ImpulseJoint;
 use crate::dynamics::MultibodyJoint;
 use crate::dynamics::RapierImpulseJointHandle;
 use crate::dynamics::RapierMultibodyJointHandle;
+use crate::plugin::get_world;
 use crate::plugin::RapierContext;
+use crate::prelude::PhysicsWorld;
 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>>,
+    impulse_joints: Query<
+        (Entity, &ImpulseJoint, Option<&PhysicsWorld>),
+        Without<RapierImpulseJointHandle>,
+    >,
+    multibody_joints: Query<
+        (Entity, &MultibodyJoint, Option<&PhysicsWorld>),
+        Without<RapierMultibodyJointHandle>,
+    >,
     parent_query: Query<&Parent>,
 ) {
-    let context = &mut *context;
+    for (entity, joint, world_within) in impulse_joints.iter() {
+        let world = get_world(world_within, &mut context);
 
-    for (entity, joint) in impulse_joints.iter() {
         let mut target = None;
         let mut body_entity = entity;
         while target.is_none() {
-            target = context.entity2body.get(&body_entity).copied();
+            target = world.entity2body.get(&body_entity).copied();
             if let Ok(parent_entity) = parent_query.get(body_entity) {
                 body_entity = parent_entity.get();
             } else {
@@ -27,31 +35,33 @@ pub fn init_joints(
             }
         }
 
-        if let (Some(target), Some(source)) = (target, context.entity2body.get(&joint.parent)) {
+        if let (Some(target), Some(source)) = (target, world.entity2body.get(&joint.parent)) {
             let handle =
-                context
+                world
                     .impulse_joints
                     .insert(*source, target, joint.data.into_rapier(), true);
             commands
                 .entity(entity)
                 .insert(RapierImpulseJointHandle(handle));
-            context.entity2impulse_joint.insert(entity, handle);
+            world.entity2impulse_joint.insert(entity, handle);
         }
     }
 
-    for (entity, joint) in multibody_joints.iter() {
-        let target = context.entity2body.get(&entity);
+    for (entity, joint, world_within) in multibody_joints.iter() {
+        let world = get_world(world_within, &mut context);
+
+        let target = world.entity2body.get(&entity);
 
-        if let (Some(target), Some(source)) = (target, context.entity2body.get(&joint.parent)) {
+        if let (Some(target), Some(source)) = (target, world.entity2body.get(&joint.parent)) {
             if let Some(handle) =
-                context
+                world
                     .multibody_joints
                     .insert(*source, *target, joint.data.into_rapier(), true)
             {
                 commands
                     .entity(entity)
                     .insert(RapierMultibodyJointHandle(handle));
-                context.entity2multibody_joint.insert(entity, handle);
+                world.entity2multibody_joint.insert(entity, handle);
             } else {
                 error!("Failed to create multibody joint: loop detected.")
             }
@@ -63,25 +73,37 @@ pub fn init_joints(
 pub fn apply_joint_user_changes(
     mut context: ResMut<RapierContext>,
     changed_impulse_joints: Query<
-        (&RapierImpulseJointHandle, &ImpulseJoint),
+        (
+            &RapierImpulseJointHandle,
+            &ImpulseJoint,
+            Option<&PhysicsWorld>,
+        ),
         Changed<ImpulseJoint>,
     >,
     changed_multibody_joints: Query<
-        (&RapierMultibodyJointHandle, &MultibodyJoint),
+        (
+            &RapierMultibodyJointHandle,
+            &MultibodyJoint,
+            Option<&PhysicsWorld>,
+        ),
         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() {
-        if let Some(joint) = context.impulse_joints.get_mut(handle.0) {
+    for (handle, changed_joint, world_within) in changed_impulse_joints.iter() {
+        let world = get_world(world_within, &mut context);
+
+        if let Some(joint) = world.impulse_joints.get_mut(handle.0) {
             joint.data = changed_joint.data.into_rapier();
         }
     }
 
-    for (handle, changed_joint) in changed_multibody_joints.iter() {
+    for (handle, changed_joint, world_within) in changed_multibody_joints.iter() {
+        let world = get_world(world_within, &mut context);
+
         // 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((mb, link_id)) = world.multibody_joints.get_mut(handle.0) {
             if let Some(link) = mb.link_mut(link_id) {
                 link.joint.data = changed_joint.data.into_rapier();
             }
diff --git a/src/plugin/systems/mod.rs b/src/plugin/systems/mod.rs
index ca4358ec..adc8687b 100644
--- a/src/plugin/systems/mod.rs
+++ b/src/plugin/systems/mod.rs
@@ -5,6 +5,7 @@ mod collider;
 mod joint;
 mod remove;
 mod rigid_body;
+mod worlds;
 mod writeback;
 
 pub use character_controller::*;
@@ -12,6 +13,7 @@ pub use collider::*;
 pub use joint::*;
 pub use remove::*;
 pub use rigid_body::*;
+pub use worlds::*;
 pub use writeback::*;
 
 use crate::dynamics::{RapierRigidBodyHandle, TransformInterpolation};
@@ -24,39 +26,44 @@ use bevy::prelude::*;
 
 /// System responsible for advancing the physics simulation, and updating the internal state
 /// for scene queries.
+#[allow(clippy::too_many_arguments)]
 pub fn step_simulation<Hooks>(
     mut context: ResMut<RapierContext>,
     config: Res<RapierConfiguration>,
     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_event_writer: EventWriter<CollisionEvent>,
+    mut contact_force_event_writer: 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),
-        );
-        context.deleted_colliders.clear();
-    } else {
-        context.propagate_modified_body_positions_to_colliders();
-    }
+    for (world_id, world) in context.worlds.iter_mut() {
+        if config.physics_pipeline_active {
+            world.step_simulation(
+                *world_id,
+                config.timestep_mode,
+                true,
+                &hooks_adapter,
+                &time,
+                &mut sim_to_render_time,
+                &mut Some(&mut interpolation_query),
+            );
 
-    if config.query_pipeline_active {
-        context.update_query_pipeline();
+            world.deleted_colliders.clear();
+
+            world.send_bevy_events(&mut collision_event_writer, &mut contact_force_event_writer);
+        } else {
+            world.propagate_modified_body_positions_to_colliders();
+        }
+
+        if config.query_pipeline_active {
+            world.update_query_pipeline();
+        }
     }
 }
 
@@ -78,7 +85,7 @@ mod tests {
 
     use super::*;
     use crate::{
-        plugin::{NoUserData, RapierPhysicsPlugin},
+        plugin::{NoUserData, RapierPhysicsPlugin, DEFAULT_WORLD_ID},
         prelude::{Collider, CollidingEntities, RigidBody},
         utils,
     };
@@ -100,6 +107,7 @@ mod tests {
             entity1,
             entity2,
             CollisionEventFlags::SENSOR,
+            DEFAULT_WORLD_ID,
         ));
 
         app.update();
@@ -144,6 +152,7 @@ mod tests {
             entity1,
             entity2,
             CollisionEventFlags::SENSOR,
+            DEFAULT_WORLD_ID,
         ));
 
         app.update();
@@ -214,8 +223,12 @@ mod tests {
 
             let child_transform = app.world.entity(child).get::<GlobalTransform>().unwrap();
             let context = app.world.resource::<RapierContext>();
-            let child_handle = context.entity2body[&child];
-            let child_body = context.bodies.get(child_handle).unwrap();
+            let world = context
+                .get_world(DEFAULT_WORLD_ID)
+                .expect("The default world should exist.");
+
+            let child_handle = world.entity2body[&child];
+            let child_body = world.bodies.get(child_handle).unwrap();
             let body_transform = utils::iso_to_transform(child_body.position());
             assert_eq!(
                 GlobalTransform::from(body_transform),
@@ -276,10 +289,14 @@ mod tests {
                 .unwrap()
                 .compute_transform();
             let context = app.world.resource::<RapierContext>();
-            let parent_handle = context.entity2body[&parent];
-            let parent_body = context.bodies.get(parent_handle).unwrap();
+            let world = context
+                .get_world(DEFAULT_WORLD_ID)
+                .expect("The default world should exist.");
+
+            let parent_handle = world.entity2body[&parent];
+            let parent_body = world.bodies.get(parent_handle).unwrap();
             let child_collider_handle = parent_body.colliders()[0];
-            let child_collider = context.colliders.get(child_collider_handle).unwrap();
+            let child_collider = world.colliders.get(child_collider_handle).unwrap();
             let body_transform = utils::iso_to_transform(child_collider.position());
             approx::assert_relative_eq!(
                 body_transform.translation,
@@ -312,7 +329,7 @@ mod tests {
             app.add_plugins((
                 WindowPlugin::default(),
                 AssetPlugin::default(),
-                ScenePlugin::default(),
+                ScenePlugin,
                 RenderPlugin {
                     render_creation: RenderCreation::Automatic(WgpuSettings {
                         backends: None,
diff --git a/src/plugin/systems/remove.rs b/src/plugin/systems/remove.rs
index 69933986..4fafa7a8 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::find_item_and_world;
 use crate::plugin::RapierContext;
 use crate::prelude::MassModifiedEvent;
 use crate::prelude::RigidBodyDisabled;
@@ -40,31 +41,33 @@ 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(
+        if let Some((world, handle)) =
+            find_item_and_world(&mut context, |world| world.entity2body.remove(&entity))
+        {
+            let _ = world.last_body_transform_set.remove(&handle);
+            world.bodies.remove(
                 handle,
-                &mut context.islands,
-                &mut context.colliders,
-                &mut context.impulse_joints,
-                &mut context.multibody_joints,
+                &mut world.islands,
+                &mut world.colliders,
+                &mut world.impulse_joints,
+                &mut world.multibody_joints,
                 false,
             );
         }
     }
 
-    let context = &mut *context;
     for entity in orphan_bodies.iter() {
-        if let Some(handle) = context.entity2body.remove(&entity) {
-            let _ = context.last_body_transform_set.remove(&handle);
-            context.bodies.remove(
+        if let Some((world, handle)) =
+            find_item_and_world(&mut context, |world| world.entity2body.remove(&entity))
+        {
+            let _ = world.last_body_transform_set.remove(&handle);
+            world.bodies.remove(
                 handle,
-                &mut context.islands,
-                &mut context.colliders,
-                &mut context.impulse_joints,
-                &mut context.multibody_joints,
+                &mut world.islands,
+                &mut world.colliders,
+                &mut world.impulse_joints,
+                &mut world.multibody_joints,
                 false,
             );
         }
@@ -75,28 +78,32 @@ pub fn sync_removals(
      * Collider removal detection.
      */
     for entity in removed_colliders.read() {
-        if let Some(parent) = context.collider_parent(entity) {
-            mass_modified.send(parent.into());
-        }
+        if let Some((world, handle)) =
+            find_item_and_world(&mut context, |world| world.entity2collider.remove(&entity))
+        {
+            if let Some(parent) = world.collider_parent(entity) {
+                mass_modified.send(parent.into());
+            }
 
-        if let Some(handle) = context.entity2collider.remove(&entity) {
-            context
+            world
                 .colliders
-                .remove(handle, &mut context.islands, &mut context.bodies, true);
-            context.deleted_colliders.insert(handle, entity);
+                .remove(handle, &mut world.islands, &mut world.bodies, true);
+            world.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((world, handle)) =
+            find_item_and_world(&mut context, |world| world.entity2collider.remove(&entity))
+        {
+            if let Some(parent) = world.collider_parent(entity) {
+                mass_modified.send(parent.into());
+            }
 
-        if let Some(handle) = context.entity2collider.remove(&entity) {
-            context
+            world
                 .colliders
-                .remove(handle, &mut context.islands, &mut context.bodies, true);
-            context.deleted_colliders.insert(handle, entity);
+                .remove(handle, &mut world.islands, &mut world.bodies, true);
+            world.deleted_colliders.insert(handle, entity);
         }
         commands.entity(entity).remove::<RapierColliderHandle>();
     }
@@ -105,14 +112,18 @@ 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);
+        if let Some((world, handle)) = find_item_and_world(&mut context, |world| {
+            world.entity2impulse_joint.remove(&entity)
+        }) {
+            world.impulse_joints.remove(handle, true);
         }
     }
 
     for entity in orphan_impulse_joints.iter() {
-        if let Some(handle) = context.entity2impulse_joint.remove(&entity) {
-            context.impulse_joints.remove(handle, true);
+        if let Some((world, handle)) = find_item_and_world(&mut context, |world| {
+            world.entity2impulse_joint.remove(&entity)
+        }) {
+            world.impulse_joints.remove(handle, true);
         }
         commands.entity(entity).remove::<RapierImpulseJointHandle>();
     }
@@ -121,14 +132,18 @@ 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);
+        if let Some((world, handle)) = find_item_and_world(&mut context, |world| {
+            world.entity2multibody_joint.remove(&entity)
+        }) {
+            world.multibody_joints.remove(handle, true);
         }
     }
 
     for entity in orphan_multibody_joints.iter() {
-        if let Some(handle) = context.entity2multibody_joint.remove(&entity) {
-            context.multibody_joints.remove(handle, true);
+        if let Some((world, handle)) = find_item_and_world(&mut context, |world| {
+            world.entity2multibody_joint.remove(&entity)
+        }) {
+            world.multibody_joints.remove(handle, true);
         }
         commands
             .entity(entity)
@@ -139,24 +154,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((world, handle)) = find_item_and_world(&mut context, |world| {
+            world.entity2collider.get(&entity).copied()
+        }) {
+            if let Some(co) = world.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((world, handle)) = find_item_and_world(&mut context, |world| {
+            world.entity2collider.get(&entity).copied()
+        }) {
+            if let Some(co) = world.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((world, handle)) = find_item_and_world(&mut context, |world| {
+            world.entity2body.get(&entity).copied()
+        }) {
+            if let Some(rb) = world.bodies.get_mut(handle) {
                 rb.set_enabled(true);
             }
         }
diff --git a/src/plugin/systems/rigid_body.rs b/src/plugin/systems/rigid_body.rs
index 478ccc10..51705c55 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::get_world;
 use crate::plugin::{configuration::TimestepMode, RapierConfiguration, RapierContext};
 use crate::{dynamics::RigidBody, plugin::configuration::SimulationToRenderTime};
 use crate::{prelude::*, utils};
@@ -9,11 +10,12 @@ use std::collections::HashMap;
 /// Components that will be updated after a physics step.
 pub type RigidBodyWritebackComponents<'a> = (
     Entity,
-    Option<&'a Parent>,
     Option<&'a mut Transform>,
     Option<&'a mut TransformInterpolation>,
     Option<&'a mut Velocity>,
     Option<&'a mut Sleeping>,
+    Option<&'a PhysicsWorld>,
+    Option<&'a RigidBody>,
 );
 
 /// Components related to rigid-bodies.
@@ -30,58 +32,111 @@ pub type RigidBodyComponents<'a> = (
     (Option<&'a Ccd>, Option<&'a SoftCcd>),
     Option<&'a Dominance>,
     Option<&'a Sleeping>,
-    Option<&'a Damping>,
-    Option<&'a RigidBodyDisabled>,
-    Option<&'a AdditionalSolverIterations>,
+    (
+        Option<&'a Damping>,
+        Option<&'a RigidBodyDisabled>,
+        Option<&'a PhysicsWorld>,
+        Option<&'a AdditionalSolverIterations>,
+    ),
 );
 
 /// 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>>,
+    changed_rb_types: Query<
+        (&RapierRigidBodyHandle, &RigidBody, Option<&PhysicsWorld>),
+        Changed<RigidBody>,
+    >,
     mut changed_transforms: Query<
         (
             &RapierRigidBodyHandle,
             &GlobalTransform,
             Option<&mut TransformInterpolation>,
+            Option<&PhysicsWorld>,
         ),
         Changed<GlobalTransform>,
     >,
-    changed_velocities: Query<(&RapierRigidBodyHandle, &Velocity), Changed<Velocity>>,
+    changed_velocities: Query<
+        (&RapierRigidBodyHandle, &Velocity, Option<&PhysicsWorld>),
+        Changed<Velocity>,
+    >,
     changed_additional_mass_props: Query<
-        (Entity, &RapierRigidBodyHandle, &AdditionalMassProperties),
+        (
+            Entity,
+            &RapierRigidBodyHandle,
+            &AdditionalMassProperties,
+            Option<&PhysicsWorld>,
+        ),
         Changed<AdditionalMassProperties>,
     >,
-    changed_locked_axes: Query<(&RapierRigidBodyHandle, &LockedAxes), Changed<LockedAxes>>,
-    changed_forces: Query<(&RapierRigidBodyHandle, &ExternalForce), Changed<ExternalForce>>,
+    changed_locked_axes: Query<
+        (&RapierRigidBodyHandle, &LockedAxes, Option<&PhysicsWorld>),
+        Changed<LockedAxes>,
+    >,
+    changed_forces: Query<
+        (
+            &RapierRigidBodyHandle,
+            &ExternalForce,
+            Option<&PhysicsWorld>,
+        ),
+        Changed<ExternalForce>,
+    >,
     mut changed_impulses: Query<
-        (&RapierRigidBodyHandle, &mut ExternalImpulse),
+        (
+            &RapierRigidBodyHandle,
+            &mut ExternalImpulse,
+            Option<&PhysicsWorld>,
+        ),
         Changed<ExternalImpulse>,
     >,
-    changed_gravity_scale: Query<(&RapierRigidBodyHandle, &GravityScale), Changed<GravityScale>>,
+    changed_gravity_scale: Query<
+        (&RapierRigidBodyHandle, &GravityScale, Option<&PhysicsWorld>),
+        Changed<GravityScale>,
+    >,
     (changed_ccd, changed_soft_ccd): (
-        Query<(&RapierRigidBodyHandle, &Ccd), Changed<Ccd>>,
-        Query<(&RapierRigidBodyHandle, &SoftCcd), Changed<SoftCcd>>,
+        Query<(&RapierRigidBodyHandle, &Ccd, Option<&PhysicsWorld>), Changed<Ccd>>,
+        Query<(&RapierRigidBodyHandle, &SoftCcd, Option<&PhysicsWorld>), 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, &Dominance, Option<&PhysicsWorld>),
+        Changed<Dominance>,
+    >,
+    changed_sleeping: Query<
+        (&RapierRigidBodyHandle, &Sleeping, Option<&PhysicsWorld>),
+        Changed<Sleeping>,
+    >,
+    changed_damping: Query<
+        (&RapierRigidBodyHandle, &Damping, Option<&PhysicsWorld>),
+        Changed<Damping>,
+    >,
     (changed_disabled, changed_additional_solver_iterations): (
-        Query<(&RapierRigidBodyHandle, &RigidBodyDisabled), Changed<RigidBodyDisabled>>,
         Query<
-            (&RapierRigidBodyHandle, &AdditionalSolverIterations),
+            (
+                &RapierRigidBodyHandle,
+                &RigidBodyDisabled,
+                Option<&PhysicsWorld>,
+            ),
+            Changed<RigidBodyDisabled>,
+        >,
+        Query<
+            (
+                &RapierRigidBodyHandle,
+                &AdditionalSolverIterations,
+                Option<&PhysicsWorld>,
+            ),
             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() {
-        if let Some(rb) = context.bodies.get_mut(handle.0) {
+    for (handle, sleeping, world_within) in changed_sleeping.iter() {
+        let world = get_world(world_within, &mut context);
+
+        if let Some(rb) = world.bodies.get_mut(handle.0) {
             let activation = rb.activation_mut();
             activation.normalized_linear_threshold = sleeping.normalized_linear_threshold;
             activation.angular_threshold = sleeping.angular_threshold;
@@ -100,8 +155,10 @@ 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() {
-        if let Some(rb) = context.bodies.get_mut(handle.0) {
+    for (handle, rb_type, world_within) in changed_rb_types.iter() {
+        let world = get_world(world_within, &mut context);
+
+        if let Some(rb) = world.bodies.get_mut(handle.0) {
             rb.set_body_type((*rb_type).into(), true);
         }
     }
@@ -123,7 +180,10 @@ pub fn apply_rigid_body_user_changes(
             }
         };
 
-    for (handle, global_transform, mut interpolation) in changed_transforms.iter_mut() {
+    for (handle, global_transform, mut interpolation, world_within) in changed_transforms.iter_mut()
+    {
+        let world = get_world(world_within, &mut context);
+
         // Use an Option<bool> to avoid running the check twice.
         let mut transform_changed = None;
 
@@ -132,7 +192,7 @@ pub fn apply_rigid_body_user_changes(
                 Some(transform_changed_fn(
                     &handle.0,
                     global_transform,
-                    &context.last_body_transform_set,
+                    &world.last_body_transform_set,
                 ))
             });
 
@@ -144,33 +204,31 @@ pub fn apply_rigid_body_user_changes(
             }
         }
 
-        if let Some(rb) = context.bodies.get_mut(handle.0) {
+        if let Some(rb) = world.bodies.get_mut(handle.0) {
             transform_changed = transform_changed.or_else(|| {
                 Some(transform_changed_fn(
                     &handle.0,
                     global_transform,
-                    &context.last_body_transform_set,
+                    &world.last_body_transform_set,
                 ))
             });
 
-            match rb.body_type() {
-                RigidBodyType::KinematicPositionBased => {
-                    if transform_changed == Some(true) {
+            if transform_changed == Some(true) {
+                match rb.body_type() {
+                    RigidBodyType::KinematicPositionBased => {
                         rb.set_next_kinematic_position(utils::transform_to_iso(
                             &global_transform.compute_transform(),
                         ));
-                        context
+                        world
                             .last_body_transform_set
                             .insert(handle.0, *global_transform);
                     }
-                }
-                _ => {
-                    if transform_changed == Some(true) {
+                    _ => {
                         rb.set_position(
                             utils::transform_to_iso(&global_transform.compute_transform()),
                             true,
                         );
-                        context
+                        world
                             .last_body_transform_set
                             .insert(handle.0, *global_transform);
                     }
@@ -179,16 +237,38 @@ pub fn apply_rigid_body_user_changes(
         }
     }
 
-    for (handle, velocity) in changed_velocities.iter() {
-        if let Some(rb) = context.bodies.get_mut(handle.0) {
-            rb.set_linvel(velocity.linvel.into(), true);
+    for (handle, velocity, world_within) in changed_velocities.iter() {
+        let world = get_world(world_within, &mut context);
+
+        // get here instead of get_mut to avoid change detection if it doesn't need to be changed
+        if let Some(rb) = world.bodies.get(handle.0) {
+            let new_linvel = velocity.linvel.into();
             #[allow(clippy::useless_conversion)] // Need to convert if dim3 enabled
-            rb.set_angvel(velocity.angvel.into(), true);
+            let new_angvel = velocity.angvel.into();
+
+            #[cfg(feature = "dim3")]
+            let cur_angvel = *rb.angvel();
+            #[cfg(feature = "dim2")]
+            let cur_angvel = rb.angvel();
+
+            let is_different = *rb.linvel() != new_linvel || cur_angvel != new_angvel;
+
+            if is_different {
+                let rb = world
+                    .bodies
+                    .get_mut(handle.0)
+                    .expect("Verified to exist in above world.bodies.get");
+
+                rb.set_linvel(new_linvel, true);
+                rb.set_angvel(new_angvel, true);
+            }
         }
     }
 
-    for (entity, handle, mprops) in changed_additional_mass_props.iter() {
-        if let Some(rb) = context.bodies.get_mut(handle.0) {
+    for (entity, handle, mprops, world_within) in changed_additional_mass_props.iter() {
+        let world = get_world(world_within, &mut context);
+
+        if let Some(rb) = world.bodies.get_mut(handle.0) {
             match mprops {
                 AdditionalMassProperties::MassProperties(mprops) => {
                     rb.set_additional_mass_properties(mprops.into_rapier(), true);
@@ -202,20 +282,28 @@ pub fn apply_rigid_body_user_changes(
         }
     }
 
-    for (handle, additional_solver_iters) in changed_additional_solver_iterations.iter() {
-        if let Some(rb) = context.bodies.get_mut(handle.0) {
+    for (handle, additional_solver_iters, world_within) in
+        changed_additional_solver_iterations.iter()
+    {
+        let world = get_world(world_within, &mut context);
+
+        if let Some(rb) = world.bodies.get_mut(handle.0) {
             rb.set_additional_solver_iterations(additional_solver_iters.0);
         }
     }
 
-    for (handle, locked_axes) in changed_locked_axes.iter() {
-        if let Some(rb) = context.bodies.get_mut(handle.0) {
+    for (handle, locked_axes, world_within) in changed_locked_axes.iter() {
+        let world = get_world(world_within, &mut context);
+
+        if let Some(rb) = world.bodies.get_mut(handle.0) {
             rb.set_locked_axes((*locked_axes).into(), true);
         }
     }
 
-    for (handle, forces) in changed_forces.iter() {
-        if let Some(rb) = context.bodies.get_mut(handle.0) {
+    for (handle, forces, world_within) in changed_forces.iter() {
+        let world = get_world(world_within, &mut context);
+
+        if let Some(rb) = world.bodies.get_mut(handle.0) {
             rb.reset_forces(true);
             rb.reset_torques(true);
             rb.add_force(forces.force.into(), true);
@@ -224,8 +312,10 @@ pub fn apply_rigid_body_user_changes(
         }
     }
 
-    for (handle, mut impulses) in changed_impulses.iter_mut() {
-        if let Some(rb) = context.bodies.get_mut(handle.0) {
+    for (handle, mut impulses, world_within) in changed_impulses.iter_mut() {
+        let world = get_world(world_within, &mut context);
+
+        if let Some(rb) = world.bodies.get_mut(handle.0) {
             rb.apply_impulse(impulses.impulse.into(), true);
             #[allow(clippy::useless_conversion)] // Need to convert if dim3 enabled
             rb.apply_torque_impulse(impulses.torque_impulse.into(), true);
@@ -233,39 +323,51 @@ pub fn apply_rigid_body_user_changes(
         }
     }
 
-    for (handle, gravity_scale) in changed_gravity_scale.iter() {
-        if let Some(rb) = context.bodies.get_mut(handle.0) {
+    for (handle, gravity_scale, world_within) in changed_gravity_scale.iter() {
+        let world = get_world(world_within, &mut context);
+
+        if let Some(rb) = world.bodies.get_mut(handle.0) {
             rb.set_gravity_scale(gravity_scale.0, true);
         }
     }
 
-    for (handle, ccd) in changed_ccd.iter() {
-        if let Some(rb) = context.bodies.get_mut(handle.0) {
+    for (handle, ccd, world_within) in changed_ccd.iter() {
+        let world = get_world(world_within, &mut context);
+
+        if let Some(rb) = world.bodies.get_mut(handle.0) {
             rb.enable_ccd(ccd.enabled);
         }
     }
 
-    for (handle, soft_ccd) in changed_soft_ccd.iter() {
-        if let Some(rb) = context.bodies.get_mut(handle.0) {
+    for (handle, soft_ccd, world_within) in changed_soft_ccd.iter() {
+        let world = get_world(world_within, &mut context);
+
+        if let Some(rb) = world.bodies.get_mut(handle.0) {
             rb.set_soft_ccd_prediction(soft_ccd.prediction);
         }
     }
 
-    for (handle, dominance) in changed_dominance.iter() {
-        if let Some(rb) = context.bodies.get_mut(handle.0) {
+    for (handle, dominance, world_within) in changed_dominance.iter() {
+        let world = get_world(world_within, &mut context);
+
+        if let Some(rb) = world.bodies.get_mut(handle.0) {
             rb.set_dominance_group(dominance.groups);
         }
     }
 
-    for (handle, damping) in changed_damping.iter() {
-        if let Some(rb) = context.bodies.get_mut(handle.0) {
+    for (handle, damping, world_within) in changed_damping.iter() {
+        let world = get_world(world_within, &mut context);
+
+        if let Some(rb) = world.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() {
-        if let Some(co) = context.bodies.get_mut(handle.0) {
+    for (handle, _, world_within) in changed_disabled.iter() {
+        let world = get_world(world_within, &mut context);
+
+        if let Some(co) = world.bodies.get_mut(handle.0) {
             co.set_enabled(false);
         }
     }
@@ -277,23 +379,37 @@ pub fn writeback_rigid_bodies(
     mut context: ResMut<RapierContext>,
     config: Res<RapierConfiguration>,
     sim_to_render_time: Res<SimulationToRenderTime>,
-    global_transforms: Query<&GlobalTransform>,
-    mut writeback: Query<
-        RigidBodyWritebackComponents,
-        (With<RigidBody>, Without<RigidBodyDisabled>),
-    >,
+    top_entities: Query<Entity, Without<Parent>>,
+    mut writeback: Query<RigidBodyWritebackComponents, Without<RigidBodyDisabled>>,
+    children_query: Query<&Children>,
 ) {
-    let context = &mut *context;
+    if !config.physics_pipeline_active {
+        return;
+    }
 
-    if config.physics_pipeline_active {
-        for (entity, parent, transform, mut interpolation, mut velocity, mut sleeping) in
-            writeback.iter_mut()
+    for entity in top_entities.iter() {
+        let (transform, delta_transform, velocity, world_offset) = if let Ok((
+            entity,
+            transform,
+            mut interpolation,
+            mut velocity,
+            mut sleeping,
+            world_within,
+            _,
+        )) = writeback.get_mut(entity)
         {
+            let mut my_new_global_transform = Transform::IDENTITY;
+            let mut parent_delta = Transform::IDENTITY;
+            let mut my_velocity = Velocity::default();
+            let mut world_offset = Vec3::ZERO;
+
+            let world = get_world(world_within, &mut context);
+
             // 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(handle) = context.entity2body.get(&entity).copied() {
-                if let Some(rb) = context.bodies.get(handle) {
+            if let Some(handle) = world.entity2body.get(&entity).copied() {
+                if let Some(rb) = world.bodies.get(handle) {
                     let mut interpolated_pos = utils::iso_to_transform(rb.position());
 
                     if let TimestepMode::Interpolated { dt, .. } = config.timestep_mode {
@@ -316,82 +432,258 @@ pub fn writeback_rigid_bodies(
                         //       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())
+                        world_offset = transform.translation;
+
+                        // let (cur_inv_scale, cur_inv_rotation, cur_inv_translation) = transform
+                        //     .compute_affine()
+                        //     .inverse()
+                        //     .to_scale_rotation_translation();
+
+                        parent_delta = Transform {
+                            translation: interpolated_pos.translation - transform.translation,
+                            rotation: interpolated_pos.rotation * transform.rotation.inverse(),
+                            scale: transform.scale,
+                        };
+
+                        let com = rb.center_of_mass();
+
+                        #[cfg(feature = "dim3")]
+                        let com = Vec3::new(
+                            com.x - rb.translation().x,
+                            com.y - rb.translation().y,
+                            com.z - rb.translation().z,
+                        );
+                        #[cfg(feature = "dim2")]
+                        let com =
+                            Vec3::new(com.x - rb.translation().x, com.y - rb.translation().y, 0.0);
+
+                        let com_diff = com - parent_delta.rotation.mul_vec3(com);
+                        parent_delta.translation -= com_diff;
+
+                        #[allow(unused_mut)] // mut is needed in 2D but not in 3D.
+                        let mut new_translation = interpolated_pos.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;
-                            }
+                            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;
-                            }
+                        if transform.rotation != interpolated_pos.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 = interpolated_pos.rotation;
+                            transform.translation = new_translation;
+                        }
+
+                        my_new_global_transform = interpolated_pos;
+
+                        world.last_body_transform_set.insert(
+                            handle,
+                            GlobalTransform::from(
+                                Transform::from_translation(new_translation)
+                                    .with_rotation(interpolated_pos.rotation),
+                            ),
+                        );
+                    }
 
-                            // 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
+                    if let Some(velocity) = &mut velocity {
+                        my_velocity = **velocity;
+
+                        let new_vel = Velocity {
+                            linvel: (*rb.linvel()).into(),
+                            #[cfg(feature = "dim3")]
+                            angvel: (*rb.angvel()).into(),
                             #[cfg(feature = "dim2")]
-                            {
-                                interpolated_pos.translation.z = transform.translation.z;
+                            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();
+                        }
+                    }
+                }
+            }
+
+            (
+                my_new_global_transform,
+                parent_delta,
+                my_velocity,
+                world_offset,
+            )
+        } else {
+            (
+                Transform::IDENTITY,
+                Transform::IDENTITY,
+                Velocity::default(),
+                Vec3::ZERO,
+            )
+        };
+
+        recurse_child_transforms(
+            context.as_mut(),
+            &config,
+            &sim_to_render_time,
+            &mut writeback,
+            transform,
+            delta_transform,
+            velocity,
+            &children_query,
+            entity,
+            world_offset,
+        );
+    }
+}
+
+fn recurse_child_transforms(
+    context: &mut RapierContext,
+    config: &RapierConfiguration,
+    sim_to_render_time: &SimulationToRenderTime,
+    writeback: &mut Query<RigidBodyWritebackComponents, Without<RigidBodyDisabled>>,
+    parent_global_transform: Transform,
+    parent_delta: Transform,
+    parent_velocity: Velocity,
+    children_query: &Query<&Children>,
+    parent_entity: Entity,
+    world_offset: Vec3,
+) {
+    let Ok(children) = children_query.get(parent_entity) else {
+        return;
+    };
+
+    for child in children.iter().copied() {
+        let mut world_offset = world_offset;
+
+        let (transform, delta_transform, velocity) = if let Ok((
+            entity,
+            transform,
+            mut interpolation,
+            mut velocity,
+            mut sleeping,
+            world_within,
+            rb_type,
+        )) = writeback.get_mut(child)
+        {
+            let mut my_new_global_transform = parent_global_transform;
+            let mut delta_transform = parent_delta;
+            let mut my_velocity = parent_velocity;
+
+            let world = get_world(world_within, context);
+
+            // 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(handle) = world.entity2body.get(&entity).copied() {
+                if let Some(rb) = world.bodies.get_mut(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 transform.rotation != interpolated_pos.rotation
-                                || transform.translation != interpolated_pos.translation
+                            if let Some(interpolated) =
+                                interpolation.lerp_slerp((dt + sim_to_render_time.diff) / dt)
                             {
-                                // 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;
+                                interpolated_pos = utils::iso_to_transform(&interpolated);
                             }
+                        }
+                    }
+
+                    if let Some(mut transform) = transform {
+                        // We need to compute the new local transform such that:
+                        // curr_parent_global_transform * new_transform * parent_delta_pos = interpolated_pos
+                        // new_transform = curr_parent_global_transform.inverse() * interpolated_pos
+                        interpolated_pos = interpolated_pos.with_scale(transform.scale);
+
+                        let inverse_parent_rotation = parent_global_transform.rotation.inverse();
+
+                        interpolated_pos.translation -= world_offset;
+
+                        let new_rotation = Quat::IDENTITY; //inverse_parent_rotation * interpolated_pos.rotation;
 
-                            context
-                                .last_body_transform_set
-                                .insert(handle, GlobalTransform::from(interpolated_pos));
+                        // has to be mut in 2d mode
+                        #[allow(unused_mut)]
+                        let mut new_translation;
+
+                        let translation_offset =
+                            if rb_type.copied().unwrap_or(RigidBody::Fixed) == RigidBody::Dynamic {
+                                // The parent's velocity will have already moved them
+                                parent_delta.translation
+                            } else {
+                                Vec3::ZERO
+                            };
+
+                        let rotated_interpolation = inverse_parent_rotation
+                            * (parent_delta.rotation
+                                * (interpolated_pos.translation - translation_offset));
+
+                        new_translation = rotated_interpolation;
+
+                        // In 2D, preserve the transform `z` component that may have been set by the user
+                        #[cfg(feature = "dim2")]
+                        {
+                            new_translation.z = transform.translation.z;
                         }
+
+                        let old_transform = *transform;
+
+                        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;
+                        }
+
+                        let inv_old_transform = Transform {
+                            scale: old_transform.scale,
+                            rotation: old_transform.rotation.inverse(),
+                            translation: -old_transform.translation,
+                        };
+
+                        delta_transform = transform.mul_transform(inv_old_transform);
+
+                        // 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.
+
+                        my_new_global_transform = parent_global_transform.mul_transform(*transform);
+                        world_offset = my_new_global_transform.translation;
+
+                        world
+                            .last_body_transform_set
+                            .insert(handle, GlobalTransform::from(my_new_global_transform));
+
+                        rb.set_position(utils::transform_to_iso(&my_new_global_transform), false);
                     }
 
                     if let Some(velocity) = &mut velocity {
+                        let old_linvel = *rb.linvel();
+
+                        my_velocity.linvel = old_linvel.into();
+
+                        rb.set_linvel(parent_velocity.linvel.into(), false);
+                        rb.set_linvel(old_linvel - rb.linvel(), false);
+
                         let new_vel = Velocity {
                             linvel: (*rb.linvel()).into(),
                             #[cfg(feature = "dim3")]
@@ -418,6 +710,88 @@ pub fn writeback_rigid_bodies(
                     }
                 }
             }
+
+            (my_new_global_transform, delta_transform, my_velocity)
+        } else {
+            (parent_global_transform, parent_delta, parent_velocity)
+        };
+
+        recurse_child_transforms(
+            context,
+            config,
+            sim_to_render_time,
+            writeback,
+            transform,
+            delta_transform,
+            velocity,
+            children_query,
+            child,
+            world_offset,
+        );
+    }
+}
+
+/// Syncs up child velocities with their parents in the physics simulation.
+/// This is done to avoid child components getting hit by their parent and rapier
+/// assuming the child is hit by the full velocity of the parent instead of `parent vel - child vel`.
+///
+/// This will not change the bevy component's velocity.
+pub fn sync_vel(
+    top_ents: Query<Entity, Without<Parent>>,
+    vel_query: Query<&Velocity>,
+    query: Query<(&RapierRigidBodyHandle, Option<&PhysicsWorld>)>,
+    children_query: Query<&Children>,
+    mut context: ResMut<RapierContext>,
+) {
+    for ent in top_ents.iter() {
+        let vel = if let Ok(velocity) = vel_query.get(ent) {
+            *velocity
+        } else {
+            Velocity::default()
+        };
+
+        if let Ok(children) = children_query.get(ent) {
+            for child in children.iter().copied() {
+                sync_velocity_recursively(child, &query, &children_query, vel, &mut context);
+            }
+        }
+    }
+}
+
+fn sync_velocity_recursively(
+    ent: Entity,
+    query: &Query<(&RapierRigidBodyHandle, Option<&PhysicsWorld>)>,
+    children_query: &Query<&Children>,
+    parent_vel: Velocity,
+    context: &mut RapierContext,
+) {
+    let vel = if let Ok((handle, world_within)) = query.get(ent) {
+        let world = get_world(world_within, context);
+        if let Some(rb) = world.bodies.get_mut(handle.0) {
+            #[cfg(feature = "dim3")]
+            let old_linvel = Vec3::from(*rb.linvel());
+            #[cfg(feature = "dim2")]
+            let old_linvel = Vec2::from(*rb.linvel());
+
+            rb.set_linvel((old_linvel + (parent_vel.linvel)).into(), false);
+
+            Velocity {
+                linvel: (*rb.linvel()).into(),
+                #[cfg(feature = "dim3")]
+                angvel: (*rb.angvel()).into(),
+                #[cfg(feature = "dim2")]
+                angvel: rb.angvel(),
+            }
+        } else {
+            parent_vel
+        }
+    } else {
+        parent_vel
+    };
+
+    if let Ok(children) = children_query.get(ent) {
+        for child in children.iter().copied() {
+            sync_velocity_recursively(child, query, children_query, vel, context);
         }
     }
 }
@@ -441,11 +815,11 @@ pub fn init_rigid_bodies(
         (ccd, soft_ccd),
         dominance,
         sleep,
-        damping,
-        disabled,
-        additional_solver_iters,
+        (damping, disabled, world_within, additional_solver_iters),
     ) in rigid_bodies.iter()
     {
+        let world = get_world(world_within, &mut context);
+
         let mut builder = RigidBodyBuilder::new((*rb).into());
         builder = builder.enabled(disabled.is_none());
 
@@ -521,14 +895,15 @@ pub fn init_rigid_bodies(
             activation.angular_threshold = sleep.angular_threshold;
         }
 
-        let handle = context.bodies.insert(rb);
+        let handle = world.bodies.insert(rb);
         commands
             .entity(entity)
             .insert(RapierRigidBodyHandle(handle));
-        context.entity2body.insert(entity, handle);
+
+        world.entity2body.insert(entity, handle);
 
         if let Some(transform) = transform {
-            context.last_body_transform_set.insert(handle, *transform);
+            world.last_body_transform_set.insert(handle, *transform);
         }
     }
 }
@@ -542,19 +917,22 @@ pub fn apply_initial_rigid_body_impulses(
     mut context: ResMut<RapierContext>,
     // 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, &mut ExternalImpulse, Option<&PhysicsWorld>),
+        Without<RapierRigidBodyHandle>,
+    >,
 ) {
-    let context = &mut *context;
+    for (entity, mut impulse, world_within) in init_impulses.iter_mut() {
+        let world = get_world(world_within, &mut context);
 
-    for (entity, mut impulse) in init_impulses.iter_mut() {
-        let bodies = &mut context.bodies;
-        if let Some(rb) = context
+        let bodies = &mut world.bodies;
+        if let Some(rb) = world
             .entity2body
             .get(&entity)
             .and_then(|h| bodies.get_mut(*h))
         {
             // Make sure the mass-properties are computed.
-            rb.recompute_mass_properties_from_colliders(&context.colliders);
+            rb.recompute_mass_properties_from_colliders(&world.colliders);
             // Apply the impulse.
             rb.apply_impulse(impulse.impulse.into(), false);
 
diff --git a/src/plugin/systems/worlds.rs b/src/plugin/systems/worlds.rs
new file mode 100644
index 00000000..d2a770ab
--- /dev/null
+++ b/src/plugin/systems/worlds.rs
@@ -0,0 +1,111 @@
+//! Systems responsible for interfacing our Bevy components with the Rapier physics engine.
+
+use crate::dynamics::{
+    RapierImpulseJointHandle, RapierMultibodyJointHandle, RapierRigidBodyHandle,
+};
+use crate::geometry::RapierColliderHandle;
+use crate::plugin::RapierContext;
+use crate::prelude::PhysicsWorld;
+use bevy::prelude::*;
+
+/// If an entity is turned into the child of something with a physics world, the child should become a part of that physics world
+///
+/// If this fails to happen, weirdness will ensue.
+pub fn on_add_entity_with_parent(
+    q_add_entity_without_parent: Query<(Entity, &Parent), Changed<Parent>>,
+    q_parent: Query<&Parent>,
+    q_physics_world: Query<&PhysicsWorld>,
+    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) {
+                commands.entity(ent).insert(*pw);
+                remove_old_physics(ent, &mut commands);
+                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, &PhysicsWorld), Changed<PhysicsWorld>>,
+    q_children: Query<&Children>,
+    q_physics_world: Query<&PhysicsWorld>,
+    context: Res<RapierContext>,
+    mut commands: Commands,
+) {
+    for (entity, new_physics_world) in &q_changed_worlds {
+        // Ensure the world actually changed before removing them from the world
+        if !context
+            .get_world(new_physics_world.world_id)
+            .map(|x| {
+                // They are already apart of this world if any of these are true
+                x.entity2impulse_joint.contains_key(&entity)
+                    || x.entity2multibody_joint.contains_key(&entity)
+                    || x.entity2collider.contains_key(&entity)
+                    || x.entity2body.contains_key(&entity)
+            })
+            .unwrap_or(false)
+        {
+            remove_old_physics(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: PhysicsWorld,
+    q_physics_world: &Query<&PhysicsWorld>,
+) {
+    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,
+        );
+    });
+}
diff --git a/src/plugin/systems/writeback.rs b/src/plugin/systems/writeback.rs
index d9c7ec8b..51a6a815 100644
--- a/src/plugin/systems/writeback.rs
+++ b/src/plugin/systems/writeback.rs
@@ -7,30 +7,37 @@ use bevy::prelude::*;
 
 /// System responsible for writing updated mass properties back into the [`ReadMassProperties`] component.
 pub fn writeback_mass_properties(
-    mut context: ResMut<RapierContext>,
+    context: Res<RapierContext>,
     config: Res<RapierConfiguration>,
 
     mut mass_props: Query<&mut ReadMassProperties>,
     mut mass_modified: EventReader<MassModifiedEvent>,
 ) {
-    let context = &mut *context;
+    if !config.physics_pipeline_active {
+        return;
+    }
 
-    if config.physics_pipeline_active {
+    for (_, world) in context.worlds.iter() {
         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) {
-                        let new_mass_props =
-                            MassProperties::from_rapier(rb.mass_properties().local_mprops);
+            let Some(handle) = world.entity2body.get(entity).copied() else {
+                continue;
+            };
+
+            let Some(rb) = world.bodies.get(handle) else {
+                continue;
+            };
+
+            let Ok(mut mass_props) = mass_props.get_mut(**entity) else {
+                continue;
+            };
+
+            let new_mass_props = MassProperties::from_rapier(rb.mass_properties().local_mprops);
 
-                        // NOTE: we write the new value only if there was an
-                        //       actual change, in order to not trigger bevy’s
-                        //       change tracking when the values didn’t change.
-                        if mass_props.get() != &new_mass_props {
-                            mass_props.set(new_mass_props);
-                        }
-                    }
-                }
+            // NOTE: we write the new value only if there was an
+            //       actual change, in order to not trigger bevy’s
+            //       change tracking when the values didn’t change.
+            if mass_props.get() != &new_mass_props {
+                mass_props.set(new_mass_props);
             }
         }
     }
diff --git a/src/render/mod.rs b/src/render/mod.rs
index a1f4c7a2..dc95eda8 100644
--- a/src/render/mod.rs
+++ b/src/render/mod.rs
@@ -1,3 +1,4 @@
+use crate::plugin::context::RapierWorld;
 use crate::plugin::RapierContext;
 use bevy::prelude::*;
 use bevy::transform::TransformSystem;
@@ -96,19 +97,24 @@ impl Plugin for RapierDebugRenderPlugin {
 
 struct BevyLinesRenderBackend<'world, 'state, 'a, 'b> {
     custom_colors: Query<'world, 'state, &'a ColliderDebugColor>,
-    context: &'b RapierContext,
+    world: Option<&'b RapierWorld>,
     gizmos: Gizmos<'world, 'state>,
 }
 
 impl<'world, 'state, 'a, 'b> BevyLinesRenderBackend<'world, 'state, 'a, 'b> {
     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| {
-                self.custom_colors
-                    .get(Entity::from_bits(co.user_data as u64))
-                    .map(|co| co.0)
-                    .ok()
-            }),
+            DebugRenderObject::Collider(h, ..) => self
+                .world
+                .expect("World not set before triggering debug render")
+                .colliders
+                .get(h)
+                .and_then(|co| {
+                    self.custom_colors
+                        .get(Entity::from_bits(co.user_data as u64))
+                        .map(|co| co.0)
+                        .ok()
+                }),
             _ => None,
         };
 
@@ -162,18 +168,22 @@ fn debug_render_scene(
 
     let mut backend = BevyLinesRenderBackend {
         custom_colors,
-        context: &rapier_context,
+        world: None,
         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;
+    for (_, world) in rapier_context.worlds.iter() {
+        backend.world = Some(world);
+
+        let unscaled_style = render_context.pipeline.style;
+        render_context.pipeline.render(
+            &mut backend,
+            &world.bodies,
+            &world.colliders,
+            &world.impulse_joints,
+            &world.multibody_joints,
+            &world.narrow_phase,
+        );
+        render_context.pipeline.style = unscaled_style;
+    }
 }