diff --git a/benches/Cargo.toml b/benches/Cargo.toml
index ea51487a66129..ca22ca2f3b835 100644
--- a/benches/Cargo.toml
+++ b/benches/Cargo.toml
@@ -1,19 +1,16 @@
 [package]
 name = "benches"
 version = "0.1.0"
-authors = ["Carter Anderson <mcanders1@gmail.com>"]
+authors = [
+    "Bevy Contributors <bevyengine@gmail.com>",
+    "Carter Anderson <mcanders1@gmail.com>",
+]
 edition = "2018"
 
 [dev-dependencies]
 criterion = "0.3"
 bevy = { path = "../" }
 
-[[bench]]
-name = "bench"
-path = "benches/bevy_ecs/bench.rs"
-harness = false
-required-features = ["macros"]
-
 [[bench]]
 name = "system_stage"
 path = "benches/bevy_ecs/stages.rs"
diff --git a/benches/benches/bevy_ecs/bench.rs b/benches/benches/bevy_ecs/bench.rs
deleted file mode 100644
index 2af2f4a320140..0000000000000
--- a/benches/benches/bevy_ecs/bench.rs
+++ /dev/null
@@ -1,94 +0,0 @@
-// Copyright 2019 Google LLC
-//
-// Licensed under the Apache License, Version 2.0 (the "License");
-// you may not use this file except in compliance with the License.
-// You may obtain a copy of the License at
-//
-//     https://www.apache.org/licenses/LICENSE-2.0
-//
-// Unless required by applicable law or agreed to in writing, software
-// distributed under the License is distributed on an "AS IS" BASIS,
-// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-// See the License for the specific language governing permissions and
-// limitations under the License.
-
-// modified by Bevy contributors
-
-use bencher::{benchmark_group, benchmark_main, Bencher};
-use bevy_ecs::*;
-
-struct Position(f32);
-struct Velocity(f32);
-
-fn spawn_tuple(b: &mut Bencher) {
-    let mut world = World::new();
-    b.iter(|| {
-        world.spawn((Position(0.0), Velocity(0.0)));
-    });
-}
-
-fn spawn_static(b: &mut Bencher) {
-    #[derive(Bundle)]
-    struct Bundle {
-        pos: Position,
-        vel: Velocity,
-    }
-
-    let mut world = World::new();
-    b.iter(|| {
-        world.spawn(Bundle {
-            pos: Position(0.0),
-            vel: Velocity(0.0),
-        });
-    });
-}
-
-fn spawn_batch(b: &mut Bencher) {
-    #[derive(Bundle)]
-    struct Bundle {
-        pos: Position,
-        vel: Velocity,
-    }
-
-    let mut world = World::new();
-    b.iter(|| {
-        world
-            .spawn_batch((0..1_000).map(|_| Bundle {
-                pos: Position(0.0),
-                vel: Velocity(0.0),
-            }))
-            .for_each(|_| {});
-        world.clear();
-    });
-}
-
-fn iterate_100k(b: &mut Bencher) {
-    let mut world = World::new();
-    for i in 0..100_000 {
-        world.spawn((Position(-(i as f32)), Velocity(i as f32)));
-    }
-    b.iter(|| {
-        for (mut pos, vel) in &mut world.query_mut::<(&mut Position, &Velocity)>() {
-            pos.0 += vel.0;
-        }
-    })
-}
-
-fn build(b: &mut Bencher) {
-    let mut world = World::new();
-    let mut builder = EntityBuilder::new();
-    b.iter(|| {
-        builder.add(Position(0.0)).add(Velocity(0.0));
-        world.spawn(builder.build());
-    });
-}
-
-benchmark_group!(
-    benches,
-    spawn_tuple,
-    spawn_static,
-    spawn_batch,
-    iterate_100k,
-    build
-);
-benchmark_main!(benches);
diff --git a/benches/benches/bevy_ecs/stages.rs b/benches/benches/bevy_ecs/stages.rs
index 5668c3dc9d20a..01421622fbc15 100644
--- a/benches/benches/bevy_ecs/stages.rs
+++ b/benches/benches/bevy_ecs/stages.rs
@@ -1,13 +1,15 @@
-use bevy::ecs::{IntoSystem,World,SystemStage,Resources,Query,Stage};
+use bevy::ecs::{
+    world::World,
+    schedule::{Stage, SystemStage},
+    system::{IntoSystem, Query},
+};
 use criterion::{criterion_group, criterion_main, Criterion};
 
 criterion_group!(benches, empty_systems, busy_systems, contrived);
 criterion_main!(benches);
 
-fn run_stage(stage: &mut SystemStage, world: &mut World, resources: &mut Resources) {
-    // !!NB!! Uncomment next line when running with old executor.
-    //stage.initialize(world, resources);
-    stage.run(world, resources);
+fn run_stage(stage: &mut SystemStage, world: &mut World) {
+    stage.run(world);
 }
 
 struct A(f32);
@@ -20,7 +22,6 @@ const ENTITY_BUNCH: usize = 5000;
 
 fn empty_systems(criterion: &mut Criterion) {
     let mut world = World::new();
-    let mut resources = Resources::default();
     let mut group = criterion.benchmark_group("empty_systems");
     group.warm_up_time(std::time::Duration::from_millis(500));
     group.measurement_time(std::time::Duration::from_secs(3));
@@ -30,10 +31,10 @@ fn empty_systems(criterion: &mut Criterion) {
         for _ in 0..amount {
             stage.add_system(empty.system());
         }
-        run_stage(&mut stage, &mut world, &mut resources);
+        run_stage(&mut stage, &mut world);
         group.bench_function(&format!("{:03}_systems", amount), |bencher| {
             bencher.iter(|| {
-                run_stage(&mut stage, &mut world, &mut resources);
+                run_stage(&mut stage, &mut world);
             });
         });
     }
@@ -47,10 +48,10 @@ fn empty_systems(criterion: &mut Criterion) {
                 .add_system(empty.system())
                 .add_system(empty.system());
         }
-        run_stage(&mut stage, &mut world, &mut resources);
+        run_stage(&mut stage, &mut world);
         group.bench_function(&format!("{:03}_systems", 5 * amount), |bencher| {
             bencher.iter(|| {
-                run_stage(&mut stage, &mut world, &mut resources);
+                run_stage(&mut stage, &mut world);
             });
         });
     }
@@ -59,22 +60,21 @@ fn empty_systems(criterion: &mut Criterion) {
 
 fn busy_systems(criterion: &mut Criterion) {
     fn ab(mut q: Query<(&mut A, &mut B)>) {
-        for (mut a, mut b) in q.iter_mut() {
+        q.for_each_mut(|(mut a, mut b)| {
             std::mem::swap(&mut a.0, &mut b.0);
-        }
+        });
     }
     fn cd(mut q: Query<(&mut C, &mut D)>) {
-        for (mut c, mut d) in q.iter_mut() {
+        q.for_each_mut(|(mut c, mut d)| {
             std::mem::swap(&mut c.0, &mut d.0);
-        }
+        });
     }
     fn ce(mut q: Query<(&mut C, &mut E)>) {
-        for (mut c, mut e) in q.iter_mut() {
+        q.for_each_mut(|(mut c, mut e)| {
             std::mem::swap(&mut c.0, &mut e.0);
-        }
+        });
     }
     let mut world = World::new();
-    let mut resources = Resources::default();
     let mut group = criterion.benchmark_group("busy_systems");
     group.warm_up_time(std::time::Duration::from_millis(500));
     group.measurement_time(std::time::Duration::from_secs(3));
@@ -95,7 +95,7 @@ fn busy_systems(criterion: &mut Criterion) {
                     .add_system(cd.system())
                     .add_system(ce.system());
             }
-            run_stage(&mut stage, &mut world, &mut resources);
+            run_stage(&mut stage, &mut world);
             group.bench_function(
                 &format!(
                     "{:02}x_entities_{:02}_systems",
@@ -104,7 +104,7 @@ fn busy_systems(criterion: &mut Criterion) {
                 ),
                 |bencher| {
                     bencher.iter(|| {
-                        run_stage(&mut stage, &mut world, &mut resources);
+                        run_stage(&mut stage, &mut world);
                     });
                 },
             );
@@ -115,25 +115,24 @@ fn busy_systems(criterion: &mut Criterion) {
 
 fn contrived(criterion: &mut Criterion) {
     fn s_0(mut q_0: Query<(&mut A, &mut B)>) {
-        for (mut c_0, mut c_1) in q_0.iter_mut() {
+        q_0.for_each_mut(|(mut c_0, mut c_1)| {
             std::mem::swap(&mut c_0.0, &mut c_1.0);
-        }
+        });
     }
     fn s_1(mut q_0: Query<(&mut A, &mut C)>, mut q_1: Query<(&mut B, &mut D)>) {
-        for (mut c_0, mut c_1) in q_0.iter_mut() {
+        q_0.for_each_mut(|(mut c_0, mut c_1)| {
             std::mem::swap(&mut c_0.0, &mut c_1.0);
-        }
-        for (mut c_0, mut c_1) in q_1.iter_mut() {
+        });
+        q_1.for_each_mut(|(mut c_0, mut c_1)| {
             std::mem::swap(&mut c_0.0, &mut c_1.0);
-        }
+        });
     }
     fn s_2(mut q_0: Query<(&mut C, &mut D)>) {
-        for (mut c_0, mut c_1) in q_0.iter_mut() {
+        q_0.for_each_mut(|(mut c_0, mut c_1)| {
             std::mem::swap(&mut c_0.0, &mut c_1.0);
-        }
+        });
     }
     let mut world = World::new();
-    let mut resources = Resources::default();
     let mut group = criterion.benchmark_group("contrived");
     group.warm_up_time(std::time::Duration::from_millis(500));
     group.measurement_time(std::time::Duration::from_secs(3));
@@ -153,7 +152,7 @@ fn contrived(criterion: &mut Criterion) {
                     .add_system(s_1.system())
                     .add_system(s_2.system());
             }
-            run_stage(&mut stage, &mut world, &mut resources);
+            run_stage(&mut stage, &mut world);
             group.bench_function(
                 &format!(
                     "{:02}x_entities_{:02}_systems",
@@ -162,7 +161,7 @@ fn contrived(criterion: &mut Criterion) {
                 ),
                 |bencher| {
                     bencher.iter(|| {
-                        run_stage(&mut stage, &mut world, &mut resources);
+                        run_stage(&mut stage, &mut world);
                     });
                 },
             );
diff --git a/benches/benches/bevy_tasks/iter.rs b/benches/benches/bevy_tasks/iter.rs
index 2c58adfc2708b..aafa4b6f5b3db 100644
--- a/benches/benches/bevy_tasks/iter.rs
+++ b/benches/benches/bevy_tasks/iter.rs
@@ -26,7 +26,7 @@ where
 }
 
 fn bench_overhead(c: &mut Criterion) {
-    fn noop(_: &mut usize) {};
+    fn noop(_: &mut usize) {}
 
     let mut v = (0..10000).collect::<Vec<usize>>();
     c.bench_function("overhead_iter", |b| {
diff --git a/crates/bevy_app/Cargo.toml b/crates/bevy_app/Cargo.toml
index 52a5b3030c1f0..be1b36a05fc73 100644
--- a/crates/bevy_app/Cargo.toml
+++ b/crates/bevy_app/Cargo.toml
@@ -14,11 +14,13 @@ keywords = ["bevy"]
 
 [features]
 trace = []
+default = ["bevy_reflect"]
 
 [dependencies]
 # bevy
 bevy_derive = { path = "../bevy_derive", version = "0.4.0" }
 bevy_ecs = { path = "../bevy_ecs", version = "0.4.0" }
+bevy_reflect = { path = "../bevy_reflect", version = "0.4.0", optional = true }
 bevy_utils = { path = "../bevy_utils", version = "0.4.0" }
 
 # other
diff --git a/crates/bevy_app/src/app.rs b/crates/bevy_app/src/app.rs
index 2b2e1a2a0ce44..fb56ad03ca281 100644
--- a/crates/bevy_app/src/app.rs
+++ b/crates/bevy_app/src/app.rs
@@ -1,5 +1,8 @@
 use crate::app_builder::AppBuilder;
-use bevy_ecs::{Resources, Schedule, Stage, World};
+use bevy_ecs::{
+    schedule::{Schedule, Stage},
+    world::World,
+};
 #[cfg(feature = "trace")]
 use bevy_utils::tracing::info_span;
 
@@ -27,7 +30,6 @@ use bevy_utils::tracing::info_span;
 /// ```
 pub struct App {
     pub world: World,
-    pub resources: Resources,
     pub runner: Box<dyn Fn(App)>,
     pub schedule: Schedule,
 }
@@ -36,7 +38,6 @@ impl Default for App {
     fn default() -> Self {
         Self {
             world: Default::default(),
-            resources: Default::default(),
             schedule: Default::default(),
             runner: Box::new(run_once),
         }
@@ -53,7 +54,7 @@ impl App {
     }
 
     pub fn update(&mut self) {
-        self.schedule.run(&mut self.world, &mut self.resources);
+        self.schedule.run(&mut self.world);
     }
 
     pub fn run(mut self) {
diff --git a/crates/bevy_app/src/app_builder.rs b/crates/bevy_app/src/app_builder.rs
index 46f3d77c5b149..cf64b6a4eb263 100644
--- a/crates/bevy_app/src/app_builder.rs
+++ b/crates/bevy_app/src/app_builder.rs
@@ -5,9 +5,12 @@ use crate::{
     CoreStage, PluginGroup, PluginGroupBuilder, StartupStage,
 };
 use bevy_ecs::{
-    clear_trackers_system, FromResources, IntoExclusiveSystem, IntoSystem, Resource, Resources,
-    RunOnce, Schedule, Stage, StageLabel, StateStage, SystemDescriptor, SystemSet, SystemStage,
-    World,
+    component::Component,
+    schedule::{
+        RunOnce, Schedule, Stage, StageLabel, StateStage, SystemDescriptor, SystemSet, SystemStage,
+    },
+    system::{IntoExclusiveSystem, IntoSystem},
+    world::{FromWorld, World},
 };
 use bevy_utils::tracing::debug;
 
@@ -22,10 +25,13 @@ impl Default for AppBuilder {
             app: App::default(),
         };
 
+        #[cfg(feature = "bevy_reflect")]
+        app_builder.init_resource::<bevy_reflect::TypeRegistryArc>();
+
         app_builder
             .add_default_stages()
             .add_event::<AppExit>()
-            .add_system_to_stage(CoreStage::Last, clear_trackers_system.exclusive_system());
+            .add_system_to_stage(CoreStage::Last, World::clear_trackers.exclusive_system());
         app_builder
     }
 }
@@ -37,17 +43,17 @@ impl AppBuilder {
         }
     }
 
-    pub fn resources(&self) -> &Resources {
-        &self.app.resources
+    pub fn run(&mut self) {
+        let app = std::mem::take(&mut self.app);
+        app.run();
     }
 
-    pub fn resources_mut(&mut self) -> &mut Resources {
-        &mut self.app.resources
+    pub fn world(&mut self) -> &World {
+        &self.app.world
     }
 
-    pub fn run(&mut self) {
-        let app = std::mem::take(&mut self.app);
-        app.run();
+    pub fn world_mut(&mut self) -> &mut World {
+        &mut self.app.world
     }
 
     pub fn set_world(&mut self, world: World) -> &mut Self {
@@ -171,7 +177,7 @@ impl AppBuilder {
         self
     }
 
-    pub fn on_state_enter<T: Clone + Resource>(
+    pub fn on_state_enter<T: Clone + Component>(
         &mut self,
         stage: impl StageLabel,
         state: T,
@@ -182,7 +188,7 @@ impl AppBuilder {
         })
     }
 
-    pub fn on_state_update<T: Clone + Resource>(
+    pub fn on_state_update<T: Clone + Component>(
         &mut self,
         stage: impl StageLabel,
         state: T,
@@ -193,7 +199,7 @@ impl AppBuilder {
         })
     }
 
-    pub fn on_state_exit<T: Clone + Resource>(
+    pub fn on_state_exit<T: Clone + Component>(
         &mut self,
         stage: impl StageLabel,
         state: T,
@@ -224,7 +230,7 @@ impl AppBuilder {
 
     pub fn add_event<T>(&mut self) -> &mut Self
     where
-        T: Send + Sync + 'static,
+        T: Component,
     {
         self.insert_resource(Events::<T>::default())
             .add_system_to_stage(CoreStage::Event, Events::<T>::update_system.system())
@@ -233,9 +239,9 @@ impl AppBuilder {
     /// Inserts a resource to the current [App] and overwrites any resource previously added of the same type.
     pub fn insert_resource<T>(&mut self, resource: T) -> &mut Self
     where
-        T: Send + Sync + 'static,
+        T: Component,
     {
-        self.app.resources.insert(resource);
+        self.app.world.insert_resource(resource);
         self
     }
 
@@ -243,19 +249,19 @@ impl AppBuilder {
     where
         T: 'static,
     {
-        self.app.resources.insert_non_send(resource);
+        self.app.world.insert_non_send(resource);
         self
     }
 
     pub fn init_resource<R>(&mut self) -> &mut Self
     where
-        R: FromResources + Send + Sync + 'static,
+        R: FromWorld + Send + Sync + 'static,
     {
         // PERF: We could avoid double hashing here, since the `from_resources` call is guaranteed not to
         // modify the map. However, we would need to be borrowing resources both mutably and immutably,
         // so we would need to be extremely certain this is correct
-        if !self.resources().contains::<R>() {
-            let resource = R::from_resources(&self.resources());
+        if !self.world_mut().contains_resource::<R>() {
+            let resource = R::from_world(self.world_mut());
             self.insert_resource(resource);
         }
         self
@@ -263,12 +269,12 @@ impl AppBuilder {
 
     pub fn init_non_send_resource<R>(&mut self) -> &mut Self
     where
-        R: FromResources + 'static,
+        R: FromWorld + 'static,
     {
         // See perf comment in init_resource
-        if self.app.resources.get_non_send::<R>().is_none() {
-            let resource = R::from_resources(&self.app.resources);
-            self.app.resources.insert_non_send(resource);
+        if self.app.world.get_non_send_resource::<R>().is_none() {
+            let resource = R::from_world(self.world_mut());
+            self.app.world.insert_non_send(resource);
         }
         self
     }
@@ -305,4 +311,16 @@ impl AppBuilder {
         plugin_group_builder.finish(self);
         self
     }
+
+    #[cfg(feature = "bevy_reflect")]
+    pub fn register_type<T: bevy_reflect::GetTypeRegistration>(&mut self) -> &mut Self {
+        {
+            let registry = self
+                .world_mut()
+                .get_resource_mut::<bevy_reflect::TypeRegistryArc>()
+                .unwrap();
+            registry.write().register::<T>();
+        }
+        self
+    }
 }
diff --git a/crates/bevy_app/src/event.rs b/crates/bevy_app/src/event.rs
index ddc8fd2271eb5..4e19ef6acdf44 100644
--- a/crates/bevy_app/src/event.rs
+++ b/crates/bevy_app/src/event.rs
@@ -1,4 +1,7 @@
-use bevy_ecs::{Local, Res, ResMut, SystemParam};
+use bevy_ecs::{
+    component::Component,
+    system::{Local, Res, ResMut, SystemParam},
+};
 use bevy_utils::tracing::trace;
 use std::{fmt, marker::PhantomData};
 
@@ -123,7 +126,7 @@ fn map_instance_event<T>(event_instance: &EventInstance<T>) -> &T {
 
 /// Reads events of type `T` in order and tracks which events have already been read.
 #[derive(SystemParam)]
-pub struct EventReader<'a, T: bevy_ecs::Resource> {
+pub struct EventReader<'a, T: Component> {
     last_event_count: Local<'a, (usize, PhantomData<T>)>,
     events: Res<'a, Events<T>>,
 }
@@ -207,7 +210,7 @@ fn internal_event_reader<'a, T>(
     }
 }
 
-impl<'a, T: bevy_ecs::Resource> EventReader<'a, T> {
+impl<'a, T: Component> EventReader<'a, T> {
     /// Iterates over the events this EventReader has not seen yet. This updates the EventReader's
     /// event counter, which means subsequent event reads will not include events that happened before now.
     pub fn iter(&mut self) -> impl DoubleEndedIterator<Item = &T> {
@@ -223,7 +226,7 @@ impl<'a, T: bevy_ecs::Resource> EventReader<'a, T> {
     }
 }
 
-impl<T: bevy_ecs::Resource> Events<T> {
+impl<T: Component> Events<T> {
     /// "Sends" an `event` by writing it to the current event buffer. [EventReader]s can then read the event.
     pub fn send(&mut self, event: T) {
         let event_id = EventId {
diff --git a/crates/bevy_app/src/lib.rs b/crates/bevy_app/src/lib.rs
index e278ae119d9f2..8224120e01d52 100644
--- a/crates/bevy_app/src/lib.rs
+++ b/crates/bevy_app/src/lib.rs
@@ -22,7 +22,7 @@ pub mod prelude {
     };
 }
 
-use bevy_ecs::StageLabel;
+use bevy_ecs::schedule::StageLabel;
 
 /// The names of the default App stages
 #[derive(Debug, Hash, PartialEq, Eq, Clone, StageLabel)]
diff --git a/crates/bevy_app/src/schedule_runner.rs b/crates/bevy_app/src/schedule_runner.rs
index e3855b2302561..69dde8e477e9b 100644
--- a/crates/bevy_app/src/schedule_runner.rs
+++ b/crates/bevy_app/src/schedule_runner.rs
@@ -41,15 +41,15 @@ impl ScheduleRunnerSettings {
     }
 }
 
-/// Configures an App to run its [Schedule](bevy_ecs::Schedule) according to a given [RunMode]
+/// Configures an App to run its [Schedule](bevy_ecs::schedule::Schedule) according to a given [RunMode]
 #[derive(Default)]
 pub struct ScheduleRunnerPlugin {}
 
 impl Plugin for ScheduleRunnerPlugin {
     fn build(&self, app: &mut AppBuilder) {
         let settings = app
-            .resources_mut()
-            .get_or_insert_with(ScheduleRunnerSettings::default)
+            .world_mut()
+            .get_resource_or_insert_with(ScheduleRunnerSettings::default)
             .to_owned();
         app.set_runner(move |mut app: App| {
             let mut app_exit_event_reader = ManualEventReader::<AppExit>::default();
@@ -63,7 +63,9 @@ impl Plugin for ScheduleRunnerPlugin {
                           -> Result<Option<Duration>, AppExit> {
                         let start_time = Instant::now();
 
-                        if let Some(app_exit_events) = app.resources.get_mut::<Events<AppExit>>() {
+                        if let Some(app_exit_events) =
+                            app.world.get_resource_mut::<Events<AppExit>>()
+                        {
                             if let Some(exit) = app_exit_event_reader.iter(&app_exit_events).last()
                             {
                                 return Err(exit.clone());
@@ -72,7 +74,9 @@ impl Plugin for ScheduleRunnerPlugin {
 
                         app.update();
 
-                        if let Some(app_exit_events) = app.resources.get_mut::<Events<AppExit>>() {
+                        if let Some(app_exit_events) =
+                            app.world.get_resource_mut::<Events<AppExit>>()
+                        {
                             if let Some(exit) = app_exit_event_reader.iter(&app_exit_events).last()
                             {
                                 return Err(exit.clone());
diff --git a/crates/bevy_asset/src/asset_server.rs b/crates/bevy_asset/src/asset_server.rs
index 8da6ae34edf22..7d58a10a6f3a8 100644
--- a/crates/bevy_asset/src/asset_server.rs
+++ b/crates/bevy_asset/src/asset_server.rs
@@ -5,7 +5,7 @@ use crate::{
     RefChange, RefChangeChannel, SourceInfo, SourceMeta,
 };
 use anyhow::Result;
-use bevy_ecs::Res;
+use bevy_ecs::system::Res;
 use bevy_log::warn;
 use bevy_tasks::TaskPool;
 use bevy_utils::{HashMap, Uuid};
diff --git a/crates/bevy_asset/src/assets.rs b/crates/bevy_asset/src/assets.rs
index ba28afb781d34..eb69de5abaf89 100644
--- a/crates/bevy_asset/src/assets.rs
+++ b/crates/bevy_asset/src/assets.rs
@@ -3,8 +3,10 @@ use crate::{
     RefChange,
 };
 use bevy_app::{prelude::Events, AppBuilder};
-use bevy_ecs::{FromResources, IntoSystem, ResMut};
-use bevy_reflect::RegisterTypeBuilder;
+use bevy_ecs::{
+    system::{IntoSystem, ResMut},
+    world::FromWorld,
+};
 use bevy_utils::HashMap;
 use crossbeam_channel::Sender;
 use std::fmt::Debug;
@@ -202,7 +204,7 @@ pub trait AddAsset {
         T: Asset;
     fn init_asset_loader<T>(&mut self) -> &mut Self
     where
-        T: AssetLoader + FromResources;
+        T: AssetLoader + FromWorld;
     fn add_asset_loader<T>(&mut self, loader: T) -> &mut Self
     where
         T: AssetLoader;
@@ -214,7 +216,7 @@ impl AddAsset for AppBuilder {
         T: Asset,
     {
         let assets = {
-            let asset_server = self.resources().get::<AssetServer>().unwrap();
+            let asset_server = self.world().get_resource::<AssetServer>().unwrap();
             asset_server.register_asset_type::<T>()
         };
 
@@ -233,17 +235,18 @@ impl AddAsset for AppBuilder {
 
     fn init_asset_loader<T>(&mut self) -> &mut Self
     where
-        T: AssetLoader + FromResources,
+        T: AssetLoader + FromWorld,
     {
-        self.add_asset_loader(T::from_resources(self.resources()))
+        let result = T::from_world(self.world_mut());
+        self.add_asset_loader(result)
     }
 
     fn add_asset_loader<T>(&mut self, loader: T) -> &mut Self
     where
         T: AssetLoader,
     {
-        self.resources()
-            .get_mut::<AssetServer>()
+        self.world_mut()
+            .get_resource_mut::<AssetServer>()
             .expect("AssetServer does not exist. Consider adding it as a resource.")
             .add_loader(loader);
         self
diff --git a/crates/bevy_asset/src/diagnostic/asset_count_diagnostics_plugin.rs b/crates/bevy_asset/src/diagnostic/asset_count_diagnostics_plugin.rs
index fb0bd6c5e63ff..1fcf5e2ae1e0c 100644
--- a/crates/bevy_asset/src/diagnostic/asset_count_diagnostics_plugin.rs
+++ b/crates/bevy_asset/src/diagnostic/asset_count_diagnostics_plugin.rs
@@ -1,7 +1,7 @@
 use crate::{Asset, Assets};
 use bevy_app::prelude::*;
 use bevy_diagnostic::{Diagnostic, DiagnosticId, Diagnostics};
-use bevy_ecs::{IntoSystem, Res, ResMut};
+use bevy_ecs::system::{IntoSystem, Res, ResMut};
 
 /// Adds "asset count" diagnostic to an App
 #[derive(Default)]
diff --git a/crates/bevy_asset/src/handle.rs b/crates/bevy_asset/src/handle.rs
index ad39e3438a69b..c33fcce4f3f0b 100644
--- a/crates/bevy_asset/src/handle.rs
+++ b/crates/bevy_asset/src/handle.rs
@@ -9,7 +9,8 @@ use crate::{
     path::{AssetPath, AssetPathId},
     Asset, Assets,
 };
-use bevy_reflect::{Reflect, ReflectComponent, ReflectDeserialize};
+use bevy_ecs::reflect::ReflectComponent;
+use bevy_reflect::{Reflect, ReflectDeserialize};
 use bevy_utils::Uuid;
 use crossbeam_channel::{Receiver, Sender};
 use serde::{Deserialize, Serialize};
diff --git a/crates/bevy_asset/src/io/android_asset_io.rs b/crates/bevy_asset/src/io/android_asset_io.rs
index dbb44b4f9c2af..91aa3770e1d5a 100644
--- a/crates/bevy_asset/src/io/android_asset_io.rs
+++ b/crates/bevy_asset/src/io/android_asset_io.rs
@@ -1,6 +1,6 @@
 use crate::{AssetIo, AssetIoError};
 use anyhow::Result;
-use bevy_ecs::bevy_utils::BoxedFuture;
+use bevy_utils::BoxedFuture;
 use std::{
     ffi::CString,
     path::{Path, PathBuf},
diff --git a/crates/bevy_asset/src/io/file_asset_io.rs b/crates/bevy_asset/src/io/file_asset_io.rs
index 0a06d66888e2d..bab6372651ff0 100644
--- a/crates/bevy_asset/src/io/file_asset_io.rs
+++ b/crates/bevy_asset/src/io/file_asset_io.rs
@@ -1,7 +1,7 @@
 use crate::{filesystem_watcher::FilesystemWatcher, AssetIo, AssetIoError, AssetServer};
 use anyhow::Result;
-use bevy_ecs::{bevy_utils::BoxedFuture, Res};
-use bevy_utils::HashSet;
+use bevy_ecs::system::Res;
+use bevy_utils::{BoxedFuture, HashSet};
 use crossbeam_channel::TryRecvError;
 use fs::File;
 use io::Read;
diff --git a/crates/bevy_asset/src/io/mod.rs b/crates/bevy_asset/src/io/mod.rs
index d7917972a04a6..a40b7b2d013b6 100644
--- a/crates/bevy_asset/src/io/mod.rs
+++ b/crates/bevy_asset/src/io/mod.rs
@@ -13,7 +13,7 @@ pub use file_asset_io::*;
 pub use wasm_asset_io::*;
 
 use anyhow::Result;
-use bevy_ecs::bevy_utils::BoxedFuture;
+use bevy_utils::BoxedFuture;
 use downcast_rs::{impl_downcast, Downcast};
 use std::{
     io,
diff --git a/crates/bevy_asset/src/io/wasm_asset_io.rs b/crates/bevy_asset/src/io/wasm_asset_io.rs
index ecac806744194..3e66981edcc1b 100644
--- a/crates/bevy_asset/src/io/wasm_asset_io.rs
+++ b/crates/bevy_asset/src/io/wasm_asset_io.rs
@@ -1,6 +1,6 @@
 use crate::{AssetIo, AssetIoError};
 use anyhow::Result;
-use bevy_ecs::bevy_utils::BoxedFuture;
+use bevy_utils::BoxedFuture;
 use js_sys::Uint8Array;
 use std::path::{Path, PathBuf};
 use wasm_bindgen::JsCast;
diff --git a/crates/bevy_asset/src/lib.rs b/crates/bevy_asset/src/lib.rs
index 3208a5efbee40..4b2214a5afda6 100644
--- a/crates/bevy_asset/src/lib.rs
+++ b/crates/bevy_asset/src/lib.rs
@@ -12,21 +12,24 @@ mod io;
 mod loader;
 mod path;
 
+pub mod prelude {
+    pub use crate::{AddAsset, AssetEvent, AssetServer, Assets, Handle, HandleUntyped};
+}
+
 pub use asset_server::*;
 pub use assets::*;
+pub use bevy_utils::BoxedFuture;
 pub use handle::*;
 pub use info::*;
 pub use io::*;
 pub use loader::*;
 pub use path::*;
 
-pub mod prelude {
-    pub use crate::{AddAsset, AssetEvent, AssetServer, Assets, Handle, HandleUntyped};
-}
-
 use bevy_app::{prelude::Plugin, AppBuilder};
-use bevy_ecs::{IntoSystem, StageLabel, SystemStage};
-use bevy_reflect::RegisterTypeBuilder;
+use bevy_ecs::{
+    schedule::{StageLabel, SystemStage},
+    system::IntoSystem,
+};
 use bevy_tasks::IoTaskPool;
 
 /// The names of asset stages in an App Schedule
@@ -59,8 +62,8 @@ impl Default for AssetServerSettings {
 /// delegate to the default `AssetIo` for the platform.
 pub fn create_platform_default_asset_io(app: &mut AppBuilder) -> Box<dyn AssetIo> {
     let settings = app
-        .resources_mut()
-        .get_or_insert_with(AssetServerSettings::default);
+        .world_mut()
+        .get_resource_or_insert_with(AssetServerSettings::default);
 
     #[cfg(all(not(target_arch = "wasm32"), not(target_os = "android")))]
     let source = FileAssetIo::new(&settings.asset_folder);
@@ -74,10 +77,10 @@ pub fn create_platform_default_asset_io(app: &mut AppBuilder) -> Box<dyn AssetIo
 
 impl Plugin for AssetPlugin {
     fn build(&self, app: &mut AppBuilder) {
-        if app.resources().get::<AssetServer>().is_none() {
+        if app.world().get_resource::<AssetServer>().is_none() {
             let task_pool = app
-                .resources()
-                .get::<IoTaskPool>()
+                .world()
+                .get_resource::<IoTaskPool>()
                 .expect("`IoTaskPool` resource not found.")
                 .0
                 .clone();
diff --git a/crates/bevy_asset/src/loader.rs b/crates/bevy_asset/src/loader.rs
index f405b6122e98c..5344d13e1e769 100644
--- a/crates/bevy_asset/src/loader.rs
+++ b/crates/bevy_asset/src/loader.rs
@@ -3,7 +3,10 @@ use crate::{
     RefChangeChannel,
 };
 use anyhow::Result;
-use bevy_ecs::{Res, ResMut, Resource};
+use bevy_ecs::{
+    component::Component,
+    system::{Res, ResMut},
+};
 use bevy_reflect::{TypeUuid, TypeUuidDynamic};
 use bevy_utils::{BoxedFuture, HashMap};
 use crossbeam_channel::{Receiver, Sender};
@@ -136,7 +139,7 @@ impl<'a> LoadContext<'a> {
 
 /// The result of loading an asset of type `T`
 #[derive(Debug)]
-pub struct AssetResult<T: Resource> {
+pub struct AssetResult<T: Component> {
     pub asset: T,
     pub id: HandleId,
     pub version: usize,
@@ -144,12 +147,12 @@ pub struct AssetResult<T: Resource> {
 
 /// A channel to send and receive [AssetResult]s
 #[derive(Debug)]
-pub struct AssetLifecycleChannel<T: Resource> {
+pub struct AssetLifecycleChannel<T: Component> {
     pub sender: Sender<AssetLifecycleEvent<T>>,
     pub receiver: Receiver<AssetLifecycleEvent<T>>,
 }
 
-pub enum AssetLifecycleEvent<T: Resource> {
+pub enum AssetLifecycleEvent<T: Component> {
     Create(AssetResult<T>),
     Free(HandleId),
 }
@@ -183,7 +186,7 @@ impl<T: AssetDynamic> AssetLifecycle for AssetLifecycleChannel<T> {
     }
 }
 
-impl<T: Resource> Default for AssetLifecycleChannel<T> {
+impl<T: Component> Default for AssetLifecycleChannel<T> {
     fn default() -> Self {
         let (sender, receiver) = crossbeam_channel::unbounded();
         AssetLifecycleChannel { sender, receiver }
diff --git a/crates/bevy_audio/src/audio_output.rs b/crates/bevy_audio/src/audio_output.rs
index 2268851bfff1c..075195c50be4f 100644
--- a/crates/bevy_audio/src/audio_output.rs
+++ b/crates/bevy_audio/src/audio_output.rs
@@ -1,6 +1,6 @@
 use crate::{Audio, AudioSource, Decodable};
 use bevy_asset::{Asset, Assets};
-use bevy_ecs::{Resources, World};
+use bevy_ecs::world::World;
 use rodio::{OutputStream, OutputStreamHandle, Sink};
 use std::marker::PhantomData;
 
@@ -59,16 +59,17 @@ where
 }
 
 /// Plays audio currently queued in the [Audio] resource through the [AudioOutput] resource
-pub fn play_queued_audio_system<P: Asset>(_world: &mut World, resources: &mut Resources)
+pub fn play_queued_audio_system<P: Asset>(world: &mut World)
 where
     P: Decodable,
     <P as Decodable>::Decoder: rodio::Source + Send + Sync,
     <<P as Decodable>::Decoder as Iterator>::Item: rodio::Sample + Send + Sync,
 {
-    let audio_output = resources.get_non_send::<AudioOutput<P>>().unwrap();
-    let mut audio = resources.get_mut::<Audio<P>>().unwrap();
+    let world = world.cell();
+    let audio_output = world.get_non_send::<AudioOutput<P>>().unwrap();
+    let mut audio = world.get_resource_mut::<Audio<P>>().unwrap();
 
-    if let Some(audio_sources) = resources.get::<Assets<P>>() {
+    if let Some(audio_sources) = world.get_resource::<Assets<P>>() {
         audio_output.try_play_queued(&*audio_sources, &mut *audio);
-    }
+    };
 }
diff --git a/crates/bevy_audio/src/lib.rs b/crates/bevy_audio/src/lib.rs
index c72a43ce02bea..f9f9dfb41f869 100644
--- a/crates/bevy_audio/src/lib.rs
+++ b/crates/bevy_audio/src/lib.rs
@@ -12,7 +12,7 @@ pub use audio_source::*;
 
 use bevy_app::prelude::*;
 use bevy_asset::AddAsset;
-use bevy_ecs::IntoExclusiveSystem;
+use bevy_ecs::system::IntoExclusiveSystem;
 
 /// Adds support for audio playback to an App
 #[derive(Default)]
diff --git a/crates/bevy_core/src/label.rs b/crates/bevy_core/src/label.rs
index 1a70d3220bd3d..9bd5aee9d4fa5 100644
--- a/crates/bevy_core/src/label.rs
+++ b/crates/bevy_core/src/label.rs
@@ -1,5 +1,10 @@
-use bevy_ecs::prelude::*;
-use bevy_reflect::{Reflect, ReflectComponent};
+use bevy_ecs::{
+    entity::Entity,
+    query::Changed,
+    reflect::ReflectComponent,
+    system::{Query, RemovedComponents, ResMut},
+};
+use bevy_reflect::Reflect;
 use bevy_utils::{HashMap, HashSet};
 use std::{
     borrow::Cow,
@@ -74,15 +79,16 @@ impl EntityLabels {
 
 pub(crate) fn entity_labels_system(
     mut entity_labels: ResMut<EntityLabels>,
+    removed_labels: RemovedComponents<Labels>,
     query: Query<(Entity, &Labels), Changed<Labels>>,
 ) {
     let entity_labels = entity_labels.deref_mut();
 
-    for entity in query.removed::<Labels>() {
-        if let Some(labels) = entity_labels.entity_labels.get(entity) {
+    for entity in removed_labels.iter() {
+        if let Some(labels) = entity_labels.entity_labels.get(&entity) {
             for label in labels.iter() {
                 if let Some(entities) = entity_labels.label_entities.get_mut(label) {
-                    entities.retain(|e| e != entity);
+                    entities.retain(|e| *e != entity);
                 }
             }
         }
@@ -114,17 +120,21 @@ pub(crate) fn entity_labels_system(
 
 #[cfg(test)]
 mod tests {
+    use bevy_ecs::{
+        schedule::{Schedule, Stage, SystemStage},
+        system::IntoSystem,
+        world::World,
+    };
+
     use super::*;
-    use bevy_ecs::Stage;
 
-    fn setup() -> (World, Resources, bevy_ecs::Schedule) {
-        let world = World::new();
-        let mut resources = Resources::default();
-        resources.insert(EntityLabels::default());
-        let mut schedule = bevy_ecs::Schedule::default();
+    fn setup() -> (World, Schedule) {
+        let mut world = World::new();
+        world.insert_resource(EntityLabels::default());
+        let mut schedule = Schedule::default();
         schedule.add_stage("test", SystemStage::single_threaded());
         schedule.add_system_to_stage("test", entity_labels_system.system());
-        (world, resources, schedule)
+        (world, schedule)
     }
 
     fn holy_cow() -> Labels {
@@ -137,12 +147,12 @@ mod tests {
 
     #[test]
     fn adds_spawned_entity() {
-        let (mut world, mut resources, mut schedule) = setup();
+        let (mut world, mut schedule) = setup();
 
-        let e1 = world.spawn((holy_cow(),));
-        schedule.run(&mut world, &mut resources);
+        let e1 = world.spawn().insert(holy_cow()).id();
+        schedule.run(&mut world);
 
-        let entity_labels = resources.get::<EntityLabels>().unwrap();
+        let entity_labels = world.get_resource::<EntityLabels>().unwrap();
         assert_eq!(entity_labels.get("holy"), &[e1], "holy");
         assert_eq!(entity_labels.get("cow"), &[e1], "cow");
         assert_eq!(entity_labels.get("shalau"), &[], "shalau");
@@ -150,14 +160,14 @@ mod tests {
 
     #[test]
     fn add_labels() {
-        let (mut world, mut resources, mut schedule) = setup();
-        let e1 = world.spawn((holy_cow(),));
-        schedule.run(&mut world, &mut resources);
+        let (mut world, mut schedule) = setup();
+        let e1 = world.spawn().insert(holy_cow()).id();
+        schedule.run(&mut world);
 
         world.get_mut::<Labels>(e1).unwrap().insert("shalau");
-        schedule.run(&mut world, &mut resources);
+        schedule.run(&mut world);
 
-        let entity_labels = resources.get::<EntityLabels>().unwrap();
+        let entity_labels = world.get_resource::<EntityLabels>().unwrap();
         assert_eq!(entity_labels.get("holy"), &[e1], "holy");
         assert_eq!(entity_labels.get("cow"), &[e1], "cow");
         assert_eq!(entity_labels.get("shalau"), &[e1], "shalau");
@@ -165,14 +175,14 @@ mod tests {
 
     #[test]
     fn remove_labels() {
-        let (mut world, mut resources, mut schedule) = setup();
-        let e1 = world.spawn((holy_cow(),));
-        schedule.run(&mut world, &mut resources);
+        let (mut world, mut schedule) = setup();
+        let e1 = world.spawn().insert(holy_cow()).id();
+        schedule.run(&mut world);
 
         world.get_mut::<Labels>(e1).unwrap().remove("holy");
-        schedule.run(&mut world, &mut resources);
+        schedule.run(&mut world);
 
-        let entity_labels = resources.get::<EntityLabels>().unwrap();
+        let entity_labels = world.get_resource::<EntityLabels>().unwrap();
         assert_eq!(entity_labels.get("holy"), &[], "holy");
         assert_eq!(entity_labels.get("cow"), &[e1], "cow");
         assert_eq!(entity_labels.get("shalau"), &[], "shalau");
@@ -180,14 +190,14 @@ mod tests {
 
     #[test]
     fn removes_despawned_entity() {
-        let (mut world, mut resources, mut schedule) = setup();
-        let e1 = world.spawn((holy_cow(),));
-        schedule.run(&mut world, &mut resources);
+        let (mut world, mut schedule) = setup();
+        let e1 = world.spawn().insert(holy_cow()).id();
+        schedule.run(&mut world);
 
-        world.despawn(e1).unwrap();
-        schedule.run(&mut world, &mut resources);
+        assert!(world.despawn(e1));
+        schedule.run(&mut world);
 
-        let entity_labels = resources.get::<EntityLabels>().unwrap();
+        let entity_labels = world.get_resource::<EntityLabels>().unwrap();
         assert_eq!(entity_labels.get("holy"), &[], "holy");
         assert_eq!(entity_labels.get("cow"), &[], "cow");
         assert_eq!(entity_labels.get("shalau"), &[], "shalau");
@@ -195,14 +205,14 @@ mod tests {
 
     #[test]
     fn removes_labels_when_component_removed() {
-        let (mut world, mut resources, mut schedule) = setup();
-        let e1 = world.spawn((holy_cow(),));
-        schedule.run(&mut world, &mut resources);
+        let (mut world, mut schedule) = setup();
+        let e1 = world.spawn().insert(holy_cow()).id();
+        schedule.run(&mut world);
 
-        world.remove_one::<Labels>(e1).unwrap();
-        schedule.run(&mut world, &mut resources);
+        world.entity_mut(e1).remove::<Labels>().unwrap();
+        schedule.run(&mut world);
 
-        let entity_labels = resources.get::<EntityLabels>().unwrap();
+        let entity_labels = world.get_resource::<EntityLabels>().unwrap();
         assert_eq!(entity_labels.get("holy"), &[], "holy");
         assert_eq!(entity_labels.get("cow"), &[], "cow");
         assert_eq!(entity_labels.get("shalau"), &[], "shalau");
@@ -210,14 +220,14 @@ mod tests {
 
     #[test]
     fn adds_another_spawned_entity() {
-        let (mut world, mut resources, mut schedule) = setup();
-        let e1 = world.spawn((holy_cow(),));
-        schedule.run(&mut world, &mut resources);
+        let (mut world, mut schedule) = setup();
+        let e1 = world.spawn().insert(holy_cow()).id();
+        schedule.run(&mut world);
 
-        let e2 = world.spawn((holy_shamoni(),));
-        schedule.run(&mut world, &mut resources);
+        let e2 = world.spawn().insert(holy_shamoni()).id();
+        schedule.run(&mut world);
 
-        let entity_labels = resources.get::<EntityLabels>().unwrap();
+        let entity_labels = world.get_resource::<EntityLabels>().unwrap();
         assert_eq!(entity_labels.get("holy"), &[e1, e2], "holy");
         assert_eq!(entity_labels.get("cow"), &[e1], "cow");
         assert_eq!(entity_labels.get("shamoni"), &[e2], "shamoni");
@@ -226,17 +236,17 @@ mod tests {
 
     #[test]
     fn removes_despawned_entity_but_leaves_other() {
-        let (mut world, mut resources, mut schedule) = setup();
-        let e1 = world.spawn((holy_cow(),));
-        schedule.run(&mut world, &mut resources);
+        let (mut world, mut schedule) = setup();
+        let e1 = world.spawn().insert(holy_cow()).id();
+        schedule.run(&mut world);
 
-        let e2 = world.spawn((holy_shamoni(),));
-        schedule.run(&mut world, &mut resources);
+        let e2 = world.spawn().insert(holy_shamoni()).id();
+        schedule.run(&mut world);
 
-        world.despawn(e1).unwrap();
-        schedule.run(&mut world, &mut resources);
+        assert!(world.despawn(e1));
+        schedule.run(&mut world);
 
-        let entity_labels = resources.get::<EntityLabels>().unwrap();
+        let entity_labels = world.get_resource::<EntityLabels>().unwrap();
         assert_eq!(entity_labels.get("holy"), &[e2], "holy");
         assert_eq!(entity_labels.get("cow"), &[], "cow");
         assert_eq!(entity_labels.get("shamoni"), &[e2], "shamoni");
diff --git a/crates/bevy_core/src/lib.rs b/crates/bevy_core/src/lib.rs
index 12c7b1377cc6d..e26be88c1337b 100644
--- a/crates/bevy_core/src/lib.rs
+++ b/crates/bevy_core/src/lib.rs
@@ -5,8 +5,6 @@ mod name;
 mod task_pool_options;
 mod time;
 
-use bevy_ecs::IntoSystem;
-use bevy_reflect::RegisterTypeBuilder;
 pub use bytes::*;
 pub use float_ord::*;
 pub use label::*;
@@ -19,6 +17,7 @@ pub mod prelude {
 }
 
 use bevy_app::prelude::*;
+use bevy_ecs::{entity::Entity, system::IntoSystem};
 use std::ops::Range;
 
 /// Adds core functionality to Apps.
@@ -28,15 +27,16 @@ pub struct CorePlugin;
 impl Plugin for CorePlugin {
     fn build(&self, app: &mut AppBuilder) {
         // Setup the default bevy task pools
-        app.resources_mut()
-            .get_cloned::<DefaultTaskPoolOptions>()
+        app.world_mut()
+            .get_resource::<DefaultTaskPoolOptions>()
+            .cloned()
             .unwrap_or_else(DefaultTaskPoolOptions::default)
-            .create_default_pools(app.resources_mut());
+            .create_default_pools(app.world_mut());
 
         app.init_resource::<Time>()
             .init_resource::<EntityLabels>()
             .init_resource::<FixedTimesteps>()
-            .register_type::<Option<String>>()
+            .register_type::<Entity>()
             .register_type::<Name>()
             .register_type::<Labels>()
             .register_type::<Range<f32>>()
@@ -44,5 +44,43 @@ impl Plugin for CorePlugin {
             .add_system_to_stage(CoreStage::First, time_system.system())
             .add_startup_system_to_stage(StartupStage::PostStartup, entity_labels_system.system())
             .add_system_to_stage(CoreStage::PostUpdate, entity_labels_system.system());
+
+        register_rust_types(app);
+        register_math_types(app);
     }
 }
+
+fn register_rust_types(app: &mut AppBuilder) {
+    app.register_type::<bool>()
+        .register_type::<u8>()
+        .register_type::<u16>()
+        .register_type::<u32>()
+        .register_type::<u64>()
+        .register_type::<u128>()
+        .register_type::<usize>()
+        .register_type::<i8>()
+        .register_type::<i16>()
+        .register_type::<i32>()
+        .register_type::<i64>()
+        .register_type::<i128>()
+        .register_type::<isize>()
+        .register_type::<f32>()
+        .register_type::<f64>()
+        .register_type::<String>()
+        .register_type::<Option<String>>();
+}
+
+fn register_math_types(app: &mut AppBuilder) {
+    app.register_type::<bevy_math::IVec2>()
+        .register_type::<bevy_math::IVec3>()
+        .register_type::<bevy_math::IVec4>()
+        .register_type::<bevy_math::UVec2>()
+        .register_type::<bevy_math::UVec3>()
+        .register_type::<bevy_math::UVec4>()
+        .register_type::<bevy_math::Vec2>()
+        .register_type::<bevy_math::Vec3>()
+        .register_type::<bevy_math::Vec4>()
+        .register_type::<bevy_math::Mat3>()
+        .register_type::<bevy_math::Mat4>()
+        .register_type::<bevy_math::Quat>();
+}
diff --git a/crates/bevy_core/src/name.rs b/crates/bevy_core/src/name.rs
index fd2f4d9f78851..7390fd8b18688 100644
--- a/crates/bevy_core/src/name.rs
+++ b/crates/bevy_core/src/name.rs
@@ -1,4 +1,5 @@
-use bevy_reflect::{Reflect, ReflectComponent};
+use bevy_ecs::reflect::ReflectComponent;
+use bevy_reflect::Reflect;
 use bevy_utils::AHasher;
 use std::{
     borrow::Cow,
diff --git a/crates/bevy_core/src/task_pool_options.rs b/crates/bevy_core/src/task_pool_options.rs
index 30c6b3120fcaa..ca8d0c8c973b4 100644
--- a/crates/bevy_core/src/task_pool_options.rs
+++ b/crates/bevy_core/src/task_pool_options.rs
@@ -1,4 +1,4 @@
-use bevy_ecs::Resources;
+use bevy_ecs::world::World;
 use bevy_tasks::{AsyncComputeTaskPool, ComputeTaskPool, IoTaskPool, TaskPoolBuilder};
 use bevy_utils::tracing::trace;
 
@@ -91,7 +91,7 @@ impl DefaultTaskPoolOptions {
     }
 
     /// Inserts the default thread pools into the given resource map based on the configured values
-    pub fn create_default_pools(&self, resources: &mut Resources) {
+    pub fn create_default_pools(&self, world: &mut World) {
         let total_threads = bevy_math::clamp(
             bevy_tasks::logical_core_count(),
             self.min_total_threads,
@@ -101,7 +101,7 @@ impl DefaultTaskPoolOptions {
 
         let mut remaining_threads = total_threads;
 
-        if !resources.contains::<IoTaskPool>() {
+        if !world.contains_resource::<IoTaskPool>() {
             // Determine the number of IO threads we will use
             let io_threads = self
                 .io
@@ -110,7 +110,7 @@ impl DefaultTaskPoolOptions {
             trace!("IO Threads: {}", io_threads);
             remaining_threads = remaining_threads.saturating_sub(io_threads);
 
-            resources.insert(IoTaskPool(
+            world.insert_resource(IoTaskPool(
                 TaskPoolBuilder::default()
                     .num_threads(io_threads)
                     .thread_name("IO Task Pool".to_string())
@@ -118,7 +118,7 @@ impl DefaultTaskPoolOptions {
             ));
         }
 
-        if !resources.contains::<AsyncComputeTaskPool>() {
+        if !world.contains_resource::<AsyncComputeTaskPool>() {
             // Determine the number of async compute threads we will use
             let async_compute_threads = self
                 .async_compute
@@ -127,7 +127,7 @@ impl DefaultTaskPoolOptions {
             trace!("Async Compute Threads: {}", async_compute_threads);
             remaining_threads = remaining_threads.saturating_sub(async_compute_threads);
 
-            resources.insert(AsyncComputeTaskPool(
+            world.insert_resource(AsyncComputeTaskPool(
                 TaskPoolBuilder::default()
                     .num_threads(async_compute_threads)
                     .thread_name("Async Compute Task Pool".to_string())
@@ -135,7 +135,7 @@ impl DefaultTaskPoolOptions {
             ));
         }
 
-        if !resources.contains::<ComputeTaskPool>() {
+        if !world.contains_resource::<ComputeTaskPool>() {
             // Determine the number of compute threads we will use
             // This is intentionally last so that an end user can specify 1.0 as the percent
             let compute_threads = self
@@ -143,7 +143,7 @@ impl DefaultTaskPoolOptions {
                 .get_number_of_threads(remaining_threads, total_threads);
 
             trace!("Compute Threads: {}", compute_threads);
-            resources.insert(ComputeTaskPool(
+            world.insert_resource(ComputeTaskPool(
                 TaskPoolBuilder::default()
                     .num_threads(compute_threads)
                     .thread_name("Compute Task Pool".to_string())
diff --git a/crates/bevy_core/src/time/fixed_timestep.rs b/crates/bevy_core/src/time/fixed_timestep.rs
index 80f99ef636e61..befd138892b8d 100644
--- a/crates/bevy_core/src/time/fixed_timestep.rs
+++ b/crates/bevy_core/src/time/fixed_timestep.rs
@@ -1,7 +1,14 @@
 use crate::Time;
-use bevy_ecs::{ArchetypeComponent, ShouldRun, System, SystemId, TypeAccess};
+use bevy_ecs::{
+    archetype::{Archetype, ArchetypeComponentId},
+    component::ComponentId,
+    query::Access,
+    schedule::ShouldRun,
+    system::{IntoSystem, Local, Res, ResMut, System, SystemId},
+    world::World,
+};
 use bevy_utils::HashMap;
-use std::{any::TypeId, borrow::Cow};
+use std::borrow::Cow;
 
 pub struct FixedTimestepState {
     pub step: f64,
@@ -42,27 +49,15 @@ impl FixedTimesteps {
 }
 
 pub struct FixedTimestep {
-    step: f64,
-    accumulator: f64,
-    looping: bool,
-    system_id: SystemId,
-    label: Option<String>, // TODO: consider making this a TypedLabel
-    archetype_access: TypeAccess<ArchetypeComponent>,
-    component_access: TypeAccess<TypeId>,
-    resource_access: TypeAccess<TypeId>,
+    state: State,
+    internal_system: Box<dyn System<In = (), Out = ShouldRun>>,
 }
 
 impl Default for FixedTimestep {
     fn default() -> Self {
         Self {
-            system_id: SystemId::new(),
-            step: 1.0 / 60.0,
-            accumulator: 0.0,
-            looping: false,
-            label: None,
-            component_access: Default::default(),
-            archetype_access: Default::default(),
-            resource_access: Default::default(),
+            state: State::default(),
+            internal_system: Box::new(Self::prepare_system.system()),
         }
     }
 }
@@ -70,24 +65,66 @@ impl Default for FixedTimestep {
 impl FixedTimestep {
     pub fn step(step: f64) -> Self {
         Self {
-            step,
+            state: State {
+                step,
+                ..Default::default()
+            },
             ..Default::default()
         }
     }
 
     pub fn steps_per_second(rate: f64) -> Self {
         Self {
-            step: 1.0 / rate,
+            state: State {
+                step: 1.0 / rate,
+                ..Default::default()
+            },
             ..Default::default()
         }
     }
 
     pub fn with_label(mut self, label: &str) -> Self {
-        self.label = Some(label.to_string());
+        self.state.label = Some(label.to_string());
         self
     }
 
-    pub fn update(&mut self, time: &Time) -> ShouldRun {
+    fn prepare_system(
+        mut state: Local<State>,
+        time: Res<Time>,
+        mut fixed_timesteps: ResMut<FixedTimesteps>,
+    ) -> ShouldRun {
+        let should_run = state.update(&time);
+        if let Some(ref label) = state.label {
+            let res_state = fixed_timesteps.fixed_timesteps.get_mut(label).unwrap();
+            res_state.step = state.step;
+            res_state.accumulator = state.accumulator;
+        }
+
+        should_run
+    }
+}
+
+#[derive(Clone)]
+pub struct State {
+    label: Option<String>, // TODO: consider making this a TypedLabel
+    step: f64,
+    accumulator: f64,
+    looping: bool,
+}
+
+impl Default for State {
+    fn default() -> Self {
+        Self {
+            step: 1.0 / 60.0,
+            accumulator: 0.0,
+            label: None,
+            looping: false,
+        }
+    }
+}
+
+impl State {
+    fn update(&mut self, time: &Time) -> ShouldRun {
         if !self.looping {
             self.accumulator += time.delta_seconds_f64();
         }
@@ -112,61 +149,49 @@ impl System for FixedTimestep {
     }
 
     fn id(&self) -> SystemId {
-        self.system_id
+        self.internal_system.id()
     }
 
-    fn update_access(&mut self, _world: &bevy_ecs::World) {}
-
-    fn archetype_component_access(&self) -> &TypeAccess<ArchetypeComponent> {
-        &self.archetype_access
+    fn new_archetype(&mut self, archetype: &Archetype) {
+        self.internal_system.new_archetype(archetype);
     }
 
-    fn component_access(&self) -> &TypeAccess<TypeId> {
-        &self.component_access
+    fn archetype_component_access(&self) -> &Access<ArchetypeComponentId> {
+        self.internal_system.archetype_component_access()
     }
 
-    fn resource_access(&self) -> &TypeAccess<TypeId> {
-        &self.resource_access
+    fn component_access(&self) -> &Access<ComponentId> {
+        self.internal_system.component_access()
     }
 
-    fn is_non_send(&self) -> bool {
-        false
+    fn is_send(&self) -> bool {
+        self.internal_system.is_send()
     }
 
-    unsafe fn run_unsafe(
-        &mut self,
-        _input: Self::In,
-        _world: &bevy_ecs::World,
-        resources: &bevy_ecs::Resources,
-    ) -> Option<Self::Out> {
-        let time = resources.get::<Time>().unwrap();
-        let result = self.update(&time);
-        if let Some(ref label) = self.label {
-            let mut fixed_timesteps = resources.get_mut::<FixedTimesteps>().unwrap();
-            let state = fixed_timesteps.fixed_timesteps.get_mut(label).unwrap();
-            state.step = self.step;
-            state.accumulator = self.accumulator;
-        }
-
-        Some(result)
+    unsafe fn run_unsafe(&mut self, _input: Self::In, world: &World) -> Self::Out {
+        // SAFE: this system inherits the internal system's component access and archetype component access,
+        // which means the caller has ensured running the internal system is safe
+        self.internal_system.run_unsafe((), world)
     }
 
-    fn apply_buffers(
-        &mut self,
-        _world: &mut bevy_ecs::World,
-        _resources: &mut bevy_ecs::Resources,
-    ) {
+    fn apply_buffers(&mut self, world: &mut World) {
+        self.internal_system.apply_buffers(world)
     }
 
-    fn initialize(&mut self, _world: &mut bevy_ecs::World, resources: &mut bevy_ecs::Resources) {
-        self.resource_access.add_read(TypeId::of::<Time>());
-        if let Some(ref label) = self.label {
-            let mut fixed_timesteps = resources.get_mut::<FixedTimesteps>().unwrap();
+    fn initialize(&mut self, world: &mut World) {
+        self.internal_system = Box::new(
+            Self::prepare_system
+                .system()
+                .config(|c| c.0 = Some(self.state.clone())),
+        );
+        self.internal_system.initialize(world);
+        if let Some(ref label) = self.state.label {
+            let mut fixed_timesteps = world.get_resource_mut::<FixedTimesteps>().unwrap();
             fixed_timesteps.fixed_timesteps.insert(
                 label.clone(),
                 FixedTimestepState {
                     accumulator: 0.0,
-                    step: self.step,
+                    step: self.state.step,
                 },
             );
         }
diff --git a/crates/bevy_core/src/time/time.rs b/crates/bevy_core/src/time/time.rs
index 670c6d3029c66..5139ade733e97 100644
--- a/crates/bevy_core/src/time/time.rs
+++ b/crates/bevy_core/src/time/time.rs
@@ -1,4 +1,4 @@
-use bevy_ecs::ResMut;
+use bevy_ecs::system::ResMut;
 use bevy_utils::{Duration, Instant};
 
 /// Tracks elapsed time since the last update and since the App has started
diff --git a/crates/bevy_core/src/time/timer.rs b/crates/bevy_core/src/time/timer.rs
index ea634850c731e..755b869252e86 100644
--- a/crates/bevy_core/src/time/timer.rs
+++ b/crates/bevy_core/src/time/timer.rs
@@ -1,4 +1,5 @@
-use bevy_reflect::{Reflect, ReflectComponent};
+use bevy_ecs::reflect::ReflectComponent;
+use bevy_reflect::Reflect;
 use bevy_utils::Duration;
 
 /// Tracks elapsed time. Enters the finished state once `duration` is reached.
diff --git a/crates/bevy_diagnostic/src/entity_count_diagnostics_plugin.rs b/crates/bevy_diagnostic/src/entity_count_diagnostics_plugin.rs
index 05a309a206c12..bdc24a35da5a9 100644
--- a/crates/bevy_diagnostic/src/entity_count_diagnostics_plugin.rs
+++ b/crates/bevy_diagnostic/src/entity_count_diagnostics_plugin.rs
@@ -1,6 +1,10 @@
+use bevy_app::{AppBuilder, Plugin};
+use bevy_ecs::{
+    system::{IntoExclusiveSystem, IntoSystem, ResMut},
+    world::World,
+};
+
 use crate::{Diagnostic, DiagnosticId, Diagnostics};
-use bevy_app::prelude::*;
-use bevy_ecs::{IntoExclusiveSystem, IntoSystem, ResMut, Resources, World};
 
 /// Adds "entity count" diagnostic to an App
 #[derive(Default)]
@@ -21,9 +25,10 @@ impl EntityCountDiagnosticsPlugin {
         diagnostics.add(Diagnostic::new(Self::ENTITY_COUNT, "entity_count", 20));
     }
 
-    pub fn diagnostic_system(world: &mut World, resources: &mut Resources) {
-        if let Some(mut diagnostics) = resources.get_mut::<Diagnostics>() {
-            diagnostics.add_measurement(Self::ENTITY_COUNT, world.entity_count() as f64);
+    pub fn diagnostic_system(world: &mut World) {
+        let entity_count = world.entities().len();
+        if let Some(mut diagnostics) = world.get_resource_mut::<Diagnostics>() {
+            diagnostics.add_measurement(Self::ENTITY_COUNT, entity_count as f64);
         }
     }
 }
diff --git a/crates/bevy_diagnostic/src/frame_time_diagnostics_plugin.rs b/crates/bevy_diagnostic/src/frame_time_diagnostics_plugin.rs
index d4dbdb7ed2299..52fb20db050f9 100644
--- a/crates/bevy_diagnostic/src/frame_time_diagnostics_plugin.rs
+++ b/crates/bevy_diagnostic/src/frame_time_diagnostics_plugin.rs
@@ -1,7 +1,7 @@
 use crate::{Diagnostic, DiagnosticId, Diagnostics};
 use bevy_app::prelude::*;
 use bevy_core::Time;
-use bevy_ecs::{IntoSystem, Res, ResMut};
+use bevy_ecs::system::{IntoSystem, Res, ResMut};
 
 /// Adds "frame time" diagnostic to an App, specifically "frame time", "fps" and "frame count"
 #[derive(Default)]
diff --git a/crates/bevy_diagnostic/src/log_diagnostics_plugin.rs b/crates/bevy_diagnostic/src/log_diagnostics_plugin.rs
index dda1804670835..e75691e16d96c 100644
--- a/crates/bevy_diagnostic/src/log_diagnostics_plugin.rs
+++ b/crates/bevy_diagnostic/src/log_diagnostics_plugin.rs
@@ -1,7 +1,7 @@
 use super::{Diagnostic, DiagnosticId, Diagnostics};
 use bevy_app::prelude::*;
 use bevy_core::{Time, Timer};
-use bevy_ecs::{IntoSystem, Res, ResMut};
+use bevy_ecs::system::{IntoSystem, Res, ResMut};
 use bevy_log::{debug, info};
 use bevy_utils::Duration;
 
diff --git a/crates/bevy_ecs/Cargo.toml b/crates/bevy_ecs/Cargo.toml
index e5093d6af49c0..3c0ac1b0e6a35 100644
--- a/crates/bevy_ecs/Cargo.toml
+++ b/crates/bevy_ecs/Cargo.toml
@@ -9,24 +9,26 @@ authors = [
 description = "Bevy Engine's entity component system"
 homepage = "https://bevyengine.org"
 repository = "https://github.com/bevyengine/bevy"
-license = "Apache-2.0"
+license = "MIT"
 keywords = ["ecs", "game", "bevy"]
 categories = ["game-engines", "data-structures"]
 
 [features]
 trace = []
+default = ["bevy_reflect"]
 
 [dependencies]
+bevy_reflect = { path = "../bevy_reflect", version = "0.4.0", optional = true }
 bevy_tasks = { path = "../bevy_tasks", version = "0.4.0" }
 bevy_utils = { path = "../bevy_utils", version = "0.4.0" }
 bevy_ecs_macros = { path = "macros", version = "0.4.0" }
+
+async-channel = "1.4"
+bitflags = "1.2"
+fixedbitset = "0.3"
 fxhash = "0.2"
-async-channel = "1.4.2"
-rand = "0.8.0"
-serde = "1.0"
 thiserror = "1.0"
-fixedbitset = "0.3.1"
-bitflags = "1.2.1"
-downcast-rs = "1.2.0"
-parking_lot = "0.11.0"
-lazy_static = { version = "1.4.0" }
+downcast-rs = "1.2"
+parking_lot = "0.11"
+rand = "0.7"
+serde = "1"
diff --git a/crates/bevy_ecs/LICENSE_APACHE b/crates/bevy_ecs/LICENSE_APACHE
deleted file mode 100644
index d645695673349..0000000000000
--- a/crates/bevy_ecs/LICENSE_APACHE
+++ /dev/null
@@ -1,202 +0,0 @@
-
-                                 Apache License
-                           Version 2.0, January 2004
-                        http://www.apache.org/licenses/
-
-   TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION
-
-   1. Definitions.
-
-      "License" shall mean the terms and conditions for use, reproduction,
-      and distribution as defined by Sections 1 through 9 of this document.
-
-      "Licensor" shall mean the copyright owner or entity authorized by
-      the copyright owner that is granting the License.
-
-      "Legal Entity" shall mean the union of the acting entity and all
-      other entities that control, are controlled by, or are under common
-      control with that entity. For the purposes of this definition,
-      "control" means (i) the power, direct or indirect, to cause the
-      direction or management of such entity, whether by contract or
-      otherwise, or (ii) ownership of fifty percent (50%) or more of the
-      outstanding shares, or (iii) beneficial ownership of such entity.
-
-      "You" (or "Your") shall mean an individual or Legal Entity
-      exercising permissions granted by this License.
-
-      "Source" form shall mean the preferred form for making modifications,
-      including but not limited to software source code, documentation
-      source, and configuration files.
-
-      "Object" form shall mean any form resulting from mechanical
-      transformation or translation of a Source form, including but
-      not limited to compiled object code, generated documentation,
-      and conversions to other media types.
-
-      "Work" shall mean the work of authorship, whether in Source or
-      Object form, made available under the License, as indicated by a
-      copyright notice that is included in or attached to the work
-      (an example is provided in the Appendix below).
-
-      "Derivative Works" shall mean any work, whether in Source or Object
-      form, that is based on (or derived from) the Work and for which the
-      editorial revisions, annotations, elaborations, or other modifications
-      represent, as a whole, an original work of authorship. For the purposes
-      of this License, Derivative Works shall not include works that remain
-      separable from, or merely link (or bind by name) to the interfaces of,
-      the Work and Derivative Works thereof.
-
-      "Contribution" shall mean any work of authorship, including
-      the original version of the Work and any modifications or additions
-      to that Work or Derivative Works thereof, that is intentionally
-      submitted to Licensor for inclusion in the Work by the copyright owner
-      or by an individual or Legal Entity authorized to submit on behalf of
-      the copyright owner. For the purposes of this definition, "submitted"
-      means any form of electronic, verbal, or written communication sent
-      to the Licensor or its representatives, including but not limited to
-      communication on electronic mailing lists, source code control systems,
-      and issue tracking systems that are managed by, or on behalf of, the
-      Licensor for the purpose of discussing and improving the Work, but
-      excluding communication that is conspicuously marked or otherwise
-      designated in writing by the copyright owner as "Not a Contribution."
-
-      "Contributor" shall mean Licensor and any individual or Legal Entity
-      on behalf of whom a Contribution has been received by Licensor and
-      subsequently incorporated within the Work.
-
-   2. Grant of Copyright License. Subject to the terms and conditions of
-      this License, each Contributor hereby grants to You a perpetual,
-      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
-      copyright license to reproduce, prepare Derivative Works of,
-      publicly display, publicly perform, sublicense, and distribute the
-      Work and such Derivative Works in Source or Object form.
-
-   3. Grant of Patent License. Subject to the terms and conditions of
-      this License, each Contributor hereby grants to You a perpetual,
-      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
-      (except as stated in this section) patent license to make, have made,
-      use, offer to sell, sell, import, and otherwise transfer the Work,
-      where such license applies only to those patent claims licensable
-      by such Contributor that are necessarily infringed by their
-      Contribution(s) alone or by combination of their Contribution(s)
-      with the Work to which such Contribution(s) was submitted. If You
-      institute patent litigation against any entity (including a
-      cross-claim or counterclaim in a lawsuit) alleging that the Work
-      or a Contribution incorporated within the Work constitutes direct
-      or contributory patent infringement, then any patent licenses
-      granted to You under this License for that Work shall terminate
-      as of the date such litigation is filed.
-
-   4. Redistribution. You may reproduce and distribute copies of the
-      Work or Derivative Works thereof in any medium, with or without
-      modifications, and in Source or Object form, provided that You
-      meet the following conditions:
-
-      (a) You must give any other recipients of the Work or
-          Derivative Works a copy of this License; and
-
-      (b) You must cause any modified files to carry prominent notices
-          stating that You changed the files; and
-
-      (c) You must retain, in the Source form of any Derivative Works
-          that You distribute, all copyright, patent, trademark, and
-          attribution notices from the Source form of the Work,
-          excluding those notices that do not pertain to any part of
-          the Derivative Works; and
-
-      (d) If the Work includes a "NOTICE" text file as part of its
-          distribution, then any Derivative Works that You distribute must
-          include a readable copy of the attribution notices contained
-          within such NOTICE file, excluding those notices that do not
-          pertain to any part of the Derivative Works, in at least one
-          of the following places: within a NOTICE text file distributed
-          as part of the Derivative Works; within the Source form or
-          documentation, if provided along with the Derivative Works; or,
-          within a display generated by the Derivative Works, if and
-          wherever such third-party notices normally appear. The contents
-          of the NOTICE file are for informational purposes only and
-          do not modify the License. You may add Your own attribution
-          notices within Derivative Works that You distribute, alongside
-          or as an addendum to the NOTICE text from the Work, provided
-          that such additional attribution notices cannot be construed
-          as modifying the License.
-
-      You may add Your own copyright statement to Your modifications and
-      may provide additional or different license terms and conditions
-      for use, reproduction, or distribution of Your modifications, or
-      for any such Derivative Works as a whole, provided Your use,
-      reproduction, and distribution of the Work otherwise complies with
-      the conditions stated in this License.
-
-   5. Submission of Contributions. Unless You explicitly state otherwise,
-      any Contribution intentionally submitted for inclusion in the Work
-      by You to the Licensor shall be under the terms and conditions of
-      this License, without any additional terms or conditions.
-      Notwithstanding the above, nothing herein shall supersede or modify
-      the terms of any separate license agreement you may have executed
-      with Licensor regarding such Contributions.
-
-   6. Trademarks. This License does not grant permission to use the trade
-      names, trademarks, service marks, or product names of the Licensor,
-      except as required for reasonable and customary use in describing the
-      origin of the Work and reproducing the content of the NOTICE file.
-
-   7. Disclaimer of Warranty. Unless required by applicable law or
-      agreed to in writing, Licensor provides the Work (and each
-      Contributor provides its Contributions) on an "AS IS" BASIS,
-      WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
-      implied, including, without limitation, any warranties or conditions
-      of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A
-      PARTICULAR PURPOSE. You are solely responsible for determining the
-      appropriateness of using or redistributing the Work and assume any
-      risks associated with Your exercise of permissions under this License.
-
-   8. Limitation of Liability. In no event and under no legal theory,
-      whether in tort (including negligence), contract, or otherwise,
-      unless required by applicable law (such as deliberate and grossly
-      negligent acts) or agreed to in writing, shall any Contributor be
-      liable to You for damages, including any direct, indirect, special,
-      incidental, or consequential damages of any character arising as a
-      result of this License or out of the use or inability to use the
-      Work (including but not limited to damages for loss of goodwill,
-      work stoppage, computer failure or malfunction, or any and all
-      other commercial damages or losses), even if such Contributor
-      has been advised of the possibility of such damages.
-
-   9. Accepting Warranty or Additional Liability. While redistributing
-      the Work or Derivative Works thereof, You may choose to offer,
-      and charge a fee for, acceptance of support, warranty, indemnity,
-      or other liability obligations and/or rights consistent with this
-      License. However, in accepting such obligations, You may act only
-      on Your own behalf and on Your sole responsibility, not on behalf
-      of any other Contributor, and only if You agree to indemnify,
-      defend, and hold each Contributor harmless for any liability
-      incurred by, or claims asserted against, such Contributor by reason
-      of your accepting any such warranty or additional liability.
-
-   END OF TERMS AND CONDITIONS
-
-   APPENDIX: How to apply the Apache License to your work.
-
-      To apply the Apache License to your work, attach the following
-      boilerplate notice, with the fields enclosed by brackets "[]"
-      replaced with your own identifying information. (Don't include
-      the brackets!)  The text should be enclosed in the appropriate
-      comment syntax for the file format. We also recommend that a
-      file or class name and description of purpose be included on the
-      same "printed page" as the copyright notice for easier
-      identification within third-party archives.
-
-   Copyright [yyyy] [name of copyright owner]
-
-   Licensed under the Apache License, Version 2.0 (the "License");
-   you may not use this file except in compliance with the License.
-   You may obtain a copy of the License at
-
-       http://www.apache.org/licenses/LICENSE-2.0
-
-   Unless required by applicable law or agreed to in writing, software
-   distributed under the License is distributed on an "AS IS" BASIS,
-   WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-   See the License for the specific language governing permissions and
-   limitations under the License.
diff --git a/crates/bevy_ecs/LICENSE_MIT b/crates/bevy_ecs/LICENSE_MIT
deleted file mode 100644
index d645695673349..0000000000000
--- a/crates/bevy_ecs/LICENSE_MIT
+++ /dev/null
@@ -1,202 +0,0 @@
-
-                                 Apache License
-                           Version 2.0, January 2004
-                        http://www.apache.org/licenses/
-
-   TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION
-
-   1. Definitions.
-
-      "License" shall mean the terms and conditions for use, reproduction,
-      and distribution as defined by Sections 1 through 9 of this document.
-
-      "Licensor" shall mean the copyright owner or entity authorized by
-      the copyright owner that is granting the License.
-
-      "Legal Entity" shall mean the union of the acting entity and all
-      other entities that control, are controlled by, or are under common
-      control with that entity. For the purposes of this definition,
-      "control" means (i) the power, direct or indirect, to cause the
-      direction or management of such entity, whether by contract or
-      otherwise, or (ii) ownership of fifty percent (50%) or more of the
-      outstanding shares, or (iii) beneficial ownership of such entity.
-
-      "You" (or "Your") shall mean an individual or Legal Entity
-      exercising permissions granted by this License.
-
-      "Source" form shall mean the preferred form for making modifications,
-      including but not limited to software source code, documentation
-      source, and configuration files.
-
-      "Object" form shall mean any form resulting from mechanical
-      transformation or translation of a Source form, including but
-      not limited to compiled object code, generated documentation,
-      and conversions to other media types.
-
-      "Work" shall mean the work of authorship, whether in Source or
-      Object form, made available under the License, as indicated by a
-      copyright notice that is included in or attached to the work
-      (an example is provided in the Appendix below).
-
-      "Derivative Works" shall mean any work, whether in Source or Object
-      form, that is based on (or derived from) the Work and for which the
-      editorial revisions, annotations, elaborations, or other modifications
-      represent, as a whole, an original work of authorship. For the purposes
-      of this License, Derivative Works shall not include works that remain
-      separable from, or merely link (or bind by name) to the interfaces of,
-      the Work and Derivative Works thereof.
-
-      "Contribution" shall mean any work of authorship, including
-      the original version of the Work and any modifications or additions
-      to that Work or Derivative Works thereof, that is intentionally
-      submitted to Licensor for inclusion in the Work by the copyright owner
-      or by an individual or Legal Entity authorized to submit on behalf of
-      the copyright owner. For the purposes of this definition, "submitted"
-      means any form of electronic, verbal, or written communication sent
-      to the Licensor or its representatives, including but not limited to
-      communication on electronic mailing lists, source code control systems,
-      and issue tracking systems that are managed by, or on behalf of, the
-      Licensor for the purpose of discussing and improving the Work, but
-      excluding communication that is conspicuously marked or otherwise
-      designated in writing by the copyright owner as "Not a Contribution."
-
-      "Contributor" shall mean Licensor and any individual or Legal Entity
-      on behalf of whom a Contribution has been received by Licensor and
-      subsequently incorporated within the Work.
-
-   2. Grant of Copyright License. Subject to the terms and conditions of
-      this License, each Contributor hereby grants to You a perpetual,
-      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
-      copyright license to reproduce, prepare Derivative Works of,
-      publicly display, publicly perform, sublicense, and distribute the
-      Work and such Derivative Works in Source or Object form.
-
-   3. Grant of Patent License. Subject to the terms and conditions of
-      this License, each Contributor hereby grants to You a perpetual,
-      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
-      (except as stated in this section) patent license to make, have made,
-      use, offer to sell, sell, import, and otherwise transfer the Work,
-      where such license applies only to those patent claims licensable
-      by such Contributor that are necessarily infringed by their
-      Contribution(s) alone or by combination of their Contribution(s)
-      with the Work to which such Contribution(s) was submitted. If You
-      institute patent litigation against any entity (including a
-      cross-claim or counterclaim in a lawsuit) alleging that the Work
-      or a Contribution incorporated within the Work constitutes direct
-      or contributory patent infringement, then any patent licenses
-      granted to You under this License for that Work shall terminate
-      as of the date such litigation is filed.
-
-   4. Redistribution. You may reproduce and distribute copies of the
-      Work or Derivative Works thereof in any medium, with or without
-      modifications, and in Source or Object form, provided that You
-      meet the following conditions:
-
-      (a) You must give any other recipients of the Work or
-          Derivative Works a copy of this License; and
-
-      (b) You must cause any modified files to carry prominent notices
-          stating that You changed the files; and
-
-      (c) You must retain, in the Source form of any Derivative Works
-          that You distribute, all copyright, patent, trademark, and
-          attribution notices from the Source form of the Work,
-          excluding those notices that do not pertain to any part of
-          the Derivative Works; and
-
-      (d) If the Work includes a "NOTICE" text file as part of its
-          distribution, then any Derivative Works that You distribute must
-          include a readable copy of the attribution notices contained
-          within such NOTICE file, excluding those notices that do not
-          pertain to any part of the Derivative Works, in at least one
-          of the following places: within a NOTICE text file distributed
-          as part of the Derivative Works; within the Source form or
-          documentation, if provided along with the Derivative Works; or,
-          within a display generated by the Derivative Works, if and
-          wherever such third-party notices normally appear. The contents
-          of the NOTICE file are for informational purposes only and
-          do not modify the License. You may add Your own attribution
-          notices within Derivative Works that You distribute, alongside
-          or as an addendum to the NOTICE text from the Work, provided
-          that such additional attribution notices cannot be construed
-          as modifying the License.
-
-      You may add Your own copyright statement to Your modifications and
-      may provide additional or different license terms and conditions
-      for use, reproduction, or distribution of Your modifications, or
-      for any such Derivative Works as a whole, provided Your use,
-      reproduction, and distribution of the Work otherwise complies with
-      the conditions stated in this License.
-
-   5. Submission of Contributions. Unless You explicitly state otherwise,
-      any Contribution intentionally submitted for inclusion in the Work
-      by You to the Licensor shall be under the terms and conditions of
-      this License, without any additional terms or conditions.
-      Notwithstanding the above, nothing herein shall supersede or modify
-      the terms of any separate license agreement you may have executed
-      with Licensor regarding such Contributions.
-
-   6. Trademarks. This License does not grant permission to use the trade
-      names, trademarks, service marks, or product names of the Licensor,
-      except as required for reasonable and customary use in describing the
-      origin of the Work and reproducing the content of the NOTICE file.
-
-   7. Disclaimer of Warranty. Unless required by applicable law or
-      agreed to in writing, Licensor provides the Work (and each
-      Contributor provides its Contributions) on an "AS IS" BASIS,
-      WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
-      implied, including, without limitation, any warranties or conditions
-      of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A
-      PARTICULAR PURPOSE. You are solely responsible for determining the
-      appropriateness of using or redistributing the Work and assume any
-      risks associated with Your exercise of permissions under this License.
-
-   8. Limitation of Liability. In no event and under no legal theory,
-      whether in tort (including negligence), contract, or otherwise,
-      unless required by applicable law (such as deliberate and grossly
-      negligent acts) or agreed to in writing, shall any Contributor be
-      liable to You for damages, including any direct, indirect, special,
-      incidental, or consequential damages of any character arising as a
-      result of this License or out of the use or inability to use the
-      Work (including but not limited to damages for loss of goodwill,
-      work stoppage, computer failure or malfunction, or any and all
-      other commercial damages or losses), even if such Contributor
-      has been advised of the possibility of such damages.
-
-   9. Accepting Warranty or Additional Liability. While redistributing
-      the Work or Derivative Works thereof, You may choose to offer,
-      and charge a fee for, acceptance of support, warranty, indemnity,
-      or other liability obligations and/or rights consistent with this
-      License. However, in accepting such obligations, You may act only
-      on Your own behalf and on Your sole responsibility, not on behalf
-      of any other Contributor, and only if You agree to indemnify,
-      defend, and hold each Contributor harmless for any liability
-      incurred by, or claims asserted against, such Contributor by reason
-      of your accepting any such warranty or additional liability.
-
-   END OF TERMS AND CONDITIONS
-
-   APPENDIX: How to apply the Apache License to your work.
-
-      To apply the Apache License to your work, attach the following
-      boilerplate notice, with the fields enclosed by brackets "[]"
-      replaced with your own identifying information. (Don't include
-      the brackets!)  The text should be enclosed in the appropriate
-      comment syntax for the file format. We also recommend that a
-      file or class name and description of purpose be included on the
-      same "printed page" as the copyright notice for easier
-      identification within third-party archives.
-
-   Copyright [yyyy] [name of copyright owner]
-
-   Licensed under the Apache License, Version 2.0 (the "License");
-   you may not use this file except in compliance with the License.
-   You may obtain a copy of the License at
-
-       http://www.apache.org/licenses/LICENSE-2.0
-
-   Unless required by applicable law or agreed to in writing, software
-   distributed under the License is distributed on an "AS IS" BASIS,
-   WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-   See the License for the specific language governing permissions and
-   limitations under the License.
diff --git a/crates/bevy_ecs/README.md b/crates/bevy_ecs/README.md
deleted file mode 100644
index fdbf6ec0fd832..0000000000000
--- a/crates/bevy_ecs/README.md
+++ /dev/null
@@ -1,7 +0,0 @@
-# Bevy ECS
-
-Bevy Engine's entity component system
-
-## Licensing
-
-Bevy ECS has its roots in hecs, which is licensed as Apache 2.0. All original hecs code is licensed under Apache 2.0. All added/modified code is dual licensed under MIT and Apache 2.0. Files with an Apache 2.0 license header (with Google LLC as the copyright holder) were from the "original hecs" codebase. Files without the header were created by Bevy contributors.
diff --git a/crates/bevy_ecs/macros/Cargo.toml b/crates/bevy_ecs/macros/Cargo.toml
index 007751d323151..3e7f8a80b1847 100644
--- a/crates/bevy_ecs/macros/Cargo.toml
+++ b/crates/bevy_ecs/macros/Cargo.toml
@@ -2,9 +2,12 @@
 name = "bevy_ecs_macros"
 version = "0.4.0"
 description = "Bevy ECS Macros"
-authors = ["Benjamin Saunders <ben.e.saunders@gmail.com>"]
+authors = [
+    "Bevy Contributors <bevyengine@gmail.com>",
+    "Carter Anderson <mcanders1@gmail.com>",
+]
 edition = "2018"
-license = "Apache-2.0"
+license = "MIT"
 
 [lib]
 proc-macro = true
diff --git a/crates/bevy_ecs/macros/src/lib.rs b/crates/bevy_ecs/macros/src/lib.rs
index c3fe34e6ea3f7..588b8df37f396 100644
--- a/crates/bevy_ecs/macros/src/lib.rs
+++ b/crates/bevy_ecs/macros/src/lib.rs
@@ -1,258 +1,172 @@
-// Copyright 2019 Google LLC
-//
-// Licensed under the Apache License, Version 2.0 (the "License");
-// you may not use this file except in compliance with the License.
-// You may obtain a copy of the License at
-//
-//     https://www.apache.org/licenses/LICENSE-2.0
-//
-// Unless required by applicable law or agreed to in writing, software
-// distributed under the License is distributed on an "AS IS" BASIS,
-// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-// See the License for the specific language governing permissions and
-// limitations under the License.
-
-// modified by Bevy contributors
-
 extern crate proc_macro;
 
-use std::borrow::Cow;
-
 use find_crate::{Dependencies, Manifest};
 use proc_macro::TokenStream;
 use proc_macro2::{Span, TokenStream as TokenStream2};
-use quote::quote;
+use quote::{format_ident, quote};
 use syn::{
-    parse::ParseStream, parse_macro_input, punctuated::Punctuated, Data, DataStruct, DeriveInput,
-    Error, Field, Fields, GenericParam, Ident, Index, Lifetime, Path, Result, Token,
+    parse::{Parse, ParseStream},
+    parse_macro_input,
+    punctuated::Punctuated,
+    token::Comma,
+    Data, DataStruct, DeriveInput, Field, Fields, GenericParam, Ident, Index, Lifetime, LitInt,
+    Path, Result, Token,
 };
 
-/// Implement `Bundle` for a monomorphic struct
-///
-/// Using derived `Bundle` impls improves spawn performance and can be convenient when combined with
-/// other derives like `serde::Deserialize`.
-#[proc_macro_derive(Bundle)]
-pub fn derive_bundle(input: TokenStream) -> TokenStream {
-    let input = parse_macro_input!(input as DeriveInput);
-    match derive_bundle_(input) {
-        Ok(ts) => ts,
-        Err(e) => e.to_compile_error(),
-    }
-    .into()
+struct AllTuples {
+    macro_ident: Ident,
+    start: usize,
+    end: usize,
+    idents: Vec<Ident>,
 }
 
-#[allow(clippy::cognitive_complexity)]
-fn derive_bundle_(input: DeriveInput) -> Result<TokenStream2> {
-    let ident = input.ident;
-    let data = match input.data {
-        syn::Data::Struct(s) => s,
-        _ => {
-            return Err(Error::new_spanned(
-                ident,
-                "derive(Bundle) does not support enums or unions",
-            ))
+impl Parse for AllTuples {
+    fn parse(input: ParseStream) -> Result<Self> {
+        let macro_ident = input.parse::<Ident>()?;
+        input.parse::<Comma>()?;
+        let start = input.parse::<LitInt>()?.base10_parse()?;
+        input.parse::<Comma>()?;
+        let end = input.parse::<LitInt>()?.base10_parse()?;
+        input.parse::<Comma>()?;
+        let mut idents = Vec::new();
+        idents.push(input.parse::<Ident>()?);
+        while input.parse::<Comma>().is_ok() {
+            idents.push(input.parse::<Ident>()?);
         }
-    };
-    let (tys, field_members) = struct_fields(&data.fields);
-
-    let ecs_path = bevy_ecs_path();
-    let field_idents = member_as_idents(&field_members);
-    let generics = add_additional_bounds_to_generic_params(&ecs_path, input.generics);
-
-    let dyn_bundle_code =
-        gen_dynamic_bundle_impl(&ecs_path, &ident, &generics, &field_members, &tys);
-    let bundle_code = if tys.is_empty() {
-        gen_unit_struct_bundle_impl(&ecs_path, ident, &generics)
-    } else {
-        gen_bundle_impl(
-            &ecs_path,
-            &ident,
-            &generics,
-            &field_members,
-            &field_idents,
-            &tys,
-        )
-    };
-    let mut ts = dyn_bundle_code;
-    ts.extend(bundle_code);
-    Ok(ts)
-}
-
-fn gen_dynamic_bundle_impl(
-    ecs_path: &syn::Path,
-    ident: &syn::Ident,
-    generics: &syn::Generics,
-    field_members: &[syn::Member],
-    tys: &[&syn::Type],
-) -> TokenStream2 {
-    let (impl_generics, ty_generics, where_clause) = generics.split_for_impl();
-    quote! {
-        impl #impl_generics ::#ecs_path::DynamicBundle for #ident #ty_generics #where_clause {
-            fn with_ids<__hecs__T>(&self, f: impl ::std::ops::FnOnce(&[::std::any::TypeId]) -> __hecs__T) -> __hecs__T {
-                <Self as ::#ecs_path::Bundle>::with_static_ids(f)
-            }
-
-            fn type_info(&self) -> ::std::vec::Vec<::#ecs_path::TypeInfo> {
-                <Self as ::#ecs_path::Bundle>::static_type_info()
-            }
 
-            #[allow(clippy::forget_copy)]
-            unsafe fn put(mut self, mut f: impl ::std::ops::FnMut(*mut u8, ::std::any::TypeId, usize) -> bool) {
-                #(
-                    if f((&mut self.#field_members as *mut #tys).cast::<u8>(), ::std::any::TypeId::of::<#tys>(), ::std::mem::size_of::<#tys>()) {
-                        #[allow(clippy::forget_copy)]
-                        ::std::mem::forget(self.#field_members);
-                    }
-                )*
-            }
-        }
+        Ok(AllTuples {
+            macro_ident,
+            start,
+            end,
+            idents,
+        })
     }
 }
 
-fn gen_bundle_impl(
-    ecs_path: &syn::Path,
-    ident: &syn::Ident,
-    generics: &syn::Generics,
-    field_members: &[syn::Member],
-    field_idents: &[Cow<syn::Ident>],
-    tys: &[&syn::Type],
-) -> TokenStream2 {
-    let num_tys = tys.len();
-    let (impl_generics, ty_generics, where_clause) = generics.split_for_impl();
-    let with_static_ids_inner = quote! {
-        {
-            let mut tys = [#((::std::mem::align_of::<#tys>(), ::std::any::TypeId::of::<#tys>())),*];
-            tys.sort_unstable_by(|x, y| {
-                ::std::cmp::Ord::cmp(&x.0, &y.0)
-                    .reverse()
-                    .then(::std::cmp::Ord::cmp(&x.1, &y.1))
+#[proc_macro]
+pub fn all_tuples(input: TokenStream) -> TokenStream {
+    let input = parse_macro_input!(input as AllTuples);
+    let len = input.end - input.start;
+    let mut ident_tuples = Vec::with_capacity(len);
+    for i in input.start..input.end {
+        let idents = input
+            .idents
+            .iter()
+            .map(|ident| format_ident!("{}{}", ident, i));
+        if input.idents.len() < 2 {
+            ident_tuples.push(quote! {
+                #(#idents)*
+            });
+        } else {
+            ident_tuples.push(quote! {
+                (#(#idents),*)
             });
-            let mut ids = [::std::any::TypeId::of::<()>(); #num_tys];
-            for (id, info) in ::std::iter::Iterator::zip(ids.iter_mut(), tys.iter()) {
-                *id = info.1;
-            }
-            ids
-        }
-    };
-    let with_static_ids_body = if generics.params.is_empty() {
-        quote! {
-            ::#ecs_path::lazy_static::lazy_static! {
-                static ref ELEMENTS: [::std::any::TypeId; #num_tys] = {
-                    #with_static_ids_inner
-                };
-            }
-            f(&*ELEMENTS)
         }
-    } else {
+    }
+
+    let macro_ident = &input.macro_ident;
+    let invocations = (input.start..input.end).map(|i| {
+        let ident_tuples = &ident_tuples[0..i];
         quote! {
-            f(&#with_static_ids_inner)
+            #macro_ident!(#(#ident_tuples),*);
         }
-    };
-    quote! {
-        impl #impl_generics ::#ecs_path::Bundle for #ident #ty_generics #where_clause {
-            #[allow(non_camel_case_types)]
-            fn with_static_ids<__hecs__T>(f: impl ::std::ops::FnOnce(&[::std::any::TypeId]) -> __hecs__T) -> __hecs__T {
-                #with_static_ids_body
-            }
+    });
+    TokenStream::from(quote! {
+        #(
+            #invocations
+        )*
+    })
+}
 
-            fn static_type_info() -> ::std::vec::Vec<::#ecs_path::TypeInfo> {
-                let mut info = ::std::vec![#(::#ecs_path::TypeInfo::of::<#tys>()),*];
-                info.sort_unstable();
-                info
-            }
+static BUNDLE_ATTRIBUTE_NAME: &str = "bundle";
 
-            unsafe fn get(
-                mut f: impl ::std::ops::FnMut(::std::any::TypeId, usize) -> ::std::option::Option<::std::ptr::NonNull<u8>>,
-            ) -> ::std::result::Result<Self, ::#ecs_path::MissingComponent> {
-                #(
-                    let #field_idents = f(::std::any::TypeId::of::<#tys>(), ::std::mem::size_of::<#tys>())
-                            .ok_or_else(::#ecs_path::MissingComponent::new::<#tys>)?
-                            .cast::<#tys>()
-                            .as_ptr();
-                )*
-                ::std::result::Result::Ok(Self { #( #field_members: #field_idents.read(), )* })
-            }
-        }
-    }
-}
+#[proc_macro_derive(Bundle, attributes(bundle))]
+pub fn derive_bundle(input: TokenStream) -> TokenStream {
+    let ast = parse_macro_input!(input as DeriveInput);
+    let ecs_path = bevy_ecs_path();
 
-// no reason to generate a static for unit structs
-fn gen_unit_struct_bundle_impl(
-    ecs_path: &syn::Path,
-    ident: syn::Ident,
-    generics: &syn::Generics,
-) -> TokenStream2 {
-    let (impl_generics, ty_generics, where_clause) = generics.split_for_impl();
-    quote! {
-        impl #impl_generics ::#ecs_path::Bundle for #ident #ty_generics #where_clause {
-            #[allow(non_camel_case_types)]
-            fn with_static_ids<__hecs__T>(f: impl ::std::ops::FnOnce(&[::std::any::TypeId]) -> __hecs__T) -> __hecs__T { f(&[]) }
-            fn static_type_info() -> ::std::vec::Vec<::#ecs_path::TypeInfo> { ::std::vec::Vec::new() }
-
-            unsafe fn get(
-                f: impl ::std::ops::FnMut(::std::any::TypeId, usize) -> ::std::option::Option<::std::ptr::NonNull<u8>>,
-            ) -> Result<Self, ::#ecs_path::MissingComponent> {
-                Ok(Self {/* for some reason this works for all unit struct variations */})
-            }
-        }
-    }
-}
+    let named_fields = match &ast.data {
+        Data::Struct(DataStruct {
+            fields: Fields::Named(fields),
+            ..
+        }) => &fields.named,
+        _ => panic!("Expected a struct with named fields."),
+    };
 
-fn make_component_trait_bound(ecs_path: &syn::Path) -> syn::TraitBound {
-    syn::TraitBound {
-        paren_token: None,
-        modifier: syn::TraitBoundModifier::None,
-        lifetimes: None,
-        path: syn::parse_quote!(::#ecs_path::Component),
+    let is_bundle = named_fields
+        .iter()
+        .map(|field| {
+            field
+                .attrs
+                .iter()
+                .any(|a| *a.path.get_ident().as_ref().unwrap() == BUNDLE_ATTRIBUTE_NAME)
+        })
+        .collect::<Vec<bool>>();
+    let field = named_fields
+        .iter()
+        .map(|field| field.ident.as_ref().unwrap())
+        .collect::<Vec<_>>();
+    let field_type = named_fields
+        .iter()
+        .map(|field| &field.ty)
+        .collect::<Vec<_>>();
+
+    let mut field_type_infos = Vec::new();
+    let mut field_get_components = Vec::new();
+    let mut field_from_components = Vec::new();
+    for ((field_type, is_bundle), field) in
+        field_type.iter().zip(is_bundle.iter()).zip(field.iter())
+    {
+        if *is_bundle {
+            field_type_infos.push(quote! {
+                type_info.extend(#field_type::type_info());
+            });
+            field_get_components.push(quote! {
+                self.#field.get_components(&mut func);
+            });
+            field_from_components.push(quote! {
+                #field: #field_type::from_components(&mut func),
+            });
+        } else {
+            field_type_infos.push(quote! {
+                type_info.push(#ecs_path::component::TypeInfo::of::<#field_type>());
+            });
+            field_get_components.push(quote! {
+                func((&mut self.#field as *mut #field_type).cast::<u8>());
+                std::mem::forget(self.#field);
+            });
+            field_from_components.push(quote! {
+                #field: func().cast::<#field_type>().read(),
+            });
+        }
     }
-}
+    let field_len = field.len();
+    let generics = ast.generics;
+    let (impl_generics, ty_generics, _where_clause) = generics.split_for_impl();
+    let struct_name = &ast.ident;
 
-fn add_additional_bounds_to_generic_params(
-    ecs: &syn::Path,
-    mut generics: syn::Generics,
-) -> syn::Generics {
-    generics.type_params_mut().for_each(|tp| {
-        tp.bounds
-            .push(syn::TypeParamBound::Trait(make_component_trait_bound(ecs)))
-    });
-    generics
-}
+    TokenStream::from(quote! {
+        /// SAFE: TypeInfo is returned in field-definition-order. [from_components] and [get_components] use field-definition-order
+        unsafe impl #impl_generics #ecs_path::bundle::Bundle for #struct_name#ty_generics {
+            fn type_info() -> Vec<#ecs_path::component::TypeInfo> {
+                let mut type_info = Vec::with_capacity(#field_len);
+                #(#field_type_infos)*
+                type_info
+            }
 
-fn struct_fields(fields: &syn::Fields) -> (Vec<&syn::Type>, Vec<syn::Member>) {
-    match fields {
-        syn::Fields::Named(ref fields) => fields
-            .named
-            .iter()
-            .map(|f| (&f.ty, syn::Member::Named(f.ident.clone().unwrap())))
-            .unzip(),
-        syn::Fields::Unnamed(ref fields) => fields
-            .unnamed
-            .iter()
-            .enumerate()
-            .map(|(i, f)| {
-                (
-                    &f.ty,
-                    syn::Member::Unnamed(syn::Index {
-                        index: i as u32,
-                        span: Span::call_site(),
-                    }),
-                )
-            })
-            .unzip(),
-        syn::Fields::Unit => (Vec::new(), Vec::new()),
-    }
-}
+            #[allow(unused_variables, unused_mut, non_snake_case)]
+            unsafe fn from_components(mut func: impl FnMut() -> *mut u8) -> Self {
+                Self {
+                    #(#field_from_components)*
+                }
+            }
 
-fn member_as_idents(members: &[syn::Member]) -> Vec<Cow<'_, syn::Ident>> {
-    members
-        .iter()
-        .map(|member| match member {
-            syn::Member::Named(ident) => Cow::Borrowed(ident),
-            &syn::Member::Unnamed(syn::Index { index, span }) => {
-                Cow::Owned(syn::Ident::new(&format!("tuple_field_{}", index), span))
+            #[allow(unused_variables, unused_mut, forget_copy, forget_ref)]
+            fn get_components(mut self, mut func: impl FnMut(*mut u8)) {
+                #(#field_get_components)*
             }
-        })
-        .collect()
+        }
+    })
 }
 
 fn get_idents(fmt_string: fn(usize) -> String, count: usize) -> Vec<Ident> {
@@ -278,19 +192,19 @@ pub fn impl_query_set(_input: TokenStream) -> TokenStream {
     let mut query_fn_muts = Vec::new();
     for i in 0..max_queries {
         let query = &queries[i];
-        let lifetime = &lifetimes[i];
         let filter = &filters[i];
+        let lifetime = &lifetimes[i];
         let fn_name = Ident::new(&format!("q{}", i), Span::call_site());
         let fn_name_mut = Ident::new(&format!("q{}_mut", i), Span::call_site());
         let index = Index::from(i);
         query_fns.push(quote! {
             pub fn #fn_name(&self) -> &Query<#lifetime, #query, #filter> {
-                &self.value.#index
+                &self.0.#index
             }
         });
         query_fn_muts.push(quote! {
             pub fn #fn_name_mut(&mut self) -> &mut Query<#lifetime, #query, #filter> {
-                &mut self.value.#index
+                &mut self.0.#index
             }
         });
     }
@@ -302,26 +216,71 @@ pub fn impl_query_set(_input: TokenStream) -> TokenStream {
         let query_fn = &query_fns[0..query_count];
         let query_fn_mut = &query_fn_muts[0..query_count];
         tokens.extend(TokenStream::from(quote! {
-            impl<#(#lifetime,)* #(#query: WorldQuery,)* #(#filter: QueryFilter,)*> QueryTuple for (#(Query<#lifetime, #query, #filter>,)*) {
-                unsafe fn new(world: &World, component_access: &TypeAccess<ArchetypeComponent>) -> Self {
-                    (
-                        #(
-                            Query::<#query, #filter>::new(
-                                std::mem::transmute(world),
-                                std::mem::transmute(component_access),
-                            ),
-                        )*
-                    )
+            impl<#(#lifetime,)*  #(#query: WorldQuery + 'static,)* #(#filter: WorldQuery + 'static,)*> SystemParam for QuerySet<(#(Query<#lifetime, #query, #filter>,)*)>
+                where #(#filter::Fetch: FilterFetch,)*
+            {
+                type Fetch = QuerySetState<(#(QueryState<#query, #filter>,)*)>;
+            }
+
+            // SAFE: Relevant query ComponentId and ArchetypeComponentId access is applied to SystemState. If any QueryState conflicts
+            // with any prior access, a panic will occur.
+            unsafe impl<#(#query: WorldQuery + 'static,)* #(#filter: WorldQuery + 'static,)*> SystemParamState for QuerySetState<(#(QueryState<#query, #filter>,)*)>
+                where #(#filter::Fetch: FilterFetch,)*
+            {
+                type Config = ();
+                fn init(world: &mut World, system_state: &mut SystemState, config: Self::Config) -> Self {
+                    #(
+                        let mut #query = QueryState::<#query, #filter>::new(world);
+                        assert_component_access_compatibility(
+                            &system_state.name,
+                            std::any::type_name::<#query>(),
+                            std::any::type_name::<#filter>(),
+                            &system_state.component_access_set,
+                            &#query.component_access,
+                            world,
+                        );
+                    )*
+                    #(
+                        system_state
+                            .component_access_set
+                            .add(#query.component_access.clone());
+                        system_state
+                            .archetype_component_access
+                            .extend(&#query.archetype_component_access);
+                    )*
+                    QuerySetState((#(#query,)*))
                 }
 
-                fn get_accesses() -> Vec<QueryAccess> {
-                    vec![
-                        #(QueryAccess::union(vec![<#query::Fetch as Fetch>::access(), #filter::access()]),)*
-                    ]
+                fn new_archetype(&mut self, archetype: &Archetype, system_state: &mut SystemState) {
+                    let (#(#query,)*) = &mut self.0;
+                    #(
+                        #query.new_archetype(archetype);
+                        system_state
+                            .archetype_component_access
+                            .extend(&#query.archetype_component_access);
+                    )*
                 }
             }
 
-            impl<#(#lifetime,)* #(#query: WorldQuery,)* #(#filter: QueryFilter,)*> QuerySet<(#(Query<#lifetime, #query, #filter>,)*)> {
+            impl<'a, #(#query: WorldQuery + 'static,)* #(#filter: WorldQuery + 'static,)*> SystemParamFetch<'a> for QuerySetState<(#(QueryState<#query, #filter>,)*)>
+                where #(#filter::Fetch: FilterFetch,)*
+            {
+                type Item = QuerySet<(#(Query<'a, #query, #filter>,)*)>;
+
+                #[inline]
+                unsafe fn get_param(
+                    state: &'a mut Self,
+                    _system_state: &'a SystemState,
+                    world: &'a World,
+                ) -> Self::Item {
+                    let (#(#query,)*) = &state.0;
+                    QuerySet((#(Query::new(world, #query),)*))
+                }
+            }
+
+            impl<#(#lifetime,)* #(#query: WorldQuery,)* #(#filter: WorldQuery,)*> QuerySet<(#(Query<#lifetime, #query, #filter>,)*)>
+                where #(#filter::Fetch: FilterFetch,)*
+            {
                 #(#query_fn)*
                 #(#query_fn_mut)*
             }
@@ -349,8 +308,7 @@ pub fn derive_system_param(input: TokenStream) -> TokenStream {
         }) => &fields.named,
         _ => panic!("Expected a struct with named fields."),
     };
-
-    let ecs_path = bevy_ecs_path();
+    let path = bevy_ecs_path();
 
     let field_attributes = fields
         .iter()
@@ -378,16 +336,18 @@ pub fn derive_system_param(input: TokenStream) -> TokenStream {
         })
         .collect::<Vec<(&Field, SystemParamFieldAttributes)>>();
     let mut fields = Vec::new();
+    let mut field_indices = Vec::new();
     let mut field_types = Vec::new();
     let mut ignored_fields = Vec::new();
     let mut ignored_field_types = Vec::new();
-    for (field, attrs) in field_attributes.iter() {
+    for (i, (field, attrs)) in field_attributes.iter().enumerate() {
         if attrs.ignore {
             ignored_fields.push(field.ident.as_ref().unwrap());
             ignored_field_types.push(&field.ty);
         } else {
             fields.push(field.ident.as_ref().unwrap());
             field_types.push(&field.ty);
+            field_indices.push(Index::from(i));
         }
     }
 
@@ -400,19 +360,6 @@ pub fn derive_system_param(input: TokenStream) -> TokenStream {
         .filter(|g| matches!(g, GenericParam::Type(_)))
         .collect();
 
-    let phantoms = lifetimeless_generics
-        .iter()
-        .map(|g| {
-            let g = match g {
-                GenericParam::Type(g) => &g.ident,
-                _ => panic!(),
-            };
-            quote! { ::std::marker::PhantomData::<#g>, }
-        })
-        .fold(quote!(), |old, new| {
-            quote! { #old #new }
-        });
-
     let mut punctuated_generics = Punctuated::<_, Token![,]>::new();
     punctuated_generics.extend(lifetimeless_generics.iter());
 
@@ -423,29 +370,43 @@ pub fn derive_system_param(input: TokenStream) -> TokenStream {
     }));
 
     let struct_name = &ast.ident;
-    let fetch_struct_name = Ident::new(&format!("Fetch{}", struct_name), Span::call_site());
+    let fetch_struct_name = Ident::new(&format!("{}State", struct_name), Span::call_site());
 
     TokenStream::from(quote! {
-        pub struct #fetch_struct_name<#punctuated_generics>(#phantoms);
-        impl #impl_generics #ecs_path::SystemParam for #struct_name#ty_generics #where_clause {
-            type Fetch = #fetch_struct_name <#punctuated_generic_idents>;
+        impl #impl_generics #path::system::SystemParam for #struct_name#ty_generics #where_clause {
+            type Fetch = #fetch_struct_name <(#(<#field_types as SystemParam>::Fetch,)*), #punctuated_generic_idents>;
         }
 
-        impl #impl_generics #ecs_path::FetchSystemParam<'a> for #fetch_struct_name<#punctuated_generic_idents> {
-            type Item = #struct_name#ty_generics;
-            fn init(system_state: &mut #ecs_path::SystemState, world: &#ecs_path::World, resources: &mut #ecs_path::Resources) {
-                #(<<#field_types as #ecs_path::SystemParam>::Fetch as #ecs_path::FetchSystemParam>::init(system_state, world, resources);)*
+        pub struct #fetch_struct_name<TSystemParamState, #punctuated_generic_idents> {
+            state: TSystemParamState,
+            marker: std::marker::PhantomData<(#punctuated_generic_idents)>
+        }
+
+        unsafe impl<TSystemParamState: #path::system::SystemParamState, #punctuated_generics> #path::system::SystemParamState for #fetch_struct_name<TSystemParamState, #punctuated_generic_idents> {
+            type Config = TSystemParamState::Config;
+            fn init(world: &mut #path::world::World, system_state: &mut #path::system::SystemState, config: Self::Config) -> Self {
+                Self {
+                    state: TSystemParamState::init(world, system_state, config),
+                    marker: std::marker::PhantomData,
+                }
             }
 
+            fn new_archetype(&mut self, archetype: &#path::archetype::Archetype, system_state: &mut #path::system::SystemState) {
+                self.state.new_archetype(archetype, system_state)
+            }
+        }
+
+        impl #impl_generics #path::system::SystemParamFetch<'a> for #fetch_struct_name <(#(<#field_types as SystemParam>::Fetch,)*), #punctuated_generic_idents> {
+            type Item = #struct_name#ty_generics;
             unsafe fn get_param(
-                system_state: &'a #ecs_path::SystemState,
-                world: &'a #ecs_path::World,
-                resources: &'a #ecs_path::Resources,
-            ) -> Option<Self::Item> {
-                Some(#struct_name {
-                    #(#fields: <<#field_types as #ecs_path::SystemParam>::Fetch as #ecs_path::FetchSystemParam>::get_param(system_state, world, resources)?,)*
+                state: &'a mut Self,
+                system_state: &'a #path::system::SystemState,
+                world: &'a #path::world::World,
+            ) -> Self::Item {
+                #struct_name {
+                    #(#fields: <<#field_types as SystemParam>::Fetch as #path::system::SystemParamFetch>::get_param(&mut state.state.#field_indices, system_state, world),)*
                     #(#ignored_fields: <#ignored_field_types>::default(),)*
-                })
+                }
             }
         }
     })
@@ -474,8 +435,8 @@ fn derive_label(input: DeriveInput, label_type: Ident) -> TokenStream2 {
     let ecs_path: Path = bevy_ecs_path();
 
     quote! {
-        impl #ecs_path::#label_type for #ident {
-            fn dyn_clone(&self) -> Box<dyn #ecs_path::#label_type> {
+        impl #ecs_path::schedule::#label_type for #ident {
+            fn dyn_clone(&self) -> Box<dyn #ecs_path::schedule::#label_type> {
                 Box::new(Clone::clone(self))
             }
         }
diff --git a/crates/bevy_ecs/src/archetype.rs b/crates/bevy_ecs/src/archetype.rs
new file mode 100644
index 0000000000000..ba9220d89037f
--- /dev/null
+++ b/crates/bevy_ecs/src/archetype.rs
@@ -0,0 +1,522 @@
+use crate::{
+    bundle::BundleId,
+    component::{ComponentFlags, ComponentId, StorageType},
+    entity::{Entity, EntityLocation},
+    storage::{Column, SparseArray, SparseSet, SparseSetIndex, TableId},
+};
+use std::{borrow::Cow, collections::HashMap, hash::Hash};
+
+#[derive(Debug, Copy, Clone, Eq, PartialEq, Hash)]
+pub struct ArchetypeId(usize);
+
+impl ArchetypeId {
+    #[inline]
+    pub const fn new(index: usize) -> Self {
+        ArchetypeId(index)
+    }
+
+    #[inline]
+    pub const fn empty() -> ArchetypeId {
+        ArchetypeId(0)
+    }
+
+    #[inline]
+    pub const fn resource() -> ArchetypeId {
+        ArchetypeId(1)
+    }
+
+    #[inline]
+    pub fn index(self) -> usize {
+        self.0
+    }
+}
+
+pub struct FromBundle {
+    pub archetype_id: ArchetypeId,
+    pub bundle_flags: Vec<ComponentFlags>,
+}
+
+#[derive(Default)]
+pub struct Edges {
+    pub add_bundle: SparseArray<BundleId, ArchetypeId>,
+    pub remove_bundle: SparseArray<BundleId, Option<ArchetypeId>>,
+    pub remove_bundle_intersection: SparseArray<BundleId, Option<ArchetypeId>>,
+    pub from_bundle: SparseArray<BundleId, FromBundle>,
+}
+
+impl Edges {
+    #[inline]
+    pub fn get_add_bundle(&self, bundle_id: BundleId) -> Option<ArchetypeId> {
+        self.add_bundle.get(bundle_id).cloned()
+    }
+
+    #[inline]
+    pub fn set_add_bundle(&mut self, bundle_id: BundleId, archetype_id: ArchetypeId) {
+        self.add_bundle.insert(bundle_id, archetype_id);
+    }
+
+    #[inline]
+    pub fn get_from_bundle(&self, bundle_id: BundleId) -> Option<&FromBundle> {
+        self.from_bundle.get(bundle_id)
+    }
+
+    #[inline]
+    pub fn set_from_bundle(
+        &mut self,
+        bundle_id: BundleId,
+        archetype_id: ArchetypeId,
+        bundle_flags: Vec<ComponentFlags>,
+    ) {
+        self.from_bundle.insert(
+            bundle_id,
+            FromBundle {
+                archetype_id,
+                bundle_flags,
+            },
+        );
+    }
+
+    #[inline]
+    pub fn get_remove_bundle(&self, bundle_id: BundleId) -> Option<Option<ArchetypeId>> {
+        self.remove_bundle.get(bundle_id).cloned()
+    }
+
+    #[inline]
+    pub fn set_remove_bundle(&mut self, bundle_id: BundleId, archetype_id: Option<ArchetypeId>) {
+        self.remove_bundle.insert(bundle_id, archetype_id);
+    }
+
+    #[inline]
+    pub fn get_remove_bundle_intersection(
+        &self,
+        bundle_id: BundleId,
+    ) -> Option<Option<ArchetypeId>> {
+        self.remove_bundle_intersection.get(bundle_id).cloned()
+    }
+
+    #[inline]
+    pub fn set_remove_bundle_intersection(
+        &mut self,
+        bundle_id: BundleId,
+        archetype_id: Option<ArchetypeId>,
+    ) {
+        self.remove_bundle_intersection
+            .insert(bundle_id, archetype_id);
+    }
+}
+
+struct TableInfo {
+    id: TableId,
+    entity_rows: Vec<usize>,
+}
+
+pub(crate) struct ArchetypeSwapRemoveResult {
+    pub swapped_entity: Option<Entity>,
+    pub table_row: usize,
+}
+
+pub(crate) struct ArchetypeComponentInfo {
+    pub(crate) storage_type: StorageType,
+    pub(crate) archetype_component_id: ArchetypeComponentId,
+}
+
+pub struct Archetype {
+    id: ArchetypeId,
+    entities: Vec<Entity>,
+    edges: Edges,
+    table_info: TableInfo,
+    table_components: Cow<'static, [ComponentId]>,
+    sparse_set_components: Cow<'static, [ComponentId]>,
+    pub(crate) unique_components: SparseSet<ComponentId, Column>,
+    pub(crate) components: SparseSet<ComponentId, ArchetypeComponentInfo>,
+}
+
+impl Archetype {
+    pub fn new(
+        id: ArchetypeId,
+        table_id: TableId,
+        table_components: Cow<'static, [ComponentId]>,
+        sparse_set_components: Cow<'static, [ComponentId]>,
+        table_archetype_components: Vec<ArchetypeComponentId>,
+        sparse_set_archetype_components: Vec<ArchetypeComponentId>,
+    ) -> Self {
+        let mut components =
+            SparseSet::with_capacity(table_components.len() + sparse_set_components.len());
+        for (component_id, archetype_component_id) in
+            table_components.iter().zip(table_archetype_components)
+        {
+            components.insert(
+                *component_id,
+                ArchetypeComponentInfo {
+                    storage_type: StorageType::Table,
+                    archetype_component_id,
+                },
+            );
+        }
+
+        for (component_id, archetype_component_id) in sparse_set_components
+            .iter()
+            .zip(sparse_set_archetype_components)
+        {
+            components.insert(
+                *component_id,
+                ArchetypeComponentInfo {
+                    storage_type: StorageType::SparseSet,
+                    archetype_component_id,
+                },
+            );
+        }
+        Self {
+            id,
+            table_info: TableInfo {
+                id: table_id,
+                entity_rows: Default::default(),
+            },
+            components,
+            table_components,
+            sparse_set_components,
+            unique_components: SparseSet::new(),
+            entities: Default::default(),
+            edges: Default::default(),
+        }
+    }
+
+    #[inline]
+    pub fn id(&self) -> ArchetypeId {
+        self.id
+    }
+
+    #[inline]
+    pub fn table_id(&self) -> TableId {
+        self.table_info.id
+    }
+
+    #[inline]
+    pub fn entities(&self) -> &[Entity] {
+        &self.entities
+    }
+
+    #[inline]
+    pub fn entity_table_rows(&self) -> &[usize] {
+        &self.table_info.entity_rows
+    }
+
+    #[inline]
+    pub fn table_components(&self) -> &[ComponentId] {
+        &self.table_components
+    }
+
+    #[inline]
+    pub fn sparse_set_components(&self) -> &[ComponentId] {
+        &self.sparse_set_components
+    }
+
+    #[inline]
+    pub fn unique_components(&self) -> &SparseSet<ComponentId, Column> {
+        &self.unique_components
+    }
+
+    #[inline]
+    pub fn unique_components_mut(&mut self) -> &mut SparseSet<ComponentId, Column> {
+        &mut self.unique_components
+    }
+
+    #[inline]
+    pub fn components(&self) -> impl Iterator<Item = ComponentId> + '_ {
+        self.components.indices()
+    }
+
+    #[inline]
+    pub fn edges(&self) -> &Edges {
+        &self.edges
+    }
+
+    #[inline]
+    pub(crate) fn edges_mut(&mut self) -> &mut Edges {
+        &mut self.edges
+    }
+
+    #[inline]
+    pub fn entity_table_row(&self, index: usize) -> usize {
+        self.table_info.entity_rows[index]
+    }
+
+    #[inline]
+    pub fn set_entity_table_row(&mut self, index: usize, table_row: usize) {
+        self.table_info.entity_rows[index] = table_row;
+    }
+
+    /// # Safety
+    /// valid component values must be immediately written to the relevant storages
+    /// `table_row` must be valid
+    pub unsafe fn allocate(&mut self, entity: Entity, table_row: usize) -> EntityLocation {
+        self.entities.push(entity);
+        self.table_info.entity_rows.push(table_row);
+
+        EntityLocation {
+            archetype_id: self.id,
+            index: self.entities.len() - 1,
+        }
+    }
+
+    pub fn reserve(&mut self, additional: usize) {
+        self.entities.reserve(additional);
+        self.table_info.entity_rows.reserve(additional);
+    }
+
+    /// Removes the entity at `index` by swapping it out. Returns the table row the entity is stored in.
+    pub(crate) fn swap_remove(&mut self, index: usize) -> ArchetypeSwapRemoveResult {
+        let is_last = index == self.entities.len() - 1;
+        self.entities.swap_remove(index);
+        ArchetypeSwapRemoveResult {
+            swapped_entity: if is_last {
+                None
+            } else {
+                Some(self.entities[index])
+            },
+            table_row: self.table_info.entity_rows.swap_remove(index),
+        }
+    }
+
+    #[inline]
+    pub fn len(&self) -> usize {
+        self.entities.len()
+    }
+
+    #[inline]
+    pub fn is_empty(&self) -> bool {
+        self.entities.is_empty()
+    }
+
+    #[inline]
+    pub fn contains(&self, component_id: ComponentId) -> bool {
+        self.components.contains(component_id)
+    }
+
+    #[inline]
+    pub fn get_storage_type(&self, component_id: ComponentId) -> Option<StorageType> {
+        self.components
+            .get(component_id)
+            .map(|info| info.storage_type)
+    }
+
+    #[inline]
+    pub fn get_archetype_component_id(
+        &self,
+        component_id: ComponentId,
+    ) -> Option<ArchetypeComponentId> {
+        self.components
+            .get(component_id)
+            .map(|info| info.archetype_component_id)
+    }
+}
+
+/// A generational id that changes every time the set of archetypes changes
+#[derive(Debug, Copy, Clone, Eq, PartialEq)]
+pub struct ArchetypeGeneration(usize);
+
+impl ArchetypeGeneration {
+    #[inline]
+    pub fn new(generation: usize) -> Self {
+        ArchetypeGeneration(generation)
+    }
+
+    #[inline]
+    pub fn value(self) -> usize {
+        self.0
+    }
+}
+
+#[derive(Hash, PartialEq, Eq)]
+pub struct ArchetypeIdentity {
+    table_components: Cow<'static, [ComponentId]>,
+    sparse_set_components: Cow<'static, [ComponentId]>,
+}
+
+#[derive(Debug, Copy, Clone, Eq, PartialEq, Hash)]
+pub struct ArchetypeComponentId(usize);
+
+impl ArchetypeComponentId {
+    #[inline]
+    pub const fn new(index: usize) -> Self {
+        Self(index)
+    }
+
+    #[inline]
+    pub fn index(self) -> usize {
+        self.0
+    }
+}
+
+impl SparseSetIndex for ArchetypeComponentId {
+    #[inline]
+    fn sparse_set_index(&self) -> usize {
+        self.0
+    }
+
+    fn get_sparse_set_index(value: usize) -> Self {
+        Self(value)
+    }
+}
+
+pub struct Archetypes {
+    pub(crate) archetypes: Vec<Archetype>,
+    pub(crate) archetype_component_count: usize,
+    archetype_ids: HashMap<ArchetypeIdentity, ArchetypeId>,
+}
+
+impl Default for Archetypes {
+    fn default() -> Self {
+        let mut archetypes = Archetypes {
+            archetypes: Vec::new(),
+            archetype_ids: Default::default(),
+            archetype_component_count: 0,
+        };
+        archetypes.get_id_or_insert(TableId::empty(), Vec::new(), Vec::new());
+
+        // adds the resource archetype. it is "special" in that it is inaccessible via a "hash", which prevents entities from
+        // being added to it
+        archetypes.archetypes.push(Archetype::new(
+            ArchetypeId::resource(),
+            TableId::empty(),
+            Cow::Owned(Vec::new()),
+            Cow::Owned(Vec::new()),
+            Vec::new(),
+            Vec::new(),
+        ));
+        archetypes
+    }
+}
+
+impl Archetypes {
+    #[inline]
+    pub fn generation(&self) -> ArchetypeGeneration {
+        ArchetypeGeneration(self.archetypes.len())
+    }
+
+    #[inline]
+    pub fn len(&self) -> usize {
+        self.archetypes.len()
+    }
+
+    #[inline]
+    pub fn empty(&self) -> &Archetype {
+        // SAFE: empty archetype always exists
+        unsafe { self.archetypes.get_unchecked(ArchetypeId::empty().index()) }
+    }
+
+    #[inline]
+    pub fn empty_mut(&mut self) -> &mut Archetype {
+        // SAFE: empty archetype always exists
+        unsafe {
+            self.archetypes
+                .get_unchecked_mut(ArchetypeId::empty().index())
+        }
+    }
+
+    #[inline]
+    pub fn resource(&self) -> &Archetype {
+        // SAFE: resource archetype always exists
+        unsafe {
+            self.archetypes
+                .get_unchecked(ArchetypeId::resource().index())
+        }
+    }
+
+    #[inline]
+    pub fn resource_mut(&mut self) -> &mut Archetype {
+        // SAFE: resource archetype always exists
+        unsafe {
+            self.archetypes
+                .get_unchecked_mut(ArchetypeId::resource().index())
+        }
+    }
+
+    #[inline]
+    pub fn is_empty(&self) -> bool {
+        self.archetypes.is_empty()
+    }
+
+    #[inline]
+    pub fn get(&self, id: ArchetypeId) -> Option<&Archetype> {
+        self.archetypes.get(id.index())
+    }
+
+    /// # Safety
+    /// `id` must be valid
+    #[inline]
+    pub unsafe fn get_unchecked(&self, id: ArchetypeId) -> &Archetype {
+        debug_assert!(id.index() < self.archetypes.len());
+        self.archetypes.get_unchecked(id.index())
+    }
+
+    #[inline]
+    pub fn get_mut(&mut self, id: ArchetypeId) -> Option<&mut Archetype> {
+        self.archetypes.get_mut(id.index())
+    }
+
+    /// # Safety
+    /// `id` must be valid
+    #[inline]
+    pub unsafe fn get_unchecked_mut(&mut self, id: ArchetypeId) -> &mut Archetype {
+        debug_assert!(id.index() < self.archetypes.len());
+        self.archetypes.get_unchecked_mut(id.index())
+    }
+
+    #[inline]
+    pub fn iter(&self) -> impl Iterator<Item = &Archetype> {
+        self.archetypes.iter()
+    }
+
+    /// Gets the archetype id matching the given inputs or inserts a new one if it doesn't exist.
+    /// `table_components` and `sparse_set_components` must be sorted
+    /// # Safety
+    /// TableId must exist in tables
+    pub(crate) fn get_id_or_insert(
+        &mut self,
+        table_id: TableId,
+        table_components: Vec<ComponentId>,
+        sparse_set_components: Vec<ComponentId>,
+    ) -> ArchetypeId {
+        let table_components = Cow::from(table_components);
+        let sparse_set_components = Cow::from(sparse_set_components);
+        let archetype_identity = ArchetypeIdentity {
+            sparse_set_components: sparse_set_components.clone(),
+            table_components: table_components.clone(),
+        };
+
+        let archetypes = &mut self.archetypes;
+        let archetype_component_count = &mut self.archetype_component_count;
+        let mut next_archetype_component_id = move || {
+            let id = ArchetypeComponentId(*archetype_component_count);
+            *archetype_component_count += 1;
+            id
+        };
+        *self
+            .archetype_ids
+            .entry(archetype_identity)
+            .or_insert_with(move || {
+                let id = ArchetypeId(archetypes.len());
+                let table_archetype_components = (0..table_components.len())
+                    .map(|_| next_archetype_component_id())
+                    .collect();
+                let sparse_set_archetype_components = (0..sparse_set_components.len())
+                    .map(|_| next_archetype_component_id())
+                    .collect();
+                archetypes.push(Archetype::new(
+                    id,
+                    table_id,
+                    table_components,
+                    sparse_set_components,
+                    table_archetype_components,
+                    sparse_set_archetype_components,
+                ));
+                id
+            })
+    }
+
+    #[inline]
+    pub fn archetype_components_len(&self) -> usize {
+        self.archetype_component_count
+    }
+}
diff --git a/crates/bevy_ecs/src/bundle.rs b/crates/bevy_ecs/src/bundle.rs
new file mode 100644
index 0000000000000..71c222a377af1
--- /dev/null
+++ b/crates/bevy_ecs/src/bundle.rs
@@ -0,0 +1,207 @@
+pub use bevy_ecs_macros::Bundle;
+
+use crate::{
+    component::{Component, ComponentFlags, ComponentId, Components, StorageType, TypeInfo},
+    entity::Entity,
+    storage::{SparseSetIndex, SparseSets, Table},
+};
+use bevy_ecs_macros::all_tuples;
+use std::{any::TypeId, collections::HashMap};
+
+/// An ordered collection of components
+///
+/// See [Bundle]
+/// # Safety
+/// [Bundle::type_info] must return the TypeInfo for each component type in the bundle, in the _exact_
+/// order that [Bundle::get_components] is called.
+/// [Bundle::from_components] must call `func` exactly once for each [TypeInfo] returned by [Bundle::type_info]
+pub unsafe trait Bundle: Send + Sync + 'static {
+    /// Gets this [Bundle]'s components type info, in the order of this bundle's Components
+    fn type_info() -> Vec<TypeInfo>;
+
+    /// Calls `func`, which should return data for each component in the bundle, in the order of this bundle's Components
+    /// # Safety
+    /// Caller must return data for each component in the bundle, in the order of this bundle's Components
+    unsafe fn from_components(func: impl FnMut() -> *mut u8) -> Self
+    where
+        Self: Sized;
+
+    /// Calls `func` on each value, in the order of this bundle's Components. This will "mem::forget" the bundle
+    /// fields, so callers are responsible for dropping the fields if that is desirable.
+    fn get_components(self, func: impl FnMut(*mut u8));
+}
+
+macro_rules! tuple_impl {
+    ($($name: ident),*) => {
+        /// SAFE: TypeInfo is returned in tuple-order. [Bundle::from_components] and [Bundle::get_components] use tuple-order
+        unsafe impl<$($name: Component),*> Bundle for ($($name,)*) {
+            fn type_info() -> Vec<TypeInfo> {
+                vec![$(TypeInfo::of::<$name>()),*]
+            }
+
+            #[allow(unused_variables, unused_mut)]
+            unsafe fn from_components(mut func: impl FnMut() -> *mut u8) -> Self {
+                #[allow(non_snake_case)]
+                let ($(mut $name,)*) = (
+                    $(func().cast::<$name>(),)*
+                );
+                ($($name.read(),)*)
+            }
+
+            #[allow(unused_variables, unused_mut)]
+            fn get_components(self, mut func: impl FnMut(*mut u8)) {
+                #[allow(non_snake_case)]
+                let ($(mut $name,)*) = self;
+                $(
+                    func((&mut $name as *mut $name).cast::<u8>());
+                    std::mem::forget($name);
+                )*
+            }
+        }
+    }
+}
+
+all_tuples!(tuple_impl, 0, 15, C);
+
+#[derive(Debug, Clone, Copy)]
+pub struct BundleId(usize);
+
+impl BundleId {
+    #[inline]
+    pub fn index(self) -> usize {
+        self.0
+    }
+}
+
+impl SparseSetIndex for BundleId {
+    #[inline]
+    fn sparse_set_index(&self) -> usize {
+        self.index()
+    }
+
+    fn get_sparse_set_index(value: usize) -> Self {
+        Self(value)
+    }
+}
+
+pub struct BundleInfo {
+    pub(crate) id: BundleId,
+    pub(crate) component_ids: Vec<ComponentId>,
+    pub(crate) storage_types: Vec<StorageType>,
+}
+
+impl BundleInfo {
+    /// # Safety
+    /// table row must exist, entity must be valid
+    #[inline]
+    pub(crate) unsafe fn write_components<T: Bundle>(
+        &self,
+        sparse_sets: &mut SparseSets,
+        entity: Entity,
+        table: &Table,
+        table_row: usize,
+        bundle_flags: &[ComponentFlags],
+        bundle: T,
+    ) {
+        // NOTE: get_components calls this closure on each component in "bundle order". bundle_info.component_ids are also in "bundle order"
+        let mut bundle_component = 0;
+        bundle.get_components(|component_ptr| {
+            // SAFE: component_id was initialized by get_dynamic_bundle_info
+            let component_id = *self.component_ids.get_unchecked(bundle_component);
+            let flags = *bundle_flags.get_unchecked(bundle_component);
+            match self.storage_types[bundle_component] {
+                StorageType::Table => {
+                    let column = table.get_column(component_id).unwrap();
+                    column.set_unchecked(table_row, component_ptr);
+                    column.get_flags_unchecked_mut(table_row).insert(flags);
+                }
+                StorageType::SparseSet => {
+                    let sparse_set = sparse_sets.get_mut(component_id).unwrap();
+                    sparse_set.insert(entity, component_ptr, flags);
+                }
+            }
+            bundle_component += 1;
+        });
+    }
+
+    #[inline]
+    pub fn id(&self) -> BundleId {
+        self.id
+    }
+
+    #[inline]
+    pub fn components(&self) -> &[ComponentId] {
+        &self.component_ids
+    }
+
+    #[inline]
+    pub fn storage_types(&self) -> &[StorageType] {
+        &self.storage_types
+    }
+}
+
+#[derive(Default)]
+pub struct Bundles {
+    bundle_infos: Vec<BundleInfo>,
+    bundle_ids: HashMap<TypeId, BundleId>,
+}
+
+impl Bundles {
+    #[inline]
+    pub fn get(&self, bundle_id: BundleId) -> Option<&BundleInfo> {
+        self.bundle_infos.get(bundle_id.index())
+    }
+
+    #[inline]
+    pub fn get_id(&self, type_id: TypeId) -> Option<BundleId> {
+        self.bundle_ids.get(&type_id).cloned()
+    }
+
+    pub(crate) fn init_info<'a, T: Bundle>(
+        &'a mut self,
+        components: &mut Components,
+    ) -> &'a BundleInfo {
+        let bundle_infos = &mut self.bundle_infos;
+        let id = self.bundle_ids.entry(TypeId::of::<T>()).or_insert_with(|| {
+            let type_info = T::type_info();
+            let id = BundleId(bundle_infos.len());
+            let bundle_info =
+                initialize_bundle(std::any::type_name::<T>(), &type_info, id, components);
+            bundle_infos.push(bundle_info);
+            id
+        });
+        // SAFE: index either exists, or was initialized
+        unsafe { self.bundle_infos.get_unchecked(id.0) }
+    }
+}
+
+fn initialize_bundle(
+    bundle_type_name: &'static str,
+    type_info: &[TypeInfo],
+    id: BundleId,
+    components: &mut Components,
+) -> BundleInfo {
+    let mut component_ids = Vec::new();
+    let mut storage_types = Vec::new();
+
+    for type_info in type_info {
+        let component_id = components.get_or_insert_with(type_info.type_id(), || type_info.clone());
+        // SAFE: get_with_type_info ensures info was created
+        let info = unsafe { components.get_info_unchecked(component_id) };
+        component_ids.push(component_id);
+        storage_types.push(info.storage_type());
+    }
+
+    let mut deduped = component_ids.clone();
+    deduped.sort();
+    deduped.dedup();
+    if deduped.len() != component_ids.len() {
+        panic!("Bundle {} has duplicate components", bundle_type_name);
+    }
+
+    BundleInfo {
+        id,
+        component_ids,
+        storage_types,
+    }
+}
diff --git a/crates/bevy_ecs/src/component/mod.rs b/crates/bevy_ecs/src/component/mod.rs
new file mode 100644
index 0000000000000..914030eff4771
--- /dev/null
+++ b/crates/bevy_ecs/src/component/mod.rs
@@ -0,0 +1,296 @@
+mod type_info;
+
+pub use type_info::*;
+
+use crate::storage::SparseSetIndex;
+use bitflags::bitflags;
+use std::{
+    alloc::Layout,
+    any::{Any, TypeId},
+    collections::hash_map::Entry,
+};
+use thiserror::Error;
+
+pub trait Component: Send + Sync + 'static {}
+impl<T: Send + Sync + 'static> Component for T {}
+
+#[derive(Debug, Copy, Clone, Eq, PartialEq)]
+pub enum StorageType {
+    Table,
+    SparseSet,
+}
+
+impl Default for StorageType {
+    fn default() -> Self {
+        StorageType::Table
+    }
+}
+
+#[derive(Debug)]
+pub struct ComponentInfo {
+    name: String,
+    id: ComponentId,
+    type_id: Option<TypeId>,
+    // SAFETY: This must remain private. It must only be set to "true" if this component is actually Send + Sync
+    is_send_and_sync: bool,
+    layout: Layout,
+    drop: unsafe fn(*mut u8),
+    storage_type: StorageType,
+}
+
+impl ComponentInfo {
+    #[inline]
+    pub fn id(&self) -> ComponentId {
+        self.id
+    }
+
+    #[inline]
+    pub fn name(&self) -> &str {
+        &self.name
+    }
+
+    #[inline]
+    pub fn type_id(&self) -> Option<TypeId> {
+        self.type_id
+    }
+
+    #[inline]
+    pub fn layout(&self) -> Layout {
+        self.layout
+    }
+
+    #[inline]
+    pub fn drop(&self) -> unsafe fn(*mut u8) {
+        self.drop
+    }
+
+    #[inline]
+    pub fn storage_type(&self) -> StorageType {
+        self.storage_type
+    }
+
+    #[inline]
+    pub fn is_send_and_sync(&self) -> bool {
+        self.is_send_and_sync
+    }
+
+    fn new(id: ComponentId, descriptor: ComponentDescriptor) -> Self {
+        ComponentInfo {
+            id,
+            name: descriptor.name,
+            storage_type: descriptor.storage_type,
+            type_id: descriptor.type_id,
+            is_send_and_sync: descriptor.is_send_and_sync,
+            drop: descriptor.drop,
+            layout: descriptor.layout,
+        }
+    }
+}
+
+#[derive(Debug, Copy, Clone, Hash, Ord, PartialOrd, Eq, PartialEq)]
+pub struct ComponentId(usize);
+
+impl ComponentId {
+    #[inline]
+    pub const fn new(index: usize) -> ComponentId {
+        ComponentId(index)
+    }
+
+    #[inline]
+    pub fn index(self) -> usize {
+        self.0
+    }
+}
+
+impl SparseSetIndex for ComponentId {
+    #[inline]
+    fn sparse_set_index(&self) -> usize {
+        self.index()
+    }
+
+    fn get_sparse_set_index(value: usize) -> Self {
+        Self(value)
+    }
+}
+
+pub struct ComponentDescriptor {
+    name: String,
+    storage_type: StorageType,
+    // SAFETY: This must remain private. It must only be set to "true" if this component is actually Send + Sync
+    is_send_and_sync: bool,
+    type_id: Option<TypeId>,
+    layout: Layout,
+    drop: unsafe fn(*mut u8),
+}
+
+impl ComponentDescriptor {
+    pub fn new<T: Component>(storage_type: StorageType) -> Self {
+        Self {
+            name: std::any::type_name::<T>().to_string(),
+            storage_type,
+            is_send_and_sync: true,
+            type_id: Some(TypeId::of::<T>()),
+            layout: Layout::new::<T>(),
+            drop: TypeInfo::drop_ptr::<T>,
+        }
+    }
+
+    #[inline]
+    pub fn storage_type(&self) -> StorageType {
+        self.storage_type
+    }
+
+    #[inline]
+    pub fn type_id(&self) -> Option<TypeId> {
+        self.type_id
+    }
+
+    #[inline]
+    pub fn name(&self) -> &str {
+        &self.name
+    }
+}
+
+impl From<TypeInfo> for ComponentDescriptor {
+    fn from(type_info: TypeInfo) -> Self {
+        Self {
+            name: type_info.type_name().to_string(),
+            storage_type: StorageType::default(),
+            is_send_and_sync: type_info.is_send_and_sync(),
+            type_id: Some(type_info.type_id()),
+            drop: type_info.drop(),
+            layout: type_info.layout(),
+        }
+    }
+}
+
+#[derive(Debug, Default)]
+pub struct Components {
+    components: Vec<ComponentInfo>,
+    indices: std::collections::HashMap<TypeId, usize, fxhash::FxBuildHasher>,
+    resource_indices: std::collections::HashMap<TypeId, usize, fxhash::FxBuildHasher>,
+}
+
+#[derive(Debug, Error)]
+pub enum ComponentsError {
+    #[error("A component of type {0:?} already exists")]
+    ComponentAlreadyExists(TypeId),
+}
+
+impl Components {
+    pub(crate) fn add(
+        &mut self,
+        descriptor: ComponentDescriptor,
+    ) -> Result<ComponentId, ComponentsError> {
+        let index = self.components.len();
+        if let Some(type_id) = descriptor.type_id {
+            let index_entry = self.indices.entry(type_id);
+            if let Entry::Occupied(_) = index_entry {
+                return Err(ComponentsError::ComponentAlreadyExists(type_id));
+            }
+            self.indices.insert(type_id, index);
+        }
+        self.components
+            .push(ComponentInfo::new(ComponentId(index), descriptor));
+
+        Ok(ComponentId(index))
+    }
+
+    #[inline]
+    pub fn get_or_insert_id<T: Component>(&mut self) -> ComponentId {
+        self.get_or_insert_with(TypeId::of::<T>(), TypeInfo::of::<T>)
+    }
+
+    #[inline]
+    pub fn get_or_insert_info<T: Component>(&mut self) -> &ComponentInfo {
+        let id = self.get_or_insert_id::<T>();
+        // SAFE: component_info with the given `id` initialized above
+        unsafe { self.get_info_unchecked(id) }
+    }
+
+    #[inline]
+    pub fn len(&self) -> usize {
+        self.components.len()
+    }
+
+    #[inline]
+    pub fn is_empty(&self) -> bool {
+        self.components.len() == 0
+    }
+
+    #[inline]
+    pub fn get_info(&self, id: ComponentId) -> Option<&ComponentInfo> {
+        self.components.get(id.0)
+    }
+
+    /// # Safety
+    /// `id` must be a valid [ComponentId]
+    #[inline]
+    pub unsafe fn get_info_unchecked(&self, id: ComponentId) -> &ComponentInfo {
+        debug_assert!(id.index() < self.components.len());
+        self.components.get_unchecked(id.0)
+    }
+
+    #[inline]
+    pub fn get_id(&self, type_id: TypeId) -> Option<ComponentId> {
+        self.indices.get(&type_id).map(|index| ComponentId(*index))
+    }
+
+    #[inline]
+    pub fn get_resource_id(&self, type_id: TypeId) -> Option<ComponentId> {
+        self.resource_indices
+            .get(&type_id)
+            .map(|index| ComponentId(*index))
+    }
+
+    #[inline]
+    pub fn get_or_insert_resource_id<T: Component>(&mut self) -> ComponentId {
+        self.get_or_insert_resource_with(TypeId::of::<T>(), TypeInfo::of::<T>)
+    }
+
+    #[inline]
+    pub fn get_or_insert_non_send_resource_id<T: Any>(&mut self) -> ComponentId {
+        self.get_or_insert_resource_with(TypeId::of::<T>(), TypeInfo::of_non_send_and_sync::<T>)
+    }
+
+    #[inline]
+    fn get_or_insert_resource_with(
+        &mut self,
+        type_id: TypeId,
+        func: impl FnOnce() -> TypeInfo,
+    ) -> ComponentId {
+        let components = &mut self.components;
+        let index = self.resource_indices.entry(type_id).or_insert_with(|| {
+            let type_info = func();
+            let index = components.len();
+            components.push(ComponentInfo::new(ComponentId(index), type_info.into()));
+            index
+        });
+
+        ComponentId(*index)
+    }
+
+    #[inline]
+    pub(crate) fn get_or_insert_with(
+        &mut self,
+        type_id: TypeId,
+        func: impl FnOnce() -> TypeInfo,
+    ) -> ComponentId {
+        let components = &mut self.components;
+        let index = self.indices.entry(type_id).or_insert_with(|| {
+            let type_info = func();
+            let index = components.len();
+            components.push(ComponentInfo::new(ComponentId(index), type_info.into()));
+            index
+        });
+
+        ComponentId(*index)
+    }
+}
+
+bitflags! {
+    pub struct ComponentFlags: u8 {
+        const ADDED = 1;
+        const MUTATED = 2;
+    }
+}
diff --git a/crates/bevy_ecs/src/component/type_info.rs b/crates/bevy_ecs/src/component/type_info.rs
new file mode 100644
index 0000000000000..ca83036b4cd13
--- /dev/null
+++ b/crates/bevy_ecs/src/component/type_info.rs
@@ -0,0 +1,63 @@
+use std::{alloc::Layout, any::TypeId};
+
+/// Metadata required to store a component
+#[derive(Debug, Clone, PartialEq, Eq)]
+pub struct TypeInfo {
+    type_id: TypeId,
+    layout: Layout,
+    drop: unsafe fn(*mut u8),
+    type_name: &'static str,
+    is_send_and_sync: bool,
+}
+
+impl TypeInfo {
+    /// Metadata for `T`
+    pub fn of<T: Send + Sync + 'static>() -> Self {
+        Self {
+            type_id: TypeId::of::<T>(),
+            layout: Layout::new::<T>(),
+            is_send_and_sync: true,
+            drop: Self::drop_ptr::<T>,
+            type_name: core::any::type_name::<T>(),
+        }
+    }
+
+    pub fn of_non_send_and_sync<T: 'static>() -> Self {
+        Self {
+            type_id: TypeId::of::<T>(),
+            layout: Layout::new::<T>(),
+            is_send_and_sync: false,
+            drop: Self::drop_ptr::<T>,
+            type_name: core::any::type_name::<T>(),
+        }
+    }
+
+    #[inline]
+    pub fn type_id(&self) -> TypeId {
+        self.type_id
+    }
+
+    #[inline]
+    pub fn layout(&self) -> Layout {
+        self.layout
+    }
+
+    #[inline]
+    pub fn drop(&self) -> unsafe fn(*mut u8) {
+        self.drop
+    }
+
+    #[inline]
+    pub fn is_send_and_sync(&self) -> bool {
+        self.is_send_and_sync
+    }
+
+    #[inline]
+    pub fn type_name(&self) -> &'static str {
+        self.type_name
+    }
+
+    pub(crate) unsafe fn drop_ptr<T>(x: *mut u8) {
+        x.cast::<T>().drop_in_place()
+    }
+}
diff --git a/crates/bevy_ecs/src/core/access.rs b/crates/bevy_ecs/src/core/access.rs
deleted file mode 100644
index e382e9b1577ec..0000000000000
--- a/crates/bevy_ecs/src/core/access.rs
+++ /dev/null
@@ -1,472 +0,0 @@
-use bevy_utils::HashSet;
-use fixedbitset::FixedBitSet;
-use std::{any::TypeId, boxed::Box, hash::Hash, vec::Vec};
-
-use super::{Archetype, World};
-
-#[derive(Debug, Copy, Clone, Ord, PartialOrd, Eq, PartialEq)]
-enum ArchetypeAccess {
-    None,
-    Read,
-    Write,
-}
-
-#[derive(Copy, Clone, Debug, Eq, PartialEq, Hash)]
-pub struct ArchetypeComponent {
-    pub archetype_index: u32,
-    pub component: TypeId,
-}
-
-impl ArchetypeComponent {
-    #[inline]
-    pub fn new<T: 'static>(archetype_index: u32) -> Self {
-        ArchetypeComponent {
-            archetype_index,
-            component: TypeId::of::<T>(),
-        }
-    }
-
-    #[inline]
-    pub fn new_ty(archetype_index: u32, component: TypeId) -> Self {
-        ArchetypeComponent {
-            archetype_index,
-            component,
-        }
-    }
-}
-
-pub enum QueryAccess {
-    None,
-    Read(TypeId, &'static str),
-    Write(TypeId, &'static str),
-    Optional(Box<QueryAccess>),
-    With(TypeId, Box<QueryAccess>),
-    Without(TypeId, Box<QueryAccess>),
-    Union(Vec<QueryAccess>),
-}
-
-impl QueryAccess {
-    pub fn read<T: 'static>() -> QueryAccess {
-        QueryAccess::Read(TypeId::of::<T>(), std::any::type_name::<T>())
-    }
-
-    pub fn write<T: 'static>() -> QueryAccess {
-        QueryAccess::Write(TypeId::of::<T>(), std::any::type_name::<T>())
-    }
-
-    pub fn with<T: 'static>(access: QueryAccess) -> QueryAccess {
-        QueryAccess::With(TypeId::of::<T>(), Box::new(access))
-    }
-
-    pub fn without<T: 'static>(access: QueryAccess) -> QueryAccess {
-        QueryAccess::Without(TypeId::of::<T>(), Box::new(access))
-    }
-
-    pub fn optional(access: QueryAccess) -> QueryAccess {
-        QueryAccess::Optional(Box::new(access))
-    }
-
-    pub fn union(accesses: Vec<QueryAccess>) -> QueryAccess {
-        QueryAccess::Union(accesses)
-    }
-
-    pub fn get_world_archetype_access(
-        &self,
-        world: &World,
-        mut type_access: Option<&mut TypeAccess<ArchetypeComponent>>,
-    ) {
-        let archetypes = world.archetypes();
-        for (i, archetype) in archetypes.enumerate() {
-            let type_access = type_access.as_deref_mut();
-            let _ = self.get_access(archetype, i as u32, type_access);
-        }
-    }
-
-    pub fn get_component_access(&self, type_access: &mut TypeAccess<TypeId>) {
-        match self {
-            QueryAccess::None => {}
-            QueryAccess::Read(ty, _) => type_access.add_read(*ty),
-            QueryAccess::Write(ty, _) => type_access.add_write(*ty),
-            QueryAccess::Optional(access) => access.get_component_access(type_access),
-            QueryAccess::With(_, access) => access.get_component_access(type_access),
-            QueryAccess::Without(_, access) => access.get_component_access(type_access),
-            QueryAccess::Union(accesses) => {
-                for access in accesses {
-                    access.get_component_access(type_access);
-                }
-            }
-        }
-    }
-
-    pub fn get_type_name(&self, type_id: TypeId) -> Option<&'static str> {
-        match self {
-            QueryAccess::None => None,
-            QueryAccess::Read(current_type_id, name) => {
-                if type_id == *current_type_id {
-                    Some(*name)
-                } else {
-                    None
-                }
-            }
-            QueryAccess::Write(current_type_id, name) => {
-                if type_id == *current_type_id {
-                    Some(*name)
-                } else {
-                    None
-                }
-            }
-            QueryAccess::Optional(query_access) => query_access.get_type_name(type_id),
-            QueryAccess::With(_, query_access) => query_access.get_type_name(type_id),
-            QueryAccess::Without(_, query_access) => query_access.get_type_name(type_id),
-            QueryAccess::Union(query_accesses) => {
-                for query_access in query_accesses.iter() {
-                    if let Some(name) = query_access.get_type_name(type_id) {
-                        return Some(name);
-                    }
-                }
-
-                None
-            }
-        }
-    }
-
-    /// Returns how this [QueryAccess] accesses the given `archetype`.
-    /// If `type_access` is set, it will populate type access with the types this query reads/writes
-    fn get_access(
-        &self,
-        archetype: &Archetype,
-        archetype_index: u32,
-        type_access: Option<&mut TypeAccess<ArchetypeComponent>>,
-    ) -> Option<ArchetypeAccess> {
-        match self {
-            QueryAccess::None => Some(ArchetypeAccess::None),
-            QueryAccess::Read(ty, _) => {
-                if archetype.has_type(*ty) {
-                    if let Some(type_access) = type_access {
-                        type_access.add_read(ArchetypeComponent::new_ty(archetype_index, *ty));
-                    }
-                    Some(ArchetypeAccess::Read)
-                } else {
-                    None
-                }
-            }
-            QueryAccess::Write(ty, _) => {
-                if archetype.has_type(*ty) {
-                    if let Some(type_access) = type_access {
-                        type_access.add_write(ArchetypeComponent::new_ty(archetype_index, *ty));
-                    }
-                    Some(ArchetypeAccess::Write)
-                } else {
-                    None
-                }
-            }
-            QueryAccess::Optional(query_access) => {
-                if let Some(access) = query_access.get_access(archetype, archetype_index, None) {
-                    // only re-run get_archetype_access if we need to set type_access
-                    if type_access.is_some() {
-                        query_access.get_access(archetype, archetype_index, type_access)
-                    } else {
-                        Some(access)
-                    }
-                } else {
-                    Some(ArchetypeAccess::Read)
-                }
-            }
-            QueryAccess::With(ty, query_access) => {
-                if archetype.has_type(*ty) {
-                    query_access.get_access(archetype, archetype_index, type_access)
-                } else {
-                    None
-                }
-            }
-            QueryAccess::Without(ty, query_access) => {
-                if !archetype.has_type(*ty) {
-                    query_access.get_access(archetype, archetype_index, type_access)
-                } else {
-                    None
-                }
-            }
-            QueryAccess::Union(query_accesses) => {
-                let mut result = None;
-                for query_access in query_accesses {
-                    if let Some(access) = query_access.get_access(archetype, archetype_index, None)
-                    {
-                        result = Some(result.unwrap_or(ArchetypeAccess::Read).max(access));
-                    } else {
-                        return None;
-                    }
-                }
-
-                // only set the type access if there is a full match
-                if let Some(type_access) = type_access {
-                    if result.is_some() {
-                        for query_access in query_accesses {
-                            query_access.get_access(archetype, archetype_index, Some(type_access));
-                        }
-                    }
-                }
-
-                result
-            }
-        }
-    }
-}
-
-/// Provides information about the types a [System](crate::System) reads and writes
-#[derive(Debug, Eq, PartialEq, Clone)]
-pub struct TypeAccess<T: Hash + Eq + PartialEq> {
-    reads_all: bool,
-    reads_and_writes: HashSet<T>,
-    writes: HashSet<T>,
-}
-
-impl<T: Hash + Eq + PartialEq> Default for TypeAccess<T> {
-    fn default() -> Self {
-        Self {
-            reads_all: false,
-            reads_and_writes: Default::default(),
-            writes: Default::default(),
-        }
-    }
-}
-
-impl<T: Hash + Eq + PartialEq + Copy> TypeAccess<T> {
-    pub fn new(reads: Vec<T>, writes: Vec<T>) -> Self {
-        let mut type_access = TypeAccess::default();
-        for write in writes {
-            type_access.add_write(write);
-        }
-        for read in reads {
-            type_access.add_read(read);
-        }
-        type_access
-    }
-
-    pub fn is_compatible(&self, other: &TypeAccess<T>) -> bool {
-        if self.reads_all {
-            other.writes.is_empty()
-        } else if other.reads_all {
-            self.writes.is_empty()
-        } else {
-            self.writes.is_disjoint(&other.reads_and_writes)
-                && self.reads_and_writes.is_disjoint(&other.writes)
-        }
-    }
-
-    pub fn get_conflict<'a>(&'a self, other: &'a TypeAccess<T>) -> Option<&'a T> {
-        if self.reads_all {
-            other.writes.iter().next()
-        } else if other.reads_all {
-            self.writes.iter().next()
-        } else {
-            match self.writes.intersection(&other.reads_and_writes).next() {
-                Some(element) => Some(element),
-                None => other.writes.intersection(&self.reads_and_writes).next(),
-            }
-        }
-    }
-
-    pub fn extend(&mut self, other: &TypeAccess<T>) {
-        self.reads_all = self.reads_all || other.reads_all;
-        self.writes.extend(&other.writes);
-        self.reads_and_writes.extend(&other.reads_and_writes);
-    }
-
-    pub fn add_read(&mut self, ty: T) {
-        self.reads_and_writes.insert(ty);
-    }
-
-    pub fn add_write(&mut self, ty: T) {
-        self.reads_and_writes.insert(ty);
-        self.writes.insert(ty);
-    }
-
-    pub fn read_all(&mut self) {
-        self.reads_all = true;
-    }
-
-    pub fn clear(&mut self) {
-        self.reads_all = false;
-        self.reads_and_writes.clear();
-        self.writes.clear();
-    }
-
-    pub fn is_read_or_write(&self, ty: &T) -> bool {
-        self.reads_all || self.reads_and_writes.contains(ty)
-    }
-
-    pub fn is_write(&self, ty: &T) -> bool {
-        self.writes.contains(ty)
-    }
-
-    pub fn reads_all(&self) -> bool {
-        self.reads_all
-    }
-
-    /// Returns an iterator of distinct accessed types if only some types are accessed.
-    pub fn all_distinct_types(&self) -> Option<impl Iterator<Item = &T>> {
-        if !self.reads_all {
-            return Some(self.reads_and_writes.iter());
-        }
-        None
-    }
-
-    pub fn condense(&self, all_types: &[T]) -> CondensedTypeAccess {
-        if self.reads_all {
-            let mut writes = FixedBitSet::with_capacity(all_types.len());
-            for (index, access_type) in all_types.iter().enumerate() {
-                if self.writes.contains(access_type) {
-                    writes.insert(index);
-                }
-            }
-            CondensedTypeAccess {
-                reads_all: true,
-                reads_and_writes: Default::default(),
-                writes,
-            }
-        } else {
-            let mut reads_and_writes = FixedBitSet::with_capacity(all_types.len());
-            let mut writes = FixedBitSet::with_capacity(all_types.len());
-            for (index, access_type) in all_types.iter().enumerate() {
-                if self.writes.contains(access_type) {
-                    reads_and_writes.insert(index);
-                    writes.insert(index);
-                } else if self.reads_and_writes.contains(access_type) {
-                    reads_and_writes.insert(index);
-                }
-            }
-            CondensedTypeAccess {
-                reads_all: false,
-                reads_and_writes,
-                writes,
-            }
-        }
-    }
-}
-
-// TODO: consider making it typed, to enable compiler helping with bug hunting?
-#[derive(Default, Debug, Eq, PartialEq, Clone)]
-pub struct CondensedTypeAccess {
-    reads_all: bool,
-    reads_and_writes: FixedBitSet,
-    writes: FixedBitSet,
-}
-
-impl CondensedTypeAccess {
-    pub fn grow(&mut self, bits: usize) {
-        self.reads_and_writes.grow(bits);
-        self.writes.grow(bits);
-    }
-
-    pub fn reads_all(&self) -> bool {
-        self.reads_all
-    }
-
-    pub fn clear(&mut self) {
-        self.reads_all = false;
-        self.reads_and_writes.clear();
-        self.writes.clear();
-    }
-
-    pub fn extend(&mut self, other: &CondensedTypeAccess) {
-        self.reads_all = self.reads_all || other.reads_all;
-        self.reads_and_writes.union_with(&other.reads_and_writes);
-        self.writes.union_with(&other.writes);
-    }
-
-    pub fn is_compatible(&self, other: &CondensedTypeAccess) -> bool {
-        if self.reads_all {
-            0 == other.writes.count_ones(..)
-        } else if other.reads_all {
-            0 == self.writes.count_ones(..)
-        } else {
-            self.writes.is_disjoint(&other.reads_and_writes)
-                && self.reads_and_writes.is_disjoint(&other.writes)
-        }
-    }
-}
-
-#[cfg(test)]
-mod tests {
-    use super::{ArchetypeComponent, TypeAccess};
-    use crate::{core::World, Entity, Fetch, QueryAccess, WorldQuery};
-    use std::vec;
-
-    struct A;
-    #[derive(Clone, Eq, PartialEq, Debug)]
-    struct B;
-    struct C;
-
-    #[test]
-    fn query_type_access() {
-        let mut world = World::default();
-        let e1 = world.spawn((A,));
-        let e2 = world.spawn((A, B));
-        let e3 = world.spawn((A, B, C));
-
-        let e1_archetype = world.get_entity_location(e1).unwrap().archetype;
-        let e2_archetype = world.get_entity_location(e2).unwrap().archetype;
-        let e3_archetype = world.get_entity_location(e3).unwrap().archetype;
-
-        let e1_a = ArchetypeComponent::new::<A>(e1_archetype);
-        let e2_a = ArchetypeComponent::new::<A>(e2_archetype);
-        let e2_b = ArchetypeComponent::new::<B>(e2_archetype);
-        let e3_a = ArchetypeComponent::new::<A>(e3_archetype);
-        let e3_b = ArchetypeComponent::new::<B>(e3_archetype);
-        let e3_c = ArchetypeComponent::new::<C>(e3_archetype);
-
-        let mut a_type_access = TypeAccess::default();
-        <(&A,) as WorldQuery>::Fetch::access()
-            .get_world_archetype_access(&world, Some(&mut a_type_access));
-
-        assert_eq!(
-            a_type_access,
-            TypeAccess::new(vec![e1_a, e2_a, e3_a], vec![])
-        );
-
-        let mut a_b_type_access = TypeAccess::default();
-        <(&A, &B) as WorldQuery>::Fetch::access()
-            .get_world_archetype_access(&world, Some(&mut a_b_type_access));
-
-        assert_eq!(
-            a_b_type_access,
-            TypeAccess::new(vec![e2_a, e2_b, e3_a, e3_b], vec![])
-        );
-
-        let mut a_bmut_type_access = TypeAccess::default();
-        <(&A, &mut B) as WorldQuery>::Fetch::access()
-            .get_world_archetype_access(&world, Some(&mut a_bmut_type_access));
-
-        assert_eq!(
-            a_bmut_type_access,
-            TypeAccess::new(vec![e2_a, e3_a], vec![e2_b, e3_b])
-        );
-
-        let mut a_option_bmut_type_access = TypeAccess::default();
-        <(Entity, &A, Option<&mut B>) as WorldQuery>::Fetch::access()
-            .get_world_archetype_access(&world, Some(&mut a_option_bmut_type_access));
-
-        assert_eq!(
-            a_option_bmut_type_access,
-            TypeAccess::new(vec![e1_a, e2_a, e3_a], vec![e2_b, e3_b])
-        );
-
-        let mut a_with_b_type_access = TypeAccess::default();
-        QueryAccess::with::<B>(<&A as WorldQuery>::Fetch::access())
-            .get_world_archetype_access(&world, Some(&mut a_with_b_type_access));
-
-        assert_eq!(
-            a_with_b_type_access,
-            TypeAccess::new(vec![e2_a, e3_a], vec![])
-        );
-
-        let mut a_with_b_option_c_type_access = TypeAccess::default();
-        QueryAccess::with::<B>(<(&A, Option<&mut C>) as WorldQuery>::Fetch::access())
-            .get_world_archetype_access(&world, Some(&mut a_with_b_option_c_type_access));
-
-        assert_eq!(
-            a_with_b_option_c_type_access,
-            TypeAccess::new(vec![e2_a, e3_a], vec![e3_c])
-        );
-    }
-}
diff --git a/crates/bevy_ecs/src/core/archetype.rs b/crates/bevy_ecs/src/core/archetype.rs
deleted file mode 100644
index 21d44ee5acebc..0000000000000
--- a/crates/bevy_ecs/src/core/archetype.rs
+++ /dev/null
@@ -1,557 +0,0 @@
-// Copyright 2019 Google LLC
-//
-// Licensed under the Apache License, Version 2.0 (the "License");
-// you may not use this file except in compliance with the License.
-// You may obtain a copy of the License at
-//
-//     https://www.apache.org/licenses/LICENSE-2.0
-//
-// Unless required by applicable law or agreed to in writing, software
-// distributed under the License is distributed on an "AS IS" BASIS,
-// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-// See the License for the specific language governing permissions and
-// limitations under the License.
-
-// modified by Bevy contributors
-
-use crate::{AtomicBorrow, Component, Entity};
-use bitflags::bitflags;
-use std::{
-    alloc::{alloc, dealloc, Layout},
-    any::{type_name, TypeId},
-    cell::UnsafeCell,
-    collections::HashMap,
-    mem,
-    ptr::{self, NonNull},
-};
-
-/// A collection of entities having the same component types
-///
-/// Accessing `Archetype`s is only required for complex dynamic scheduling. To manipulate entities,
-/// go through the `World`.
-#[derive(Debug)]
-pub struct Archetype {
-    types: Vec<TypeInfo>,
-    state: TypeIdMap<TypeState>,
-    len: usize,
-    entities: Vec<Entity>,
-    // UnsafeCell allows unique references into `data` to be constructed while shared references
-    // containing the `Archetype` exist
-    data: UnsafeCell<NonNull<u8>>,
-    data_size: usize,
-    grow_size: usize,
-}
-
-impl Archetype {
-    fn assert_type_info(types: &[TypeInfo]) {
-        types.windows(2).for_each(|x| match x[0].cmp(&x[1]) {
-            core::cmp::Ordering::Less => (),
-            #[cfg(debug_assertions)]
-            core::cmp::Ordering::Equal => panic!(
-                "attempted to allocate entity with duplicate {} components; \
-                 each type must occur at most once!",
-                x[0].type_name
-            ),
-            #[cfg(not(debug_assertions))]
-            core::cmp::Ordering::Equal => panic!(
-                "attempted to allocate entity with duplicate components; \
-                 each type must occur at most once!"
-            ),
-            core::cmp::Ordering::Greater => panic!("Type info is unsorted."),
-        });
-    }
-
-    #[allow(missing_docs)]
-    pub fn new(types: Vec<TypeInfo>) -> Self {
-        Self::with_grow(types, 64)
-    }
-
-    #[allow(missing_docs)]
-    pub fn with_grow(types: Vec<TypeInfo>, grow_size: usize) -> Self {
-        Self::assert_type_info(&types);
-        let mut state = HashMap::with_capacity_and_hasher(types.len(), Default::default());
-        for ty in &types {
-            state.insert(ty.id, TypeState::new());
-        }
-        Self {
-            state,
-            types,
-            entities: Vec::new(),
-            len: 0,
-            data: UnsafeCell::new(NonNull::dangling()),
-            data_size: 0,
-            grow_size,
-        }
-    }
-
-    pub(crate) fn clear(&mut self) {
-        for ty in &self.types {
-            for index in 0..self.len {
-                unsafe {
-                    let removed = self
-                        .get_dynamic(ty.id, ty.layout.size(), index)
-                        .unwrap()
-                        .as_ptr();
-                    (ty.drop)(removed);
-                }
-            }
-        }
-        self.len = 0;
-    }
-
-    #[allow(missing_docs)]
-    #[inline]
-    pub fn has<T: Component>(&self) -> bool {
-        self.has_dynamic(TypeId::of::<T>())
-    }
-
-    #[allow(missing_docs)]
-    #[inline]
-    pub fn has_type(&self, ty: TypeId) -> bool {
-        self.has_dynamic(ty)
-    }
-
-    pub(crate) fn has_dynamic(&self, id: TypeId) -> bool {
-        self.state.contains_key(&id)
-    }
-
-    #[allow(missing_docs)]
-    #[inline]
-    pub fn get<T: Component>(&self) -> Option<NonNull<T>> {
-        let state = self.state.get(&TypeId::of::<T>())?;
-        Some(unsafe {
-            NonNull::new_unchecked(
-                (*self.data.get()).as_ptr().add(state.offset).cast::<T>() as *mut T
-            )
-        })
-    }
-
-    #[allow(missing_docs)]
-    #[inline]
-    pub fn get_with_type_state<T: Component>(&self) -> Option<(NonNull<T>, &TypeState)> {
-        let state = self.state.get(&TypeId::of::<T>())?;
-        Some(unsafe {
-            (
-                NonNull::new_unchecked(
-                    (*self.data.get()).as_ptr().add(state.offset).cast::<T>() as *mut T
-                ),
-                state,
-            )
-        })
-    }
-
-    #[allow(missing_docs)]
-    pub fn get_type_state(&self, ty: TypeId) -> Option<&TypeState> {
-        self.state.get(&ty)
-    }
-
-    #[allow(missing_docs)]
-    pub fn get_type_state_mut(&mut self, ty: TypeId) -> Option<&mut TypeState> {
-        self.state.get_mut(&ty)
-    }
-
-    #[allow(missing_docs)]
-    #[inline]
-    pub fn borrow<T: Component>(&self) {
-        if self
-            .state
-            .get(&TypeId::of::<T>())
-            .map_or(false, |x| !x.borrow.borrow())
-        {
-            panic!("{} already borrowed uniquely.", type_name::<T>());
-        }
-    }
-
-    #[allow(missing_docs)]
-    #[inline]
-    pub fn borrow_mut<T: Component>(&self) {
-        if self
-            .state
-            .get(&TypeId::of::<T>())
-            .map_or(false, |x| !x.borrow.borrow_mut())
-        {
-            panic!("{} already borrowed.", type_name::<T>());
-        }
-    }
-
-    #[allow(missing_docs)]
-    #[inline]
-    pub fn release<T: Component>(&self) {
-        if let Some(x) = self.state.get(&TypeId::of::<T>()) {
-            x.borrow.release();
-        }
-    }
-
-    #[allow(missing_docs)]
-    #[inline]
-    pub fn release_mut<T: Component>(&self) {
-        if let Some(x) = self.state.get(&TypeId::of::<T>()) {
-            x.borrow.release_mut();
-        }
-    }
-
-    #[allow(missing_docs)]
-    #[inline]
-    pub fn len(&self) -> usize {
-        self.len
-    }
-
-    #[allow(missing_docs)]
-    #[inline]
-    pub fn is_empty(&self) -> bool {
-        self.len == 0
-    }
-
-    #[allow(missing_docs)]
-    pub fn iter_entities(&self) -> impl Iterator<Item = &Entity> {
-        self.entities.iter().take(self.len)
-    }
-
-    #[inline]
-    pub(crate) fn entities(&self) -> NonNull<Entity> {
-        unsafe { NonNull::new_unchecked(self.entities.as_ptr() as *mut _) }
-    }
-
-    pub(crate) fn get_entity(&self, index: usize) -> Entity {
-        self.entities[index]
-    }
-
-    #[allow(missing_docs)]
-    pub fn types(&self) -> &[TypeInfo] {
-        &self.types
-    }
-
-    /// # Safety
-    /// `index` must be in-bounds
-    pub unsafe fn get_dynamic(&self, ty: TypeId, size: usize, index: usize) -> Option<NonNull<u8>> {
-        debug_assert!(index < self.len);
-        Some(NonNull::new_unchecked(
-            (*self.data.get())
-                .as_ptr()
-                .add(self.state.get(&ty)?.offset + size * index)
-                .cast::<u8>(),
-        ))
-    }
-
-    /// # Safety
-    /// Every type must be written immediately after this call
-    pub unsafe fn allocate(&mut self, id: Entity) -> usize {
-        if self.len == self.entities.len() {
-            self.grow(self.len.max(self.grow_size));
-        }
-
-        self.entities[self.len] = id;
-        self.len += 1;
-        self.len - 1
-    }
-
-    pub(crate) fn reserve(&mut self, additional: usize) {
-        if additional > (self.capacity() - self.len()) {
-            self.grow(additional - (self.capacity() - self.len()));
-        }
-    }
-
-    fn capacity(&self) -> usize {
-        self.entities.len()
-    }
-
-    #[allow(missing_docs)]
-    pub fn clear_trackers(&mut self) {
-        for type_state in self.state.values_mut() {
-            type_state.clear_trackers();
-        }
-    }
-
-    fn grow(&mut self, increment: usize) {
-        unsafe {
-            let old_count = self.len;
-            let new_capacity = self.capacity() + increment;
-            self.entities.resize(
-                new_capacity,
-                Entity {
-                    id: u32::MAX,
-                    generation: u32::MAX,
-                },
-            );
-
-            for type_state in self.state.values_mut() {
-                type_state
-                    .component_flags
-                    .resize_with(new_capacity, ComponentFlags::empty);
-            }
-
-            let old_data_size = mem::replace(&mut self.data_size, 0);
-            let mut old_offsets = Vec::with_capacity(self.types.len());
-            for ty in &self.types {
-                self.data_size = align(self.data_size, ty.layout.align());
-                let ty_state = self.state.get_mut(&ty.id).unwrap();
-                old_offsets.push(ty_state.offset);
-                ty_state.offset = self.data_size;
-                self.data_size += ty.layout.size() * new_capacity;
-            }
-            let new_data = if self.data_size == 0 {
-                NonNull::dangling()
-            } else {
-                NonNull::new(alloc(
-                    Layout::from_size_align(
-                        self.data_size,
-                        self.types.first().map_or(1, |x| x.layout.align()),
-                    )
-                    .unwrap(),
-                ))
-                .unwrap()
-            };
-            if old_data_size != 0 {
-                for (i, ty) in self.types.iter().enumerate() {
-                    let old_off = old_offsets[i];
-                    let new_off = self.state.get(&ty.id).unwrap().offset;
-                    ptr::copy_nonoverlapping(
-                        (*self.data.get()).as_ptr().add(old_off),
-                        new_data.as_ptr().add(new_off),
-                        ty.layout.size() * old_count,
-                    );
-                }
-                dealloc(
-                    (*self.data.get()).as_ptr().cast(),
-                    Layout::from_size_align_unchecked(
-                        old_data_size,
-                        self.types.first().map_or(1, |x| x.layout.align()),
-                    ),
-                );
-            }
-
-            self.data = UnsafeCell::new(new_data);
-        }
-    }
-
-    /// Returns the ID of the entity moved into `index`, if any
-    pub(crate) unsafe fn remove(&mut self, index: usize) -> Option<Entity> {
-        let last = self.len - 1;
-        for ty in &self.types {
-            let removed = self
-                .get_dynamic(ty.id, ty.layout.size(), index)
-                .unwrap()
-                .as_ptr();
-            (ty.drop)(removed);
-            if index != last {
-                // TODO: copy component tracker state here
-                ptr::copy_nonoverlapping(
-                    self.get_dynamic(ty.id, ty.layout.size(), last)
-                        .unwrap()
-                        .as_ptr(),
-                    removed,
-                    ty.layout.size(),
-                );
-
-                let type_state = self.state.get_mut(&ty.id).unwrap();
-                type_state.component_flags[index] = type_state.component_flags[last];
-            }
-        }
-        self.len = last;
-        if index != last {
-            self.entities[index] = self.entities[last];
-            Some(self.entities[last])
-        } else {
-            None
-        }
-    }
-
-    /// Returns the ID of the entity moved into `index`, if any
-    pub(crate) unsafe fn move_to(
-        &mut self,
-        index: usize,
-        mut f: impl FnMut(*mut u8, TypeId, usize, ComponentFlags),
-    ) -> Option<Entity> {
-        let last = self.len - 1;
-        for ty in &self.types {
-            let moved = self
-                .get_dynamic(ty.id, ty.layout.size(), index)
-                .unwrap()
-                .as_ptr();
-            let type_state = self.state.get(&ty.id).unwrap();
-            let flags = type_state.component_flags[index];
-            f(moved, ty.id(), ty.layout().size(), flags);
-            if index != last {
-                ptr::copy_nonoverlapping(
-                    self.get_dynamic(ty.id, ty.layout.size(), last)
-                        .unwrap()
-                        .as_ptr(),
-                    moved,
-                    ty.layout.size(),
-                );
-                let type_state = self.state.get_mut(&ty.id).unwrap();
-                type_state.component_flags[index] = type_state.component_flags[last];
-            }
-        }
-        self.len -= 1;
-        if index != last {
-            self.entities[index] = self.entities[last];
-            Some(self.entities[last])
-        } else {
-            None
-        }
-    }
-
-    /// # Safety
-    ///
-    ///  - `component` must point to valid memory
-    ///  - the component `ty`pe must be registered
-    ///  - `index` must be in-bound
-    ///  - `size` must be the size of the component
-    ///  - the storage array must be big enough
-    pub unsafe fn put_dynamic(
-        &mut self,
-        component: *mut u8,
-        ty: TypeId,
-        size: usize,
-        index: usize,
-        flags: ComponentFlags,
-    ) {
-        let state = self.state.get_mut(&ty).unwrap();
-        state.component_flags[index] = flags;
-        let ptr = (*self.data.get())
-            .as_ptr()
-            .add(state.offset + size * index)
-            .cast::<u8>();
-        ptr::copy_nonoverlapping(component, ptr, size);
-    }
-}
-
-impl Drop for Archetype {
-    fn drop(&mut self) {
-        self.clear();
-        if self.data_size != 0 {
-            unsafe {
-                dealloc(
-                    (*self.data.get()).as_ptr().cast(),
-                    Layout::from_size_align_unchecked(
-                        self.data_size,
-                        self.types.first().map_or(1, |x| x.layout.align()),
-                    ),
-                );
-            }
-        }
-    }
-}
-
-/// Metadata about a type stored in an archetype
-#[derive(Debug)]
-pub struct TypeState {
-    offset: usize,
-    borrow: AtomicBorrow,
-    component_flags: Vec<ComponentFlags>,
-}
-
-bitflags! {
-    pub struct ComponentFlags: u8 {
-        const ADDED = 1;
-        const MUTATED = 2;
-    }
-}
-
-impl TypeState {
-    fn new() -> Self {
-        Self {
-            offset: 0,
-            borrow: AtomicBorrow::new(),
-            component_flags: Vec::new(),
-        }
-    }
-
-    fn clear_trackers(&mut self) {
-        for flags in self.component_flags.iter_mut() {
-            *flags = ComponentFlags::empty();
-        }
-    }
-
-    #[allow(missing_docs)]
-    #[inline]
-    pub fn component_flags(&self) -> NonNull<ComponentFlags> {
-        unsafe { NonNull::new_unchecked(self.component_flags.as_ptr() as *mut ComponentFlags) }
-    }
-}
-
-/// Metadata required to store a component
-#[derive(Debug, Copy, Clone)]
-pub struct TypeInfo {
-    id: TypeId,
-    layout: Layout,
-    drop: unsafe fn(*mut u8),
-    type_name: &'static str,
-}
-
-impl TypeInfo {
-    /// Metadata for `T`
-    pub fn of<T: 'static>() -> Self {
-        unsafe fn drop_ptr<T>(x: *mut u8) {
-            x.cast::<T>().drop_in_place()
-        }
-
-        Self {
-            id: TypeId::of::<T>(),
-            layout: Layout::new::<T>(),
-            drop: drop_ptr::<T>,
-            type_name: core::any::type_name::<T>(),
-        }
-    }
-
-    #[allow(missing_docs)]
-    #[inline]
-    pub fn id(&self) -> TypeId {
-        self.id
-    }
-
-    #[allow(missing_docs)]
-    #[inline]
-    pub fn layout(&self) -> Layout {
-        self.layout
-    }
-
-    pub(crate) unsafe fn drop(&self, data: *mut u8) {
-        (self.drop)(data)
-    }
-
-    #[allow(missing_docs)]
-    #[inline]
-    pub fn type_name(&self) -> &'static str {
-        self.type_name
-    }
-}
-
-impl PartialOrd for TypeInfo {
-    fn partial_cmp(&self, other: &Self) -> Option<core::cmp::Ordering> {
-        Some(self.cmp(other))
-    }
-}
-
-impl Ord for TypeInfo {
-    /// Order by alignment, descending. Ties broken with TypeId.
-    fn cmp(&self, other: &Self) -> core::cmp::Ordering {
-        self.layout
-            .align()
-            .cmp(&other.layout.align())
-            .reverse()
-            .then_with(|| self.id.cmp(&other.id))
-    }
-}
-
-impl PartialEq for TypeInfo {
-    fn eq(&self, other: &Self) -> bool {
-        self.id == other.id
-    }
-}
-
-impl Eq for TypeInfo {}
-
-fn align(x: usize, alignment: usize) -> usize {
-    debug_assert!(alignment.is_power_of_two());
-    (x + alignment - 1) & (!alignment + 1)
-}
-
-/// A hasher optimized for hashing a single TypeId.
-///
-/// We don't use RandomState from std or Random state from Ahash
-/// because fxhash is [proved to be faster](https://github.com/bevyengine/bevy/pull/1119#issuecomment-751361215)
-/// and we don't need Hash Dos attack protection here
-/// since TypeIds generated during compilation and there is no reason to user attack himself.
-pub(crate) type TypeIdMap<V> = HashMap<TypeId, V, fxhash::FxBuildHasher>;
diff --git a/crates/bevy_ecs/src/core/borrow.rs b/crates/bevy_ecs/src/core/borrow.rs
deleted file mode 100644
index d1e677509b121..0000000000000
--- a/crates/bevy_ecs/src/core/borrow.rs
+++ /dev/null
@@ -1,222 +0,0 @@
-// Copyright 2019 Google LLC
-//
-// Licensed under the Apache License, Version 2.0 (the "License");
-// you may not use this file except in compliance with the License.
-// You may obtain a copy of the License at
-//
-//     https://www.apache.org/licenses/LICENSE-2.0
-//
-// Unless required by applicable law or agreed to in writing, software
-// distributed under the License is distributed on an "AS IS" BASIS,
-// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-// See the License for the specific language governing permissions and
-// limitations under the License.
-
-// modified by Bevy contributors
-
-use crate::{Archetype, Component, ComponentFlags, MissingComponent};
-use core::{
-    fmt::Debug,
-    ops::{Deref, DerefMut},
-    sync::atomic::{AtomicUsize, Ordering},
-};
-
-/// Atomically enforces Rust-style borrow checking at runtime
-#[derive(Debug)]
-pub struct AtomicBorrow(AtomicUsize);
-
-impl AtomicBorrow {
-    /// Creates a new AtomicBorrow
-    pub const fn new() -> Self {
-        Self(AtomicUsize::new(0))
-    }
-
-    /// Starts a new immutable borrow. This can be called any number of times
-    pub fn borrow(&self) -> bool {
-        let value = self.0.fetch_add(1, Ordering::Acquire).wrapping_add(1);
-        if value == 0 {
-            // Wrapped, this borrow is invalid!
-            core::panic!()
-        }
-        if value & UNIQUE_BIT != 0 {
-            self.0.fetch_sub(1, Ordering::Release);
-            false
-        } else {
-            true
-        }
-    }
-
-    /// Starts a new mutable borrow. This must be unique. It cannot be done in parallel with other borrows or borrow_muts
-    pub fn borrow_mut(&self) -> bool {
-        self.0
-            .compare_exchange(0, UNIQUE_BIT, Ordering::Acquire, Ordering::Relaxed)
-            .is_ok()
-    }
-
-    /// Release an immutable borrow.
-    pub fn release(&self) {
-        let value = self.0.fetch_sub(1, Ordering::Release);
-        debug_assert!(value != 0, "unbalanced release");
-        debug_assert!(value & UNIQUE_BIT == 0, "shared release of unique borrow");
-    }
-
-    /// Release a mutable borrow.
-    pub fn release_mut(&self) {
-        let value = self.0.fetch_and(!UNIQUE_BIT, Ordering::Release);
-        debug_assert_ne!(value & UNIQUE_BIT, 0, "unique release of shared borrow");
-    }
-}
-
-const UNIQUE_BIT: usize = !(usize::max_value() >> 1);
-
-/// Shared borrow of an entity's component
-#[derive(Clone)]
-pub struct Ref<'a, T: Component> {
-    archetype: &'a Archetype,
-    target: &'a T,
-}
-
-impl<'a, T: Component> Ref<'a, T> {
-    /// Creates a new entity component borrow
-    ///
-    /// # Safety
-    ///
-    /// - the index of the component must be valid
-    pub unsafe fn new(archetype: &'a Archetype, index: usize) -> Result<Self, MissingComponent> {
-        let target = archetype
-            .get::<T>()
-            .ok_or_else(MissingComponent::new::<T>)?;
-        archetype.borrow::<T>();
-        Ok(Self {
-            archetype,
-            target: &*target.as_ptr().add(index as usize),
-        })
-    }
-}
-
-unsafe impl<T: Component> Send for Ref<'_, T> {}
-unsafe impl<T: Component> Sync for Ref<'_, T> {}
-
-impl<'a, T: Component> Drop for Ref<'a, T> {
-    fn drop(&mut self) {
-        self.archetype.release::<T>();
-    }
-}
-
-impl<'a, T: Component> Deref for Ref<'a, T> {
-    type Target = T;
-
-    fn deref(&self) -> &T {
-        self.target
-    }
-}
-
-impl<'a, T: Component> Debug for Ref<'a, T>
-where
-    T: Debug,
-{
-    fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
-        self.deref().fmt(f)
-    }
-}
-
-/// Unique borrow of an entity's component
-pub struct RefMut<'a, T: Component> {
-    archetype: &'a Archetype,
-    target: &'a mut T,
-    flags: &'a mut ComponentFlags,
-}
-
-impl<'a, T: Component> RefMut<'a, T> {
-    /// Creates a new entity component mutable borrow
-    ///
-    /// # Safety
-    ///
-    /// - the index of the component must be valid
-    pub unsafe fn new(archetype: &'a Archetype, index: usize) -> Result<Self, MissingComponent> {
-        let (target, type_state) = archetype
-            .get_with_type_state::<T>()
-            .ok_or_else(MissingComponent::new::<T>)?;
-        archetype.borrow_mut::<T>();
-        Ok(Self {
-            archetype,
-            target: &mut *target.as_ptr().add(index),
-            flags: &mut *type_state.component_flags().as_ptr().add(index),
-        })
-    }
-}
-
-unsafe impl<T: Component> Send for RefMut<'_, T> {}
-unsafe impl<T: Component> Sync for RefMut<'_, T> {}
-
-impl<'a, T: Component> Drop for RefMut<'a, T> {
-    fn drop(&mut self) {
-        self.archetype.release_mut::<T>();
-    }
-}
-
-impl<'a, T: Component> Deref for RefMut<'a, T> {
-    type Target = T;
-
-    fn deref(&self) -> &T {
-        self.target
-    }
-}
-
-impl<'a, T: Component> DerefMut for RefMut<'a, T> {
-    fn deref_mut(&mut self) -> &mut T {
-        self.flags.insert(ComponentFlags::MUTATED);
-        self.target
-    }
-}
-
-impl<'a, T: Component> Debug for RefMut<'a, T>
-where
-    T: Debug,
-{
-    fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
-        self.deref().fmt(f)
-    }
-}
-
-/// Handle to an entity with any component types
-#[derive(Copy, Clone)]
-pub struct EntityRef<'a> {
-    archetype: Option<&'a Archetype>,
-    index: usize,
-}
-
-impl<'a> EntityRef<'a> {
-    /// Construct a `Ref` for an entity with no components
-    pub(crate) fn empty() -> Self {
-        Self {
-            archetype: None,
-            index: 0,
-        }
-    }
-
-    pub(crate) unsafe fn new(archetype: &'a Archetype, index: usize) -> Self {
-        Self {
-            archetype: Some(archetype),
-            index,
-        }
-    }
-
-    /// Borrow the component of type `T`, if it exists
-    ///
-    /// Panics if the component is already uniquely borrowed from another entity with the same
-    /// components.
-    pub fn get<T: Component>(&self) -> Option<Ref<'a, T>> {
-        Some(unsafe { Ref::new(self.archetype?, self.index).ok()? })
-    }
-
-    /// Uniquely borrow the component of type `T`, if it exists
-    ///
-    /// Panics if the component is already borrowed from another entity with the same components.
-    pub fn get_mut<T: Component>(&self) -> Option<RefMut<'a, T>> {
-        Some(unsafe { RefMut::new(self.archetype?, self.index).ok()? })
-    }
-}
-
-unsafe impl<'a> Send for EntityRef<'a> {}
-unsafe impl<'a> Sync for EntityRef<'a> {}
diff --git a/crates/bevy_ecs/src/core/bundle.rs b/crates/bevy_ecs/src/core/bundle.rs
deleted file mode 100644
index 7ca93433d2e74..0000000000000
--- a/crates/bevy_ecs/src/core/bundle.rs
+++ /dev/null
@@ -1,151 +0,0 @@
-// Copyright 2019 Google LLC
-//
-// Licensed under the Apache License, Version 2.0 (the "License");
-// you may not use this file except in compliance with the License.
-// You may obtain a copy of the License at
-//
-//     https://www.apache.org/licenses/LICENSE-2.0
-//
-// Unless required by applicable law or agreed to in writing, software
-// distributed under the License is distributed on an "AS IS" BASIS,
-// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-// See the License for the specific language governing permissions and
-// limitations under the License.
-
-// modified by Bevy contributors
-
-use crate::{Component, TypeInfo};
-use std::{
-    any::{type_name, TypeId},
-    fmt, mem,
-    ptr::NonNull,
-};
-
-/// A dynamically typed collection of components
-///
-/// See [Bundle]
-pub trait DynamicBundle {
-    /// Invoke a callback on the fields' type IDs, sorted by descending alignment then id
-    #[doc(hidden)]
-    fn with_ids<T>(&self, f: impl FnOnce(&[TypeId]) -> T) -> T;
-    /// Obtain the fields' TypeInfos, sorted by descending alignment then id
-    #[doc(hidden)]
-    fn type_info(&self) -> Vec<TypeInfo>;
-    /// Allow a callback to move all components out of the bundle
-    ///
-    /// Must invoke `f` only with a valid pointer, its type, and the pointee's size. A `false`
-    /// return value indicates that the value was not moved and should be dropped.
-    #[doc(hidden)]
-    unsafe fn put(self, f: impl FnMut(*mut u8, TypeId, usize) -> bool);
-}
-
-/// A statically typed collection of components
-///
-/// See [DynamicBundle]
-pub trait Bundle: DynamicBundle {
-    #[doc(hidden)]
-    fn with_static_ids<T>(f: impl FnOnce(&[TypeId]) -> T) -> T;
-
-    /// Obtain the fields' TypeInfos, sorted by descending alignment then id
-    #[doc(hidden)]
-    fn static_type_info() -> Vec<TypeInfo>;
-
-    /// Construct `Self` by moving components out of pointers fetched by `f`
-    ///
-    /// # Safety
-    ///
-    /// `f` must produce pointers to the expected fields. The implementation must not read from any
-    /// pointers if any call to `f` returns `None`.
-    #[doc(hidden)]
-    unsafe fn get(
-        f: impl FnMut(TypeId, usize) -> Option<NonNull<u8>>,
-    ) -> Result<Self, MissingComponent>
-    where
-        Self: Sized;
-}
-
-/// Error indicating that an entity did not have a required component
-#[derive(Debug, Clone, Eq, PartialEq, Hash)]
-pub struct MissingComponent(&'static str);
-
-impl MissingComponent {
-    /// Construct an error representing a missing `T`
-    pub fn new<T: Component>() -> Self {
-        Self(type_name::<T>())
-    }
-}
-
-impl fmt::Display for MissingComponent {
-    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
-        write!(f, "missing {} component", self.0)
-    }
-}
-
-#[cfg(feature = "std")]
-impl std::error::Error for MissingComponent {}
-
-macro_rules! tuple_impl {
-    ($($name: ident),*) => {
-        impl<$($name: Component),*> DynamicBundle for ($($name,)*) {
-            fn with_ids<T>(&self, f: impl FnOnce(&[TypeId]) -> T) -> T {
-                Self::with_static_ids(f)
-            }
-
-            fn type_info(&self) -> Vec<TypeInfo> {
-                Self::static_type_info()
-            }
-
-            #[allow(unused_variables, unused_mut)]
-            unsafe fn put(self, mut f: impl FnMut(*mut u8, TypeId, usize) -> bool) {
-                #[allow(non_snake_case)]
-                let ($(mut $name,)*) = self;
-                $(
-                    if f(
-                        (&mut $name as *mut $name).cast::<u8>(),
-                        TypeId::of::<$name>(),
-                        mem::size_of::<$name>()
-                    ) {
-                        mem::forget($name)
-                    }
-                )*
-            }
-        }
-
-        impl<$($name: Component),*> Bundle for ($($name,)*) {
-            fn with_static_ids<T>(f: impl FnOnce(&[TypeId]) -> T) -> T {
-                const N: usize = count!($($name),*);
-                let mut xs: [(usize, TypeId); N] = [$((mem::align_of::<$name>(), TypeId::of::<$name>())),*];
-                xs.sort_unstable_by(|x, y| x.0.cmp(&y.0).reverse().then(x.1.cmp(&y.1)));
-                let mut ids = [TypeId::of::<()>(); N];
-                for (slot, &(_, id)) in ids.iter_mut().zip(xs.iter()) {
-                    *slot = id;
-                }
-                f(&ids)
-            }
-
-            fn static_type_info() -> Vec<TypeInfo> {
-                let mut xs = vec![$(TypeInfo::of::<$name>()),*];
-                xs.sort_unstable();
-                xs
-            }
-
-            #[allow(unused_variables, unused_mut)]
-            unsafe fn get(mut f: impl FnMut(TypeId, usize) -> Option<NonNull<u8>>) -> Result<Self, MissingComponent> {
-                #[allow(non_snake_case)]
-                let ($(mut $name,)*) = ($(
-                    f(TypeId::of::<$name>(), mem::size_of::<$name>()).ok_or_else(MissingComponent::new::<$name>)?
-                        .as_ptr()
-                        .cast::<$name>(),)*
-                );
-                Ok(($($name.read(),)*))
-            }
-        }
-    }
-}
-
-macro_rules! count {
-    () => { 0 };
-    ($x: ident $(, $rest: ident)*) => { 1 + count!($($rest),*) };
-}
-
-smaller_tuples_too!(tuple_impl, O, N, M, L, K, J, I, H, G, F, E, D, C, B, A);
diff --git a/crates/bevy_ecs/src/core/entities.rs b/crates/bevy_ecs/src/core/entities.rs
deleted file mode 100644
index f7d001cae7c40..0000000000000
--- a/crates/bevy_ecs/src/core/entities.rs
+++ /dev/null
@@ -1,386 +0,0 @@
-use std::{
-    convert::TryFrom,
-    fmt, mem,
-    sync::atomic::{AtomicU32, Ordering},
-};
-
-/// Lightweight unique ID of an entity
-///
-/// Obtained from `World::spawn`. Can be stored to refer to an entity in the future.
-#[derive(Clone, Copy, Hash, Eq, Ord, PartialEq, PartialOrd)]
-pub struct Entity {
-    pub(crate) generation: u32,
-    pub(crate) id: u32,
-}
-
-impl Entity {
-    /// Creates a new entity reference with a generation of 0
-    pub fn new(id: u32) -> Entity {
-        Entity { id, generation: 0 }
-    }
-
-    /// Convert to a form convenient for passing outside of rust
-    ///
-    /// Only useful for identifying entities within the same instance of an application. Do not use
-    /// for serialization between runs.
-    ///
-    /// No particular structure is guaranteed for the returned bits.
-    pub fn to_bits(self) -> u64 {
-        u64::from(self.generation) << 32 | u64::from(self.id)
-    }
-
-    /// Reconstruct an `Entity` previously destructured with `to_bits`
-    ///
-    /// Only useful when applied to results from `to_bits` in the same instance of an application.
-    pub fn from_bits(bits: u64) -> Self {
-        Self {
-            generation: (bits >> 32) as u32,
-            id: bits as u32,
-        }
-    }
-
-    /// Extract a transiently unique identifier
-    ///
-    /// No two simultaneously-live entities share the same ID, but dead entities' IDs may collide
-    /// with both live and dead entities. Useful for compactly representing entities within a
-    /// specific snapshot of the world, such as when serializing.
-    pub fn id(self) -> u32 {
-        self.id
-    }
-}
-
-impl fmt::Debug for Entity {
-    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
-        write!(f, "{}v{}", self.id, self.generation)
-    }
-}
-
-#[derive(Debug, Default)]
-pub(crate) struct Entities {
-    pub meta: Vec<EntityMeta>,
-    // Reserved entities outside the range of `meta`, having implicit generation 0, archetype 0, and
-    // undefined index. Calling `flush` converts these to real entities, which can have a fully
-    // defined location.
-    pending: AtomicU32,
-    // Unused entity IDs below `meta.len()`
-    free: Vec<u32>,
-    free_cursor: AtomicU32,
-    // Reserved IDs within `meta.len()` with implicit archetype 0 and undefined index. Should be
-    // consumed and used to initialize locations to produce real entities after calling `flush`.
-    reserved: Box<[AtomicU32]>,
-    reserved_cursor: AtomicU32,
-}
-
-impl Entities {
-    /// Reserve an entity ID concurrently
-    ///
-    /// Storage for entity generation and location is lazily allocated by calling `flush`. Locations
-    /// can be determined by the return value of `flush` and by iterating through the `reserved`
-    /// accessors, and should all be written immediately after flushing.
-    pub fn reserve_entity(&self) -> Entity {
-        loop {
-            let index = self.free_cursor.load(Ordering::Relaxed);
-            return match index.checked_sub(1) {
-                // The freelist is empty, so increment `pending` to arrange for a new entity with a
-                // predictable ID to be allocated on the next `flush` call
-                None => {
-                    let n = self.pending.fetch_add(1, Ordering::Relaxed);
-                    Entity {
-                        generation: 0,
-                        id: u32::try_from(self.meta.len())
-                            .ok()
-                            .and_then(|x| x.checked_add(n))
-                            .expect("Too many entities."),
-                    }
-                }
-                // The freelist has entities in it, so move the last entry to the reserved list, to
-                // be consumed by the caller as part of a higher-level flush.
-                Some(next) => {
-                    // We don't care about memory ordering here so long as we get our slot.
-                    if self
-                        .free_cursor
-                        .compare_exchange_weak(index, next, Ordering::Relaxed, Ordering::Relaxed)
-                        .is_err()
-                    {
-                        // Another thread already consumed this slot, start over.
-                        continue;
-                    }
-                    let id = self.free[next as usize];
-                    let reservation = self.reserved_cursor.fetch_add(1, Ordering::Relaxed);
-                    self.reserved[reservation as usize].store(id, Ordering::Relaxed);
-                    Entity {
-                        generation: self.meta[id as usize].generation,
-                        id,
-                    }
-                }
-            };
-        }
-    }
-
-    /// Allocate an entity ID directly
-    ///
-    /// Location should be written immediately.
-    pub fn alloc(&mut self) -> Entity {
-        debug_assert_eq!(
-            self.pending.load(Ordering::Relaxed),
-            0,
-            "allocator must be flushed before potentially growing"
-        );
-        let index = self.free_cursor.load(Ordering::Relaxed);
-        match index.checked_sub(1) {
-            None => {
-                self.grow(0);
-                let cursor = self.free_cursor.fetch_sub(1, Ordering::Relaxed);
-                let id = self.free[(cursor - 1) as usize];
-                Entity {
-                    generation: self.meta[id as usize].generation,
-                    id,
-                }
-            }
-            Some(next) => {
-                // Not racey due to &mut self
-                self.free_cursor.store(next, Ordering::Relaxed);
-                let id = self.free[next as usize];
-                Entity {
-                    generation: self.meta[id as usize].generation,
-                    id,
-                }
-            }
-        }
-    }
-
-    /// Destroy an entity, allowing it to be reused
-    ///
-    /// Must not be called on reserved entities prior to `flush`.
-    pub fn free(&mut self, entity: Entity) -> Result<Location, NoSuchEntity> {
-        let meta = &mut self.meta[entity.id as usize];
-        if meta.generation != entity.generation {
-            return Err(NoSuchEntity);
-        }
-        meta.generation += 1;
-        let loc = mem::replace(
-            &mut meta.location,
-            Location {
-                archetype: 0,
-                // Guard against bugs in reservation handling
-                index: usize::max_value(),
-            },
-        );
-        let index = self.free_cursor.fetch_add(1, Ordering::Relaxed); // Not racey due to &mut self
-        self.free[index as usize] = entity.id;
-        debug_assert!(
-            loc.index != usize::max_value(),
-            "free called on reserved entity without flush"
-        );
-        Ok(loc)
-    }
-
-    /// Ensure `n` at least allocations can succeed without reallocating
-    pub fn reserve(&mut self, additional: u32) {
-        debug_assert_eq!(
-            self.pending.load(Ordering::Relaxed),
-            0,
-            "allocator must be flushed before potentially growing"
-        );
-        let free = self.free_cursor.load(Ordering::Relaxed);
-        if additional > free {
-            self.grow(additional - free);
-        }
-    }
-
-    pub fn contains(&self, entity: Entity) -> bool {
-        if entity.id >= self.meta.len() as u32 {
-            return true;
-        }
-        self.meta[entity.id as usize].generation == entity.generation
-    }
-
-    pub fn clear(&mut self) {
-        // Not racey due to &mut self
-        self.free_cursor
-            .store(self.meta.len() as u32, Ordering::Relaxed);
-        for (i, x) in self.free.iter_mut().enumerate() {
-            *x = i as u32;
-        }
-        self.pending.store(0, Ordering::Relaxed);
-        self.reserved_cursor.store(0, Ordering::Relaxed);
-    }
-
-    /// Access the location storage of an entity
-    ///
-    /// Must not be called on pending entities.
-    pub fn get_mut(&mut self, entity: Entity) -> Result<&mut Location, NoSuchEntity> {
-        let meta = &mut self.meta[entity.id as usize];
-        if meta.generation == entity.generation {
-            Ok(&mut meta.location)
-        } else {
-            Err(NoSuchEntity)
-        }
-    }
-
-    /// Returns `Ok(Location { archetype: 0, index: undefined })` for pending entities
-    pub fn get(&self, entity: Entity) -> Result<Location, NoSuchEntity> {
-        if self.meta.len() <= entity.id as usize {
-            return Ok(Location {
-                archetype: 0,
-                index: usize::max_value(),
-            });
-        }
-        let meta = &self.meta[entity.id as usize];
-        if meta.generation != entity.generation {
-            return Err(NoSuchEntity);
-        }
-        if meta.location.archetype == 0 {
-            return Ok(Location {
-                archetype: 0,
-                index: usize::max_value(),
-            });
-        }
-        Ok(meta.location)
-    }
-
-    /// Allocate space for and enumerate pending entities
-    #[allow(clippy::reversed_empty_ranges)]
-    pub fn flush(&mut self) -> impl Iterator<Item = u32> {
-        let pending = self.pending.load(Ordering::Relaxed); // Not racey due to &mut self
-        if pending != 0 {
-            let first = self.meta.len() as u32;
-            self.grow(0);
-            first..(first + pending)
-        } else {
-            0..0
-        }
-    }
-
-    /// Number of freed entities in `self.meta`
-    pub fn freed_len(&self) -> u32 {
-        self.free_cursor.load(Ordering::Relaxed)
-    }
-
-    /// Number of reserved entities outside of `self.meta`
-    pub fn pending_len(&self) -> u32 {
-        self.pending.load(Ordering::Relaxed)
-    }
-
-    // The following three methods allow iteration over `reserved` simultaneous to location
-    // writes. This is a lazy hack, but we only use it in `World::flush` so the complexity and unsafety
-    // involved in producing an `impl Iterator<Item=(u32, &mut Location)>` isn't a clear win.
-    /// Number of reserved entities in `self.meta`
-    pub fn reserved_len(&self) -> u32 {
-        self.reserved_cursor.load(Ordering::Relaxed)
-    }
-
-    pub fn reserved(&self, i: u32) -> u32 {
-        debug_assert!(i < self.reserved_len());
-        self.reserved[i as usize].load(Ordering::Relaxed)
-    }
-
-    pub fn clear_reserved(&mut self) {
-        self.reserved_cursor.store(0, Ordering::Relaxed);
-    }
-
-    /// Expand storage and mark all but the first `pending` of the new slots as free
-    fn grow(&mut self, increment: u32) {
-        let pending = self.pending.swap(0, Ordering::Relaxed);
-        let new_len = (self.meta.len() + pending as usize + increment as usize)
-            .max(self.meta.len() * 2)
-            .max(1024);
-        let mut new_meta = Vec::with_capacity(new_len);
-        new_meta.extend_from_slice(&self.meta);
-        new_meta.resize(
-            new_len,
-            EntityMeta {
-                generation: 0,
-                location: Location {
-                    archetype: 0,
-                    index: usize::max_value(), // dummy value, to be filled in
-                },
-            },
-        );
-
-        let free_cursor = self.free_cursor.load(Ordering::Relaxed); // Not racey due to &mut self
-        let mut new_free = Vec::with_capacity(new_len);
-        new_free.extend_from_slice(&self.free[0..free_cursor as usize]);
-        // Add freshly allocated trailing free slots
-        new_free.extend(((self.meta.len() as u32 + pending)..new_len as u32).rev());
-        debug_assert!(new_free.len() <= new_len);
-        self.free_cursor
-            .store(new_free.len() as u32, Ordering::Relaxed); // Not racey due to &mut self
-
-        // Zero-fill
-        new_free.resize(new_len, 0);
-
-        self.meta = new_meta;
-        self.free = new_free;
-        let mut new_reserved = Vec::with_capacity(new_len);
-        // Not racey due to &mut self
-        let reserved_cursor = self.reserved_cursor.load(Ordering::Relaxed);
-        for x in &self.reserved[..reserved_cursor as usize] {
-            new_reserved.push(AtomicU32::new(x.load(Ordering::Relaxed)));
-        }
-        new_reserved.resize_with(new_len, || AtomicU32::new(0));
-        self.reserved = new_reserved.into();
-    }
-
-    pub fn get_reserver(&self) -> EntityReserver {
-        // SAFE: reservers use atomics for anything write-related
-        let entities: &'static Entities = unsafe { mem::transmute(self) };
-        EntityReserver { entities }
-    }
-}
-
-/// Reserves entities in a way that is usable in multi-threaded contexts.
-#[derive(Debug)]
-pub struct EntityReserver {
-    entities: &'static Entities,
-}
-
-impl EntityReserver {
-    /// Reserves an entity
-    pub fn reserve_entity(&self) -> Entity {
-        self.entities.reserve_entity()
-    }
-}
-
-#[derive(Copy, Clone, Debug)]
-pub(crate) struct EntityMeta {
-    pub generation: u32,
-    pub location: Location,
-}
-
-/// A location of an entity in an archetype
-#[derive(Copy, Clone, Debug)]
-pub struct Location {
-    /// The archetype index
-    pub archetype: u32,
-
-    /// The index of the entity in the archetype
-    pub index: usize,
-}
-
-/// Error indicating that no entity with a particular ID exists
-#[derive(Debug, Clone, Eq, PartialEq)]
-pub struct NoSuchEntity;
-
-impl fmt::Display for NoSuchEntity {
-    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
-        f.pad("no such entity")
-    }
-}
-
-#[cfg(feature = "std")]
-impl Error for NoSuchEntity {}
-
-#[cfg(test)]
-mod tests {
-    use super::*;
-
-    #[test]
-    fn entity_bits_roundtrip() {
-        let e = Entity {
-            generation: 0xDEADBEEF,
-            id: 0xBAADF00D,
-        };
-        assert_eq!(Entity::from_bits(e.to_bits()), e);
-    }
-}
diff --git a/crates/bevy_ecs/src/core/entity_builder.rs b/crates/bevy_ecs/src/core/entity_builder.rs
deleted file mode 100644
index d366738f2fba8..0000000000000
--- a/crates/bevy_ecs/src/core/entity_builder.rs
+++ /dev/null
@@ -1,188 +0,0 @@
-// Copyright 2019 Google LLC
-//
-// Licensed under the Apache License, Version 2.0 (the "License");
-// you may not use this file except in compliance with the License.
-// You may obtain a copy of the License at
-//
-//     https://www.apache.org/licenses/LICENSE-2.0
-//
-// Unless required by applicable law or agreed to in writing, software
-// distributed under the License is distributed on an "AS IS" BASIS,
-// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-// See the License for the specific language governing permissions and
-// limitations under the License.
-
-// modified by Bevy contributors
-
-use bevy_utils::HashSet;
-use std::{
-    alloc::{alloc, dealloc, Layout},
-    any::TypeId,
-    mem::{self, MaybeUninit},
-    ptr,
-};
-
-use crate::{Component, DynamicBundle, TypeInfo};
-
-/// Helper for incrementally constructing a bundle of components with dynamic component types
-///
-/// Prefer reusing the same builder over creating new ones repeatedly.
-///
-/// ```
-/// # use bevy_ecs::*;
-/// let mut world = World::new();
-/// let mut builder = EntityBuilder::new();
-/// builder.add(123).add("abc");
-/// let e = world.spawn(builder.build()); // builder can now be reused
-/// assert_eq!(*world.get::<i32>(e).unwrap(), 123);
-/// assert_eq!(*world.get::<&str>(e).unwrap(), "abc");
-/// ```
-pub struct EntityBuilder {
-    storage: Box<[MaybeUninit<u8>]>,
-    cursor: usize,
-    info: Vec<(TypeInfo, usize)>,
-    ids: Vec<TypeId>,
-    id_set: HashSet<TypeId>,
-}
-
-impl EntityBuilder {
-    /// Create a builder representing an entity with no components
-    pub fn new() -> Self {
-        Self {
-            cursor: 0,
-            storage: Box::new([]),
-            info: Vec::new(),
-            ids: Vec::new(),
-            id_set: HashSet::default(),
-        }
-    }
-
-    /// Add `component` to the entity
-    pub fn add<T: Component>(&mut self, component: T) -> &mut Self {
-        if !self.id_set.insert(TypeId::of::<T>()) {
-            return self;
-        }
-        let end = self.cursor + mem::size_of::<T>();
-        if end > self.storage.len() {
-            self.grow(end);
-        }
-        if mem::size_of::<T>() != 0 {
-            unsafe {
-                self.storage
-                    .as_mut_ptr()
-                    .add(self.cursor)
-                    .cast::<T>()
-                    .write_unaligned(component);
-            }
-        }
-        self.info.push((TypeInfo::of::<T>(), self.cursor));
-        self.cursor += mem::size_of::<T>();
-        self
-    }
-
-    fn grow(&mut self, min_size: usize) {
-        let new_len = min_size.next_power_of_two().max(64);
-        let mut new_storage = vec![MaybeUninit::uninit(); new_len].into_boxed_slice();
-        new_storage[..self.cursor].copy_from_slice(&self.storage[..self.cursor]);
-        self.storage = new_storage;
-    }
-
-    /// Construct a `Bundle` suitable for spawning
-    pub fn build(&mut self) -> BuiltEntity<'_> {
-        self.info.sort_unstable_by_key(|x| x.0);
-        self.ids.extend(self.info.iter().map(|x| x.0.id()));
-        BuiltEntity { builder: self }
-    }
-
-    /// Drop previously `add`ed components
-    ///
-    /// The builder is cleared implicitly when an entity is built, so this doesn't usually need to
-    /// be called.
-    pub fn clear(&mut self) {
-        self.ids.clear();
-        self.id_set.clear();
-        self.cursor = 0;
-        let max_size = self
-            .info
-            .iter()
-            .map(|x| x.0.layout().size())
-            .max()
-            .unwrap_or(0);
-        let max_align = self
-            .info
-            .iter()
-            .map(|x| x.0.layout().align())
-            .max()
-            .unwrap_or(0);
-        unsafe {
-            // Suitably aligned storage for drop
-            let tmp = if max_size > 0 {
-                alloc(Layout::from_size_align(max_size, max_align).unwrap()).cast()
-            } else {
-                max_align as *mut _
-            };
-            for (ty, offset) in self.info.drain(..) {
-                ptr::copy_nonoverlapping(
-                    self.storage[offset..offset + ty.layout().size()]
-                        .as_ptr()
-                        .cast(),
-                    tmp,
-                    ty.layout().size(),
-                );
-                ty.drop(tmp);
-            }
-            if max_size > 0 {
-                dealloc(tmp, Layout::from_size_align(max_size, max_align).unwrap())
-            }
-        }
-    }
-}
-
-unsafe impl Send for EntityBuilder {}
-unsafe impl Sync for EntityBuilder {}
-
-impl Drop for EntityBuilder {
-    fn drop(&mut self) {
-        // Ensure buffered components aren't leaked
-        self.clear();
-    }
-}
-
-impl Default for EntityBuilder {
-    fn default() -> Self {
-        Self::new()
-    }
-}
-
-/// The output of an `EntityBuilder`, suitable for passing to `World::spawn` or `World::insert`
-pub struct BuiltEntity<'a> {
-    builder: &'a mut EntityBuilder,
-}
-
-impl DynamicBundle for BuiltEntity<'_> {
-    fn with_ids<T>(&self, f: impl FnOnce(&[TypeId]) -> T) -> T {
-        f(&self.builder.ids)
-    }
-
-    #[doc(hidden)]
-    fn type_info(&self) -> Vec<TypeInfo> {
-        self.builder.info.iter().map(|x| x.0).collect()
-    }
-
-    unsafe fn put(self, mut f: impl FnMut(*mut u8, TypeId, usize) -> bool) {
-        for (ty, offset) in self.builder.info.drain(..) {
-            let ptr = self.builder.storage.as_mut_ptr().add(offset).cast();
-            if !f(ptr, ty.id(), ty.layout().size()) {
-                ty.drop(ptr);
-            }
-        }
-    }
-}
-
-impl Drop for BuiltEntity<'_> {
-    fn drop(&mut self) {
-        // Ensures components aren't leaked if `store` was never called, and prepares the builder
-        // for reuse.
-        self.builder.clear();
-    }
-}
diff --git a/crates/bevy_ecs/src/core/filter.rs b/crates/bevy_ecs/src/core/filter.rs
deleted file mode 100644
index 65e01f4d58762..0000000000000
--- a/crates/bevy_ecs/src/core/filter.rs
+++ /dev/null
@@ -1,272 +0,0 @@
-use crate::{core::ComponentFlags, Archetype, Bundle, Component, QueryAccess};
-use std::{any::TypeId, marker::PhantomData, ptr::NonNull};
-
-pub trait QueryFilter: Sized {
-    type EntityFilter: EntityFilter;
-    fn access() -> QueryAccess;
-    fn get_entity_filter(archetype: &Archetype) -> Option<Self::EntityFilter>;
-}
-
-pub trait EntityFilter: Sized {
-    const DANGLING: Self;
-
-    /// # Safety
-    /// This might access archetype data in an unsafe manner. In general filters should be read-only and they should only access
-    /// the data they have claimed in `access()`.
-    unsafe fn matches_entity(&self, _offset: usize) -> bool;
-}
-
-pub struct AnyEntityFilter;
-
-impl EntityFilter for AnyEntityFilter {
-    const DANGLING: Self = AnyEntityFilter;
-
-    #[inline]
-    unsafe fn matches_entity(&self, _offset: usize) -> bool {
-        true
-    }
-}
-
-pub struct Or<T>(pub T);
-
-/// Query transformer that retrieves components of type `T` that have been mutated since the start of the frame.
-/// Added components do not count as mutated.
-pub struct Mutated<T>(NonNull<ComponentFlags>, PhantomData<T>);
-
-/// Query transformer that retrieves components of type `T` that have been added since the start of the frame.
-pub struct Added<T>(NonNull<ComponentFlags>, PhantomData<T>);
-
-/// Query transformer that retrieves components of type `T` that have either been mutated or added since the start of the frame.
-pub struct Changed<T>(NonNull<ComponentFlags>, PhantomData<T>);
-
-impl QueryFilter for () {
-    type EntityFilter = AnyEntityFilter;
-
-    fn access() -> QueryAccess {
-        QueryAccess::None
-    }
-
-    #[inline]
-    fn get_entity_filter(_archetype: &Archetype) -> Option<Self::EntityFilter> {
-        Some(AnyEntityFilter)
-    }
-}
-
-impl<T: Component> QueryFilter for Added<T> {
-    type EntityFilter = Self;
-
-    fn access() -> QueryAccess {
-        QueryAccess::read::<T>()
-    }
-
-    #[inline]
-    fn get_entity_filter(archetype: &Archetype) -> Option<Self::EntityFilter> {
-        archetype
-            .get_type_state(TypeId::of::<T>())
-            .map(|state| Added(state.component_flags(), Default::default()))
-    }
-}
-
-impl<T: Component> EntityFilter for Added<T> {
-    const DANGLING: Self = Added(NonNull::dangling(), PhantomData::<T>);
-
-    #[inline]
-    unsafe fn matches_entity(&self, offset: usize) -> bool {
-        (*self.0.as_ptr().add(offset)).contains(ComponentFlags::ADDED)
-    }
-}
-
-impl<T: Component> QueryFilter for Mutated<T> {
-    type EntityFilter = Self;
-
-    fn access() -> QueryAccess {
-        QueryAccess::read::<T>()
-    }
-
-    #[inline]
-    fn get_entity_filter(archetype: &Archetype) -> Option<Self::EntityFilter> {
-        archetype
-            .get_type_state(TypeId::of::<T>())
-            .map(|state| Mutated(state.component_flags(), Default::default()))
-    }
-}
-
-impl<T: Component> EntityFilter for Mutated<T> {
-    const DANGLING: Self = Mutated(NonNull::dangling(), PhantomData::<T>);
-
-    unsafe fn matches_entity(&self, offset: usize) -> bool {
-        (*self.0.as_ptr().add(offset)).contains(ComponentFlags::MUTATED)
-    }
-}
-
-impl<T: Component> QueryFilter for Changed<T> {
-    type EntityFilter = Self;
-
-    fn access() -> QueryAccess {
-        QueryAccess::read::<T>()
-    }
-
-    #[inline]
-    fn get_entity_filter(archetype: &Archetype) -> Option<Self::EntityFilter> {
-        archetype
-            .get_type_state(TypeId::of::<T>())
-            .map(|state| Changed(state.component_flags(), Default::default()))
-    }
-}
-
-impl<T: Component> EntityFilter for Changed<T> {
-    const DANGLING: Self = Changed(NonNull::dangling(), PhantomData::<T>);
-
-    #[inline]
-    unsafe fn matches_entity(&self, offset: usize) -> bool {
-        let flags = *self.0.as_ptr().add(offset);
-        flags.contains(ComponentFlags::ADDED) || flags.contains(ComponentFlags::MUTATED)
-    }
-}
-
-pub struct Without<T>(PhantomData<T>);
-
-impl<T: Component> QueryFilter for Without<T> {
-    type EntityFilter = AnyEntityFilter;
-
-    fn access() -> QueryAccess {
-        QueryAccess::without::<T>(QueryAccess::None)
-    }
-
-    #[inline]
-    fn get_entity_filter(archetype: &Archetype) -> Option<Self::EntityFilter> {
-        if archetype.has_type(TypeId::of::<T>()) {
-            None
-        } else {
-            Some(AnyEntityFilter)
-        }
-    }
-}
-
-pub struct With<T>(PhantomData<T>);
-
-impl<T: Component> QueryFilter for With<T> {
-    type EntityFilter = AnyEntityFilter;
-
-    fn access() -> QueryAccess {
-        QueryAccess::with::<T>(QueryAccess::None)
-    }
-
-    #[inline]
-    fn get_entity_filter(archetype: &Archetype) -> Option<Self::EntityFilter> {
-        if archetype.has_type(TypeId::of::<T>()) {
-            Some(AnyEntityFilter)
-        } else {
-            None
-        }
-    }
-}
-
-pub struct WithType<T: Bundle>(PhantomData<T>);
-
-impl<T: Bundle> QueryFilter for WithType<T> {
-    type EntityFilter = AnyEntityFilter;
-
-    fn access() -> QueryAccess {
-        QueryAccess::union(
-            T::static_type_info()
-                .iter()
-                .map(|info| QueryAccess::With(info.id(), Box::new(QueryAccess::None)))
-                .collect::<Vec<QueryAccess>>(),
-        )
-    }
-
-    #[inline]
-    fn get_entity_filter(archetype: &Archetype) -> Option<Self::EntityFilter> {
-        if T::static_type_info()
-            .iter()
-            .all(|info| archetype.has_type(info.id()))
-        {
-            Some(AnyEntityFilter)
-        } else {
-            None
-        }
-    }
-}
-
-macro_rules! impl_query_filter_tuple {
-    ($($filter: ident),*) => {
-        #[allow(unused_variables)]
-        #[allow(non_snake_case)]
-        impl<$($filter: QueryFilter),*> QueryFilter for ($($filter,)*) {
-            type EntityFilter = ($($filter::EntityFilter,)*);
-
-            fn access() -> QueryAccess {
-                QueryAccess::union(vec![
-                    $($filter::access(),)+
-                ])
-            }
-
-            fn get_entity_filter(archetype: &Archetype) -> Option<Self::EntityFilter> {
-                Some(($($filter::get_entity_filter(archetype)?,)*))
-            }
-
-        }
-
-        #[allow(unused_variables)]
-        #[allow(non_snake_case)]
-        impl<$($filter: EntityFilter),*> EntityFilter for ($($filter,)*) {
-            const DANGLING: Self = ($($filter::DANGLING,)*);
-            unsafe fn matches_entity(&self, offset: usize) -> bool {
-                let ($($filter,)*) = self;
-                true $(&& $filter.matches_entity(offset))*
-            }
-        }
-
-        #[allow(unused_variables)]
-        #[allow(non_snake_case)]
-        impl<$($filter: QueryFilter),*> QueryFilter for Or<($($filter,)*)> {
-            type EntityFilter = Or<($(Option<<$filter as QueryFilter>::EntityFilter>,)*)>;
-            fn access() -> QueryAccess {
-                QueryAccess::union(vec![
-                    $(QueryAccess::Optional(Box::new($filter::access())),)+
-                ])
-            }
-
-            fn get_entity_filter(archetype: &Archetype) -> Option<Self::EntityFilter> {
-                let mut matches_something = false;
-                $(
-                    let $filter = $filter::get_entity_filter(archetype);
-                    matches_something = matches_something || $filter.is_some();
-                )*
-                if matches_something {
-                    Some(Or(($($filter,)*)))
-                } else {
-                    None
-                }
-            }
-
-        }
-        #[allow(unused_variables)]
-        #[allow(non_snake_case)]
-        impl<$($filter: EntityFilter),*> EntityFilter for Or<($(Option<$filter>,)*)> {
-            const DANGLING: Self = Or(($(Some($filter::DANGLING),)*));
-            unsafe fn matches_entity(&self, offset: usize) -> bool {
-                let Or(($($filter,)*)) = self;
-                false $(|| $filter.as_ref().map_or(false, |filter|filter.matches_entity(offset)))*
-            }
-        }
-    };
-}
-
-impl_query_filter_tuple!(A);
-impl_query_filter_tuple!(A, B);
-impl_query_filter_tuple!(A, B, C);
-impl_query_filter_tuple!(A, B, C, D);
-impl_query_filter_tuple!(A, B, C, D, E);
-impl_query_filter_tuple!(A, B, C, D, E, F);
-impl_query_filter_tuple!(A, B, C, D, E, F, G);
-impl_query_filter_tuple!(A, B, C, D, E, F, G, H);
-impl_query_filter_tuple!(A, B, C, D, E, F, G, H, I);
-impl_query_filter_tuple!(A, B, C, D, E, F, G, H, I, J);
-impl_query_filter_tuple!(A, B, C, D, E, F, G, H, I, J, K);
-impl_query_filter_tuple!(A, B, C, D, E, F, G, H, I, J, K, L);
-impl_query_filter_tuple!(A, B, C, D, E, F, G, H, I, J, K, L, M);
-impl_query_filter_tuple!(A, B, C, D, E, F, G, H, I, J, K, L, M, N);
-impl_query_filter_tuple!(A, B, C, D, E, F, G, H, I, J, K, L, M, N, O);
-impl_query_filter_tuple!(A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P);
diff --git a/crates/bevy_ecs/src/core/mod.rs b/crates/bevy_ecs/src/core/mod.rs
deleted file mode 100644
index 9cc61470dd596..0000000000000
--- a/crates/bevy_ecs/src/core/mod.rs
+++ /dev/null
@@ -1,64 +0,0 @@
-// Copyright 2019 Google LLC
-//
-// Licensed under the Apache License, Version 2.0 (the "License");
-// you may not use this file except in compliance with the License.
-// You may obtain a copy of the License at
-//
-//     https://www.apache.org/licenses/LICENSE-2.0
-//
-// Unless required by applicable law or agreed to in writing, software
-// distributed under the License is distributed on an "AS IS" BASIS,
-// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-// See the License for the specific language governing permissions and
-// limitations under the License.
-
-// modified by Bevy contributors
-
-/// Imagine macro parameters, but more like those Russian dolls.
-///
-/// Calls m!(A, B, C), m!(A, B), m!(B), and m!() for i.e. (m, A, B, C)
-/// where m is any macro, for any number of parameters.
-#[macro_export]
-macro_rules! smaller_tuples_too {
-    ($m: ident, $ty: ident) => {
-        $m!{$ty}
-        $m!{}
-    };
-    ($m: ident, $ty: ident, $($tt: ident),*) => {
-        $m!{$ty, $($tt),*}
-        smaller_tuples_too!{$m, $($tt),*}
-    };
-}
-
-mod access;
-mod archetype;
-mod borrow;
-mod bundle;
-mod entities;
-mod entity_builder;
-mod entity_map;
-mod filter;
-mod query;
-mod serde;
-mod world;
-mod world_builder;
-
-pub use access::{ArchetypeComponent, CondensedTypeAccess, QueryAccess, TypeAccess};
-pub use archetype::{Archetype, ComponentFlags, TypeState};
-pub use borrow::{AtomicBorrow, Ref, RefMut};
-pub use bundle::{Bundle, DynamicBundle, MissingComponent};
-pub use entities::{Entity, EntityReserver, Location, NoSuchEntity};
-pub use entity_builder::{BuiltEntity, EntityBuilder};
-pub use entity_map::*;
-pub use filter::{Added, Changed, EntityFilter, Mutated, Or, QueryFilter, With, Without};
-pub use query::{Batch, BatchedIter, Flags, Mut, QueryIter, ReadOnlyFetch, WorldQuery};
-pub use world::{ArchetypesGeneration, Component, ComponentError, SpawnBatchIter, World};
-pub use world_builder::*;
-
-// Unstable implementation details needed by the macros
-#[doc(hidden)]
-pub use archetype::TypeInfo;
-#[doc(hidden)]
-pub use bevy_utils;
-#[doc(hidden)]
-pub use query::Fetch;
diff --git a/crates/bevy_ecs/src/core/query.rs b/crates/bevy_ecs/src/core/query.rs
deleted file mode 100644
index d4bac85f9a82a..0000000000000
--- a/crates/bevy_ecs/src/core/query.rs
+++ /dev/null
@@ -1,775 +0,0 @@
-// Copyright 2019 Google LLC
-//
-// Licensed under the Apache License, Version 2.0 (the "License");
-// you may not use this file except in compliance with the License.
-// You may obtain a copy of the License at
-//
-//     https://www.apache.org/licenses/LICENSE-2.0
-//
-// Unless required by applicable law or agreed to in writing, software
-// distributed under the License is distributed on an "AS IS" BASIS,
-// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-// See the License for the specific language governing permissions and
-// limitations under the License.
-
-// modified by Bevy contributors
-
-use super::{Archetype, Component, Entity, MissingComponent, QueryAccess, QueryFilter};
-use crate::{ComponentFlags, EntityFilter};
-use std::{
-    marker::PhantomData,
-    ops::{Deref, DerefMut},
-    ptr::NonNull,
-    vec,
-};
-
-/// A collection of component types to fetch from a `World`
-pub trait WorldQuery {
-    #[doc(hidden)]
-    type Fetch: for<'a> Fetch<'a>;
-}
-
-/// A fetch that is read only. This should only be implemented for read-only fetches.
-pub unsafe trait ReadOnlyFetch {}
-
-/// Streaming iterators over contiguous homogeneous ranges of components
-pub trait Fetch<'a>: Sized {
-    /// Type of value to be fetched
-    type Item;
-
-    /// A value on which `get` may never be called
-    #[allow(clippy::declare_interior_mutable_const)] // no const fn in traits
-    const DANGLING: Self;
-
-    /// How this query will access `archetype`, if at all
-    fn access() -> QueryAccess;
-
-    /// Construct a `Fetch` for `archetype` if it should be traversed
-    ///
-    /// # Safety
-    /// `offset` must be in bounds of `archetype`
-    unsafe fn get(archetype: &'a Archetype, offset: usize) -> Option<Self>;
-
-    /// Access the `n`th item in this archetype without bounds checking
-    ///
-    /// # Safety
-    /// - Must only be called after `borrow`
-    /// - `release` must not be called while `'a` is still live
-    /// - Bounds-checking must be performed externally
-    /// - Any resulting borrows must be legal (e.g. no &mut to something another iterator might access)
-    unsafe fn fetch(&self, n: usize) -> Self::Item;
-}
-
-#[derive(Copy, Clone, Debug)]
-pub struct EntityFetch(NonNull<Entity>);
-unsafe impl ReadOnlyFetch for EntityFetch {}
-
-impl WorldQuery for Entity {
-    type Fetch = EntityFetch;
-}
-
-impl<'a> Fetch<'a> for EntityFetch {
-    type Item = Entity;
-
-    const DANGLING: Self = Self(NonNull::dangling());
-
-    #[inline]
-    unsafe fn get(archetype: &'a Archetype, offset: usize) -> Option<Self> {
-        Some(EntityFetch(NonNull::new_unchecked(
-            archetype.entities().as_ptr().add(offset),
-        )))
-    }
-
-    #[inline]
-    unsafe fn fetch(&self, n: usize) -> Self::Item {
-        *self.0.as_ptr().add(n)
-    }
-
-    #[inline]
-    fn access() -> QueryAccess {
-        QueryAccess::None
-    }
-}
-
-impl<'a, T: Component> WorldQuery for &'a T {
-    type Fetch = FetchRead<T>;
-}
-
-#[doc(hidden)]
-pub struct FetchRead<T>(NonNull<T>);
-
-unsafe impl<T> ReadOnlyFetch for FetchRead<T> {}
-
-impl<'a, T: Component> Fetch<'a> for FetchRead<T> {
-    type Item = &'a T;
-
-    const DANGLING: Self = Self(NonNull::dangling());
-
-    unsafe fn get(archetype: &'a Archetype, offset: usize) -> Option<Self> {
-        archetype
-            .get::<T>()
-            .map(|x| Self(NonNull::new_unchecked(x.as_ptr().add(offset))))
-    }
-
-    #[inline]
-    unsafe fn fetch(&self, n: usize) -> &'a T {
-        &*self.0.as_ptr().add(n)
-    }
-
-    #[inline]
-    fn access() -> QueryAccess {
-        QueryAccess::read::<T>()
-    }
-}
-
-impl<'a, T: Component> WorldQuery for &'a mut T {
-    type Fetch = FetchMut<T>;
-}
-
-impl<T: WorldQuery> WorldQuery for Option<T> {
-    type Fetch = TryFetch<T::Fetch>;
-}
-
-/// Flags on component `T` that happened since the start of the frame.
-#[derive(Clone)]
-pub struct Flags<T: Component> {
-    _marker: std::marker::PhantomData<T>,
-    with: bool,
-    added: bool,
-    mutated: bool,
-}
-impl<T: Component> std::fmt::Debug for Flags<T> {
-    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
-        f.debug_struct("Flags")
-            .field("with", &self.with)
-            .field("added", &self.added)
-            .field("mutated", &self.mutated)
-            .finish()
-    }
-}
-
-impl<T: Component> Flags<T> {
-    /// Does the entity have this component
-    pub fn with(&self) -> bool {
-        self.with
-    }
-
-    /// Has this component been added since the start of the frame.
-    pub fn added(&self) -> bool {
-        self.added
-    }
-
-    /// Has this component been mutated since the start of the frame.
-    pub fn mutated(&self) -> bool {
-        self.mutated
-    }
-
-    /// Has this component been either mutated or added since the start of the frame.
-    pub fn changed(&self) -> bool {
-        self.added || self.mutated
-    }
-}
-
-impl<T: Component> WorldQuery for Flags<T> {
-    type Fetch = FlagsFetch<T>;
-}
-
-/// Unique borrow of an entity's component
-pub struct Mut<'a, T: Component> {
-    pub(crate) value: &'a mut T,
-    pub(crate) flags: &'a mut ComponentFlags,
-}
-
-impl<'a, T: Component> Mut<'a, T> {
-    /// Creates a new mutable reference to a component. This is unsafe because the index bounds are not checked.
-    ///
-    /// # Safety
-    /// This doesn't check the bounds of index in archetype
-    pub unsafe fn new(archetype: &'a Archetype, index: usize) -> Result<Self, MissingComponent> {
-        let (target, type_state) = archetype
-            .get_with_type_state::<T>()
-            .ok_or_else(MissingComponent::new::<T>)?;
-        Ok(Self {
-            value: &mut *target.as_ptr().add(index),
-            flags: &mut *type_state.component_flags().as_ptr().add(index),
-        })
-    }
-}
-
-unsafe impl<T: Component> Send for Mut<'_, T> {}
-unsafe impl<T: Component> Sync for Mut<'_, T> {}
-
-impl<'a, T: Component> Deref for Mut<'a, T> {
-    type Target = T;
-
-    #[inline]
-    fn deref(&self) -> &T {
-        self.value
-    }
-}
-
-impl<'a, T: Component> DerefMut for Mut<'a, T> {
-    #[inline]
-    fn deref_mut(&mut self) -> &mut T {
-        self.flags.insert(ComponentFlags::MUTATED);
-        self.value
-    }
-}
-
-impl<'a, T: Component + core::fmt::Debug> core::fmt::Debug for Mut<'a, T> {
-    fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
-        self.value.fmt(f)
-    }
-}
-
-impl<'a, T: Component> WorldQuery for Mut<'a, T> {
-    type Fetch = FetchMut<T>;
-}
-#[doc(hidden)]
-pub struct FetchMut<T>(NonNull<T>, NonNull<ComponentFlags>);
-
-impl<'a, T: Component> Fetch<'a> for FetchMut<T> {
-    type Item = Mut<'a, T>;
-
-    const DANGLING: Self = Self(NonNull::dangling(), NonNull::dangling());
-
-    unsafe fn get(archetype: &'a Archetype, offset: usize) -> Option<Self> {
-        archetype
-            .get_with_type_state::<T>()
-            .map(|(components, type_state)| {
-                Self(
-                    NonNull::new_unchecked(components.as_ptr().add(offset)),
-                    NonNull::new_unchecked(type_state.component_flags().as_ptr().add(offset)),
-                )
-            })
-    }
-
-    #[inline]
-    unsafe fn fetch(&self, n: usize) -> Mut<'a, T> {
-        Mut {
-            value: &mut *self.0.as_ptr().add(n),
-            flags: &mut *self.1.as_ptr().add(n),
-        }
-    }
-
-    #[inline]
-    fn access() -> QueryAccess {
-        QueryAccess::write::<T>()
-    }
-}
-
-#[doc(hidden)]
-pub struct TryFetch<T>(Option<T>);
-unsafe impl<T> ReadOnlyFetch for TryFetch<T> where T: ReadOnlyFetch {}
-
-impl<'a, T: Fetch<'a>> Fetch<'a> for TryFetch<T> {
-    type Item = Option<T::Item>;
-
-    const DANGLING: Self = Self(None);
-
-    #[inline]
-    fn access() -> QueryAccess {
-        QueryAccess::optional(T::access())
-    }
-
-    unsafe fn get(archetype: &'a Archetype, offset: usize) -> Option<Self> {
-        Some(Self(T::get(archetype, offset)))
-    }
-
-    unsafe fn fetch(&self, n: usize) -> Option<T::Item> {
-        Some(self.0.as_ref()?.fetch(n))
-    }
-}
-
-#[doc(hidden)]
-pub struct FlagsFetch<T>(Option<NonNull<ComponentFlags>>, PhantomData<T>);
-unsafe impl<T> ReadOnlyFetch for FlagsFetch<T> {}
-
-impl<'a, T: Component> Fetch<'a> for FlagsFetch<T> {
-    type Item = Flags<T>;
-
-    const DANGLING: Self = Self(None, PhantomData::<T>);
-
-    #[inline]
-    fn access() -> QueryAccess {
-        QueryAccess::read::<T>()
-    }
-
-    unsafe fn get(archetype: &'a Archetype, offset: usize) -> Option<Self> {
-        Some(Self(
-            archetype
-                .get_type_state(std::any::TypeId::of::<T>())
-                .map(|type_state| {
-                    NonNull::new_unchecked(type_state.component_flags().as_ptr().add(offset))
-                }),
-            PhantomData::<T>,
-        ))
-    }
-
-    unsafe fn fetch(&self, n: usize) -> Self::Item {
-        if let Some(flags) = self.0.as_ref() {
-            let flags = *flags.as_ptr().add(n);
-            Self::Item {
-                _marker: PhantomData::<T>,
-                with: true,
-                added: flags.contains(ComponentFlags::ADDED),
-                mutated: flags.contains(ComponentFlags::MUTATED),
-            }
-        } else {
-            Self::Item {
-                _marker: PhantomData::<T>,
-                with: false,
-                added: false,
-                mutated: false,
-            }
-        }
-    }
-}
-
-struct ChunkInfo<Q: WorldQuery, F: QueryFilter> {
-    fetch: Q::Fetch,
-    filter: F::EntityFilter,
-    len: usize,
-}
-
-/// Iterator over the set of entities with the components in `Q`
-pub struct QueryIter<'w, Q: WorldQuery, F: QueryFilter> {
-    archetypes: &'w [Archetype],
-    archetype_index: usize,
-    chunk_info: ChunkInfo<Q, F>,
-    chunk_position: usize,
-}
-
-impl<'w, Q: WorldQuery, F: QueryFilter> QueryIter<'w, Q, F> {
-    const EMPTY: ChunkInfo<Q, F> = ChunkInfo {
-        fetch: Q::Fetch::DANGLING,
-        len: 0,
-        filter: F::EntityFilter::DANGLING,
-    };
-
-    /// Creates a new QueryIter
-    #[inline]
-    pub(crate) fn new(archetypes: &'w [Archetype]) -> Self {
-        Self {
-            archetypes,
-            archetype_index: 0,
-            chunk_info: Self::EMPTY,
-            chunk_position: 0,
-        }
-    }
-}
-
-impl<'w, Q: WorldQuery, F: QueryFilter> Iterator for QueryIter<'w, Q, F> {
-    type Item = <Q::Fetch as Fetch<'w>>::Item;
-
-    #[inline]
-    fn next(&mut self) -> Option<Self::Item> {
-        unsafe {
-            loop {
-                if self.chunk_position == self.chunk_info.len {
-                    let archetype = self.archetypes.get(self.archetype_index)?;
-                    self.archetype_index += 1;
-                    self.chunk_position = 0;
-                    self.chunk_info = Q::Fetch::get(archetype, 0)
-                        .and_then(|fetch| {
-                            Some(ChunkInfo {
-                                fetch,
-                                len: archetype.len(),
-                                filter: F::get_entity_filter(archetype)?,
-                            })
-                        })
-                        .unwrap_or(Self::EMPTY);
-                    continue;
-                }
-
-                if !self
-                    .chunk_info
-                    .filter
-                    .matches_entity(self.chunk_position as usize)
-                {
-                    self.chunk_position += 1;
-                    continue;
-                }
-
-                let item = Some(self.chunk_info.fetch.fetch(self.chunk_position as usize));
-                self.chunk_position += 1;
-                return item;
-            }
-        }
-    }
-}
-
-// if the Fetch is an UnfilteredFetch, then we can cheaply compute the length of the query by getting
-// the length of each matching archetype
-impl<'w, Q: WorldQuery> ExactSizeIterator for QueryIter<'w, Q, ()> {
-    fn len(&self) -> usize {
-        self.archetypes
-            .iter()
-            .filter(|&archetype| unsafe { Q::Fetch::get(archetype, 0).is_some() })
-            .map(|x| x.len())
-            .sum()
-    }
-}
-
-struct ChunkIter<Q: WorldQuery, F: QueryFilter> {
-    fetch: Q::Fetch,
-    filter: F::EntityFilter,
-    position: usize,
-    len: usize,
-}
-
-impl<Q: WorldQuery, F: QueryFilter> ChunkIter<Q, F> {
-    unsafe fn next<'a>(&mut self) -> Option<<Q::Fetch as Fetch<'a>>::Item> {
-        loop {
-            if self.position == self.len {
-                return None;
-            }
-
-            if !self.filter.matches_entity(self.position as usize) {
-                self.position += 1;
-                continue;
-            }
-
-            let item = Some(self.fetch.fetch(self.position as usize));
-            self.position += 1;
-            return item;
-        }
-    }
-}
-
-/// Batched version of `QueryIter`
-pub struct BatchedIter<'w, Q: WorldQuery, F: QueryFilter> {
-    archetypes: &'w [Archetype],
-    archetype_index: usize,
-    batch_size: usize,
-    batch: usize,
-    _marker: PhantomData<(Q, F)>,
-}
-
-impl<'w, Q: WorldQuery, F: QueryFilter> BatchedIter<'w, Q, F> {
-    pub(crate) fn new(archetypes: &'w [Archetype], batch_size: usize) -> Self {
-        Self {
-            archetypes,
-            archetype_index: 0,
-            batch_size,
-            batch: 0,
-            _marker: Default::default(),
-        }
-    }
-}
-
-unsafe impl<'w, Q: WorldQuery, F: QueryFilter> Send for BatchedIter<'w, Q, F> {}
-unsafe impl<'w, Q: WorldQuery, F: QueryFilter> Sync for BatchedIter<'w, Q, F> {}
-
-impl<'w, Q: WorldQuery, F: QueryFilter> Iterator for BatchedIter<'w, Q, F> {
-    type Item = Batch<'w, Q, F>;
-
-    fn next(&mut self) -> Option<Self::Item> {
-        loop {
-            let archetype = self.archetypes.get(self.archetype_index)?;
-            let offset = self.batch_size * self.batch;
-            if offset >= archetype.len() {
-                self.archetype_index += 1;
-                self.batch = 0;
-                continue;
-            }
-            if let (Some(fetch), Some(filter)) = (
-                unsafe { Q::Fetch::get(archetype, offset) },
-                F::get_entity_filter(archetype),
-            ) {
-                self.batch += 1;
-                return Some(Batch {
-                    _marker: PhantomData,
-                    state: ChunkIter {
-                        fetch,
-                        position: 0,
-                        len: self.batch_size.min(archetype.len() - offset),
-                        filter,
-                    },
-                });
-            } else {
-                self.archetype_index += 1;
-                debug_assert_eq!(
-                    self.batch, 0,
-                    "query fetch should always reject at the first batch or not at all"
-                );
-                continue;
-            }
-        }
-    }
-}
-
-/// A sequence of entities yielded by `BatchedIter`
-pub struct Batch<'q, Q: WorldQuery, F: QueryFilter> {
-    _marker: PhantomData<&'q ()>,
-    state: ChunkIter<Q, F>,
-}
-
-impl<'q, 'w, Q: WorldQuery, F: QueryFilter> Iterator for Batch<'q, Q, F> {
-    type Item = <Q::Fetch as Fetch<'q>>::Item;
-
-    fn next(&mut self) -> Option<Self::Item> {
-        let components = unsafe { self.state.next()? };
-        Some(components)
-    }
-}
-
-unsafe impl<'q, Q: WorldQuery, F: QueryFilter> Send for Batch<'q, Q, F> {}
-unsafe impl<'q, Q: WorldQuery, F: QueryFilter> Sync for Batch<'q, Q, F> {}
-
-macro_rules! tuple_impl {
-    ($($name: ident),*) => {
-        impl<'a, $($name: Fetch<'a>),*> Fetch<'a> for ($($name,)*) {
-            type Item = ($($name::Item,)*);
-            const DANGLING: Self = ($($name::DANGLING,)*);
-
-            #[allow(unused_variables, unused_mut)]
-            fn access() -> QueryAccess {
-                QueryAccess::union(vec![
-                    $($name::access(),)*
-                ])
-            }
-
-            #[allow(unused_variables)]
-            unsafe fn get(archetype: &'a Archetype, offset: usize) -> Option<Self> {
-                Some(($($name::get(archetype, offset)?,)*))
-            }
-
-            #[allow(unused_variables)]
-            unsafe fn fetch(&self, n: usize) -> Self::Item {
-                #[allow(non_snake_case)]
-                let ($($name,)*) = self;
-                ($($name.fetch(n),)*)
-            }
-        }
-
-        impl<$($name: WorldQuery),*> WorldQuery for ($($name,)*) {
-            type Fetch = ($($name::Fetch,)*);
-        }
-
-        unsafe impl<$($name: ReadOnlyFetch),*> ReadOnlyFetch for ($($name,)*) {}
-    };
-}
-
-smaller_tuples_too!(tuple_impl, O, N, M, L, K, J, I, H, G, F, E, D, C, B, A);
-
-#[cfg(test)]
-mod tests {
-    use crate::core::{Added, Changed, Component, Entity, Flags, Mutated, Or, QueryFilter, World};
-    use std::{vec, vec::Vec};
-
-    use super::Mut;
-
-    struct A(usize);
-    struct B(usize);
-    struct C;
-
-    #[test]
-    fn added_queries() {
-        let mut world = World::default();
-        let e1 = world.spawn((A(0),));
-
-        fn get_added<Com: Component>(world: &World) -> Vec<Entity> {
-            world
-                .query_filtered::<Entity, Added<Com>>()
-                .collect::<Vec<Entity>>()
-        }
-
-        assert_eq!(get_added::<A>(&world), vec![e1]);
-        world.insert(e1, (B(0),)).unwrap();
-        assert_eq!(get_added::<A>(&world), vec![e1]);
-        assert_eq!(get_added::<B>(&world), vec![e1]);
-
-        world.clear_trackers();
-        assert!(get_added::<A>(&world).is_empty());
-        let e2 = world.spawn((A(1), B(1)));
-        assert_eq!(get_added::<A>(&world), vec![e2]);
-        assert_eq!(get_added::<B>(&world), vec![e2]);
-
-        let added = world
-            .query_filtered::<Entity, (Added<A>, Added<B>)>()
-            .collect::<Vec<Entity>>();
-        assert_eq!(added, vec![e2]);
-    }
-
-    #[test]
-    fn mutated_trackers() {
-        let mut world = World::default();
-        let e1 = world.spawn((A(0), B(0)));
-        let e2 = world.spawn((A(0), B(0)));
-        let e3 = world.spawn((A(0), B(0)));
-        world.spawn((A(0), B));
-
-        for (i, mut a) in world.query_mut::<Mut<A>>().enumerate() {
-            if i % 2 == 0 {
-                a.0 += 1;
-            }
-        }
-
-        fn get_filtered<F: QueryFilter>(world: &mut World) -> Vec<Entity> {
-            world.query_filtered::<Entity, F>().collect::<Vec<Entity>>()
-        }
-
-        assert_eq!(get_filtered::<Mutated<A>>(&mut world), vec![e1, e3]);
-
-        // ensure changing an entity's archetypes also moves its mutated state
-        world.insert(e1, (C,)).unwrap();
-
-        assert_eq!(get_filtered::<Mutated<A>>(&mut world), vec![e3, e1], "changed entities list should not change (although the order will due to archetype moves)");
-
-        // spawning a new A entity should not change existing mutated state
-        world.insert(e1, (A(0), B)).unwrap();
-        assert_eq!(
-            get_filtered::<Mutated<A>>(&mut world),
-            vec![e3, e1],
-            "changed entities list should not change"
-        );
-
-        // removing an unchanged entity should not change mutated state
-        world.despawn(e2).unwrap();
-        assert_eq!(
-            get_filtered::<Mutated<A>>(&mut world),
-            vec![e3, e1],
-            "changed entities list should not change"
-        );
-
-        // removing a changed entity should remove it from enumeration
-        world.despawn(e1).unwrap();
-        assert_eq!(
-            get_filtered::<Mutated<A>>(&mut world),
-            vec![e3],
-            "e1 should no longer be returned"
-        );
-
-        world.clear_trackers();
-
-        assert!(get_filtered::<Mutated<A>>(&mut world).is_empty());
-
-        let e4 = world.spawn(());
-
-        world.insert_one(e4, A(0)).unwrap();
-        assert!(get_filtered::<Mutated<A>>(&mut world).is_empty());
-        assert_eq!(get_filtered::<Added<A>>(&mut world), vec![e4]);
-
-        world.insert_one(e4, A(1)).unwrap();
-        assert_eq!(get_filtered::<Mutated<A>>(&mut world), vec![e4]);
-
-        world.clear_trackers();
-
-        // ensure inserting multiple components set mutated state for
-        // already existing components and set added state for
-        // non existing components even when changing archetype.
-        world.insert(e4, (A(0), B(0))).unwrap();
-
-        assert!(get_filtered::<Added<A>>(&mut world).is_empty());
-        assert_eq!(get_filtered::<Mutated<A>>(&mut world), vec![e4]);
-        assert_eq!(get_filtered::<Added<B>>(&mut world), vec![e4]);
-        assert!(get_filtered::<Mutated<B>>(&mut world).is_empty());
-    }
-
-    #[test]
-    fn multiple_mutated_query() {
-        let mut world = World::default();
-        world.spawn((A(0), B(0)));
-        let e2 = world.spawn((A(0), B(0)));
-        world.spawn((A(0), B(0)));
-
-        for mut a in world.query_mut::<Mut<A>>() {
-            a.0 += 1;
-        }
-
-        for mut b in world.query_mut::<Mut<B>>().skip(1).take(1) {
-            b.0 += 1;
-        }
-
-        let a_b_mutated = world
-            .query_filtered_mut::<Entity, (Mutated<A>, Mutated<B>)>()
-            .collect::<Vec<Entity>>();
-        assert_eq!(a_b_mutated, vec![e2]);
-    }
-
-    #[test]
-    fn or_mutated_query() {
-        let mut world = World::default();
-        let e1 = world.spawn((A(0), B(0)));
-        let e2 = world.spawn((A(0), B(0)));
-        let e3 = world.spawn((A(0), B(0)));
-        let _e4 = world.spawn((A(0), B(0)));
-
-        // Mutate A in entities e1 and e2
-        for mut a in world.query_mut::<Mut<A>>().take(2) {
-            a.0 += 1;
-        }
-        // Mutate B in entities e2 and e3
-        for mut b in world.query_mut::<Mut<B>>().skip(1).take(2) {
-            b.0 += 1;
-        }
-
-        let a_b_mutated = world
-            .query_filtered_mut::<Entity, Or<(Mutated<A>, Mutated<B>)>>()
-            .collect::<Vec<Entity>>();
-        // e1 has mutated A, e3 has mutated B, e2 has mutated A and B, _e4 has no mutated component
-        assert_eq!(a_b_mutated, vec![e1, e2, e3]);
-    }
-
-    #[test]
-    fn changed_query() {
-        let mut world = World::default();
-        let e1 = world.spawn((A(0), B(0)));
-
-        fn get_changed(world: &World) -> Vec<Entity> {
-            world
-                .query_filtered::<Entity, Changed<A>>()
-                .collect::<Vec<Entity>>()
-        }
-        assert_eq!(get_changed(&world), vec![e1]);
-        world.clear_trackers();
-        assert_eq!(get_changed(&world), vec![]);
-        *world.get_mut(e1).unwrap() = A(1);
-        assert_eq!(get_changed(&world), vec![e1]);
-    }
-
-    #[test]
-    fn flags_query() {
-        let mut world = World::default();
-        let e1 = world.spawn((A(0), B(0)));
-        world.spawn((B(0),));
-
-        fn get_flags(world: &World) -> Vec<Flags<A>> {
-            world.query::<Flags<A>>().collect::<Vec<Flags<A>>>()
-        }
-        let flags = get_flags(&world);
-        assert!(flags[0].with());
-        assert!(flags[0].added());
-        assert!(!flags[0].mutated());
-        assert!(flags[0].changed());
-        assert!(!flags[1].with());
-        assert!(!flags[1].added());
-        assert!(!flags[1].mutated());
-        assert!(!flags[1].changed());
-        world.clear_trackers();
-        let flags = get_flags(&world);
-        assert!(flags[0].with());
-        assert!(!flags[0].added());
-        assert!(!flags[0].mutated());
-        assert!(!flags[0].changed());
-        *world.get_mut(e1).unwrap() = A(1);
-        let flags = get_flags(&world);
-        assert!(flags[0].with());
-        assert!(!flags[0].added());
-        assert!(flags[0].mutated());
-        assert!(flags[0].changed());
-    }
-
-    #[test]
-    fn exact_size_query() {
-        let mut world = World::default();
-        world.spawn((A(0), B(0)));
-        world.spawn((A(0), B(0)));
-        world.spawn((C,));
-
-        assert_eq!(world.query::<(&A, &B)>().len(), 2);
-        // the following example shouldn't compile because Changed<A> is not an UnfilteredFetch
-        // assert_eq!(world.query::<(Changed<A>, &B)>().len(), 2);
-    }
-}
diff --git a/crates/bevy_ecs/src/core/world.rs b/crates/bevy_ecs/src/core/world.rs
deleted file mode 100644
index 44c64295dcede..0000000000000
--- a/crates/bevy_ecs/src/core/world.rs
+++ /dev/null
@@ -1,1150 +0,0 @@
-// Copyright 2019 Google LLC
-//
-// Licensed under the Apache License, Version 2.0 (the "License");
-// you may not use this file except in compliance with the License.
-// You may obtain a copy of the License at
-//
-//     https://www.apache.org/licenses/LICENSE-2.0
-//
-// Unless required by applicable law or agreed to in writing, software
-// distributed under the License is distributed on an "AS IS" BASIS,
-// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-// See the License for the specific language governing permissions and
-// limitations under the License.
-
-// modified by Bevy contributors
-
-use crate::{
-    core::entities::Entities, Archetype, BatchedIter, Bundle, ComponentFlags, DynamicBundle,
-    Entity, EntityFilter, EntityReserver, Fetch, Location, MissingComponent, Mut, NoSuchEntity,
-    QueryFilter, QueryIter, ReadOnlyFetch, Ref, RefMut, WorldQuery,
-};
-use bevy_utils::{HashMap, HashSet};
-use std::{any::TypeId, fmt, mem, ptr};
-
-use super::borrow::EntityRef;
-
-/// An unordered collection of entities, each having any number of distinctly typed components
-///
-/// Similar to `HashMap<Entity, Vec<Box<dyn Any>>>` where each `Vec` never contains two of the same
-/// type, but far more efficient to traverse.
-///
-/// The components of entities who have the same set of component types are stored in contiguous
-/// runs, allowing for extremely fast, cache-friendly iteration.
-#[derive(Debug)]
-pub struct World {
-    entities: Entities,
-    index: HashMap<Vec<TypeId>, u32>,
-    removed_components: HashMap<TypeId, Vec<Entity>>,
-    #[allow(missing_docs)]
-    pub archetypes: Vec<Archetype>,
-    archetype_generation: u64,
-}
-
-impl World {
-    /// Create an empty world
-    pub fn new() -> Self {
-        // `flush` assumes archetype 0 always exists, representing entities with no components.
-        let archetypes = vec![Archetype::new(Vec::new())];
-        let mut index = HashMap::default();
-        index.insert(Vec::new(), 0);
-        Self {
-            entities: Entities::default(),
-            index,
-            archetypes,
-            archetype_generation: 0,
-            removed_components: HashMap::default(),
-        }
-    }
-
-    /// Create an entity with certain components
-    ///
-    /// Returns the ID of the newly created entity.
-    ///
-    /// Arguments can be tuples, structs annotated with `#[derive(Bundle)]`, or the result of
-    /// calling `build` on an `EntityBuilder`, which is useful if the set of components isn't
-    /// statically known. To spawn an entity with only one component, use a one-element tuple like
-    /// `(x,)`.
-    ///
-    /// Any type that satisfies `Send + Sync + 'static` can be used as a component.
-    ///
-    /// # Example
-    /// ```
-    /// # use bevy_ecs::*;
-    /// let mut world = World::new();
-    /// let a = world.spawn((123, "abc"));
-    /// let b = world.spawn((456, true));
-    /// ```
-    pub fn spawn(&mut self, bundle: impl DynamicBundle) -> Entity {
-        // Ensure all entity allocations are accounted for so `self.entities` can realloc if
-        // necessary
-        self.flush();
-
-        let entity = self.entities.alloc();
-        let archetype_id = bundle.with_ids(|ids| {
-            self.index.get(ids).copied().unwrap_or_else(|| {
-                let x = self.archetypes.len() as u32;
-                self.archetypes.push(Archetype::new(bundle.type_info()));
-                self.index.insert(ids.to_vec(), x);
-                self.archetype_generation += 1;
-                x
-            })
-        });
-
-        let archetype = &mut self.archetypes[archetype_id as usize];
-        unsafe {
-            let index = archetype.allocate(entity);
-            bundle.put(|ptr, ty, size| {
-                archetype.put_dynamic(ptr, ty, size, index, ComponentFlags::ADDED);
-                true
-            });
-            self.entities.meta[entity.id as usize].location = Location {
-                archetype: archetype_id,
-                index,
-            };
-        }
-
-        entity
-    }
-
-    /// Efficiently spawn a large number of entities with the same components
-    ///
-    /// Faster than calling `spawn` repeatedly with the same components.
-    ///
-    /// # Example
-    /// ```
-    /// # use bevy_ecs::*;
-    /// let mut world = World::new();
-    /// let entities = world.spawn_batch((0..1_000).map(|i| (i, "abc"))).collect::<Vec<_>>();
-    /// for i in 0..1_000 {
-    ///     assert_eq!(*world.get::<i32>(entities[i]).unwrap(), i as i32);
-    /// }
-    /// ```
-    pub fn spawn_batch<I>(&mut self, iter: I) -> SpawnBatchIter<'_, I::IntoIter>
-    where
-        I: IntoIterator,
-        I::Item: Bundle,
-    {
-        // Ensure all entity allocations are accounted for so `self.entities` can realloc if
-        // necessary
-        self.flush();
-
-        let iter = iter.into_iter();
-        let (lower, upper) = iter.size_hint();
-        let archetype_id = self.reserve_inner::<I::Item>(upper.unwrap_or(lower) as u32);
-
-        SpawnBatchIter {
-            inner: iter,
-            entities: &mut self.entities,
-            archetype_id,
-            archetype: &mut self.archetypes[archetype_id as usize],
-        }
-    }
-
-    /// Destroy an entity and all its components
-    pub fn despawn(&mut self, entity: Entity) -> Result<(), NoSuchEntity> {
-        self.flush();
-
-        let loc = self.entities.free(entity)?;
-        let archetype = &mut self.archetypes[loc.archetype as usize];
-        if let Some(moved) = unsafe { archetype.remove(loc.index) } {
-            self.entities.get_mut(moved).unwrap().index = loc.index;
-        }
-        for ty in archetype.types() {
-            let removed_entities = self
-                .removed_components
-                .entry(ty.id())
-                .or_insert_with(Vec::new);
-            removed_entities.push(entity);
-        }
-        Ok(())
-    }
-
-    /// Ensure `additional` entities with exact components `T` can be spawned without reallocating
-    pub fn reserve<T: Bundle>(&mut self, additional: u32) {
-        self.reserve_inner::<T>(additional);
-    }
-
-    /// Reserves an entity.
-    pub fn reserve_entity(&self) -> Entity {
-        self.entities.reserve_entity()
-    }
-
-    fn reserve_inner<T: Bundle>(&mut self, additional: u32) -> u32 {
-        self.flush();
-        self.entities.reserve(additional);
-
-        let archetype_id = T::with_static_ids(|ids| {
-            self.index.get(ids).copied().unwrap_or_else(|| {
-                let x = self.archetypes.len() as u32;
-                self.archetypes.push(Archetype::new(T::static_type_info()));
-                self.index.insert(ids.to_vec(), x);
-                self.archetype_generation += 1;
-                x
-            })
-        });
-
-        self.archetypes[archetype_id as usize].reserve(additional as usize);
-        archetype_id
-    }
-
-    /// Despawn all entities
-    ///
-    /// Preserves allocated storage for reuse.
-    pub fn clear(&mut self) {
-        for archetype in &mut self.archetypes {
-            for ty in archetype.types() {
-                let removed_entities = self
-                    .removed_components
-                    .entry(ty.id())
-                    .or_insert_with(Vec::new);
-                removed_entities.extend(archetype.iter_entities().copied());
-            }
-            archetype.clear();
-        }
-        self.entities.clear();
-    }
-
-    /// Whether `entity` still exists
-    pub fn contains(&self, entity: Entity) -> bool {
-        self.entities.contains(entity)
-    }
-
-    /// Returns true if the given entity has a component with the given type id.
-    pub fn has_component_type(&self, entity: Entity, ty: TypeId) -> bool {
-        self.get_entity_location(entity)
-            .map(|location| &self.archetypes[location.archetype as usize])
-            .map(|archetype| archetype.has_type(ty))
-            .unwrap_or(false)
-    }
-
-    /// Efficiently iterate over all entities that have certain components
-    ///
-    /// Calling `iter` on the returned value yields `(Entity, Q)` tuples, where `Q` is some query
-    /// type. A query type is `&T`, `&mut T`, a tuple of query types, or an `Option` wrapping a
-    /// query type, where `T` is any component type. Components queried with `&mut` must only appear
-    /// once. Entities which do not have a component type referenced outside of an `Option` will be
-    /// skipped.
-    ///
-    /// Entities are yielded in arbitrary order.
-    ///
-    /// # Example
-    /// ```
-    /// # use bevy_ecs::*;
-    /// let mut world = World::new();
-    /// let a = world.spawn((123, true, "abc"));
-    /// let b = world.spawn((456, false));
-    /// let c = world.spawn((42, "def"));
-    /// let entities = world.query::<(Entity, &i32, &bool)>()
-    ///     .map(|(e, &i, &b)| (e, i, b)) // Copy out of the world
-    ///     .collect::<Vec<_>>();
-    /// assert_eq!(entities.len(), 2);
-    /// assert!(entities.contains(&(a, 123, true)));
-    /// assert!(entities.contains(&(b, 456, false)));
-    /// ```
-    #[inline]
-    pub fn query<Q: WorldQuery>(&self) -> QueryIter<'_, Q, ()>
-    where
-        Q::Fetch: ReadOnlyFetch,
-    {
-        // SAFE: read-only access to world and read only query prevents mutable access
-        unsafe { self.query_unchecked() }
-    }
-
-    #[inline]
-    pub fn query_filtered<Q: WorldQuery, F: QueryFilter>(&self) -> QueryIter<'_, Q, F>
-    where
-        Q::Fetch: ReadOnlyFetch,
-    {
-        // SAFE: read-only access to world and read only query prevents mutable access
-        unsafe { self.query_unchecked() }
-    }
-
-    /// Efficiently iterate over all entities that have certain components
-    ///
-    /// Calling `iter` on the returned value yields `(Entity, Q)` tuples, where `Q` is some query
-    /// type. A query type is `&T`, `&mut T`, a tuple of query types, or an `Option` wrapping a
-    /// query type, where `T` is any component type. Components queried with `&mut` must only appear
-    /// once. Entities which do not have a component type referenced outside of an `Option` will be
-    /// skipped.
-    ///
-    /// Entities are yielded in arbitrary order.
-    ///
-    /// # Example
-    /// ```
-    /// # use bevy_ecs::*;
-    /// let mut world = World::new();
-    /// let a = world.spawn((123, true, "abc"));
-    /// let b = world.spawn((456, false));
-    /// let c = world.spawn((42, "def"));
-    /// let entities = world.query_mut::<(Entity, &mut i32, &bool)>()
-    ///     .map(|(e, i, &b)| (e, *i, b)) // Copy out of the world
-    ///     .collect::<Vec<_>>();
-    /// assert_eq!(entities.len(), 2);
-    /// assert!(entities.contains(&(a, 123, true)));
-    /// assert!(entities.contains(&(b, 456, false)));
-    /// ```
-    #[inline]
-    pub fn query_mut<Q: WorldQuery>(&mut self) -> QueryIter<'_, Q, ()> {
-        // SAFE: unique mutable access
-        unsafe { self.query_unchecked() }
-    }
-
-    #[inline]
-    pub fn query_filtered_mut<Q: WorldQuery, F: QueryFilter>(&mut self) -> QueryIter<'_, Q, F> {
-        // SAFE: unique mutable access
-        unsafe { self.query_unchecked() }
-    }
-
-    /// Like `query`, but instead of returning a single iterator it returns a "batched iterator",
-    /// where each batch is `batch_size`. This is generally used for parallel iteration.
-    #[inline]
-    pub fn query_batched<Q: WorldQuery>(&self, batch_size: usize) -> BatchedIter<'_, Q, ()>
-    where
-        Q::Fetch: ReadOnlyFetch,
-    {
-        // SAFE: read-only access to world and read only query prevents mutable access
-        unsafe { self.query_batched_unchecked(batch_size) }
-    }
-
-    #[inline]
-    pub fn query_batched_filtered<Q: WorldQuery, F: QueryFilter>(
-        &self,
-        batch_size: usize,
-    ) -> BatchedIter<'_, Q, F>
-    where
-        Q::Fetch: ReadOnlyFetch,
-    {
-        // SAFE: read-only access to world and read only query prevents mutable access
-        unsafe { self.query_batched_unchecked(batch_size) }
-    }
-
-    /// Like `query`, but instead of returning a single iterator it returns a "batched iterator",
-    /// where each batch is `batch_size`. This is generally used for parallel iteration.
-    #[inline]
-    pub fn query_batched_mut<Q: WorldQuery>(
-        &mut self,
-        batch_size: usize,
-    ) -> BatchedIter<'_, Q, ()> {
-        // SAFE: unique mutable access
-        unsafe { self.query_batched_unchecked(batch_size) }
-    }
-
-    #[inline]
-    pub fn query_batched_filtered_mut<Q: WorldQuery, F: QueryFilter>(
-        &mut self,
-        batch_size: usize,
-    ) -> BatchedIter<'_, Q, F> {
-        // SAFE: unique mutable access
-        unsafe { self.query_batched_unchecked(batch_size) }
-    }
-
-    /// Efficiently iterate over all entities that have certain components
-    ///
-    /// Calling `iter` on the returned value yields `(Entity, Q)` tuples, where `Q` is some query
-    /// type. A query type is `&T`, `&mut T`, a tuple of query types, or an `Option` wrapping a
-    /// query type, where `T` is any component type. Components queried with `&mut` must only appear
-    /// once. Entities which do not have a component type referenced outside of an `Option` will be
-    /// skipped.
-    ///
-    /// Entities are yielded in arbitrary order.
-    ///
-    /// # Safety
-    /// This does not check for mutable query correctness. To be safe, make sure mutable queries
-    /// have unique access to the components they query.
-    #[inline]
-    pub unsafe fn query_unchecked<Q: WorldQuery, F: QueryFilter>(&self) -> QueryIter<'_, Q, F> {
-        QueryIter::new(&self.archetypes)
-    }
-
-    /// Like `query`, but instead of returning a single iterator it returns a "batched iterator",
-    /// where each batch is `batch_size`. This is generally used for parallel iteration.
-    ///
-    /// # Safety
-    /// This does not check for mutable query correctness. To be safe, make sure mutable queries
-    /// have unique access to the components they query.
-    #[inline]
-    pub unsafe fn query_batched_unchecked<Q: WorldQuery, F: QueryFilter>(
-        &self,
-        batch_size: usize,
-    ) -> BatchedIter<'_, Q, F> {
-        BatchedIter::new(&self.archetypes, batch_size)
-    }
-
-    /// Prepare a read only query against a single entity
-    ///
-    /// Handy for accessing multiple components simultaneously.
-    ///
-    /// # Example
-    /// ```
-    /// # use bevy_ecs::*;
-    /// let mut world = World::new();
-    /// let a = world.spawn((123, true, "abc"));
-    /// // The returned query must outlive the borrow made by `get`
-    /// let (number, flag) = world.query_one::<(&i32, &bool)>(a).unwrap();
-    /// assert_eq!(*number, 123);
-    /// ```
-    #[inline]
-    pub fn query_one<Q: WorldQuery>(
-        &self,
-        entity: Entity,
-    ) -> Result<<Q::Fetch as Fetch>::Item, NoSuchEntity>
-    where
-        Q::Fetch: ReadOnlyFetch,
-    {
-        // SAFE: read-only access to world and read only query prevents mutable access
-        unsafe { self.query_one_unchecked::<Q, ()>(entity) }
-    }
-
-    #[inline]
-    pub fn query_one_filtered<Q: WorldQuery, F: QueryFilter>(
-        &self,
-        entity: Entity,
-    ) -> Result<<Q::Fetch as Fetch>::Item, NoSuchEntity>
-    where
-        Q::Fetch: ReadOnlyFetch,
-    {
-        // SAFE: read-only access to world and read only query prevents mutable access
-        unsafe { self.query_one_unchecked::<Q, F>(entity) }
-    }
-
-    /// Prepare a query against a single entity
-    ///
-    /// Handy for accessing multiple components simultaneously.
-    ///
-    /// # Example
-    /// ```
-    /// # use bevy_ecs::*;
-    /// let mut world = World::new();
-    /// let a = world.spawn((123, true, "abc"));
-    /// // The returned query must outlive the borrow made by `get`
-    /// let (mut number, flag) = world.query_one_mut::<(&mut i32, &bool)>(a).unwrap();
-    /// if *flag { *number *= 2; }
-    /// assert_eq!(*number, 246);
-    /// ```
-    #[inline]
-    pub fn query_one_mut<Q: WorldQuery>(
-        &mut self,
-        entity: Entity,
-    ) -> Result<<Q::Fetch as Fetch>::Item, NoSuchEntity> {
-        // SAFE: unique mutable access to world
-        unsafe { self.query_one_unchecked::<Q, ()>(entity) }
-    }
-
-    #[inline]
-    pub fn query_one_filtered_mut<Q: WorldQuery, F: QueryFilter>(
-        &mut self,
-        entity: Entity,
-    ) -> Result<<Q::Fetch as Fetch>::Item, NoSuchEntity> {
-        // SAFE: unique mutable access to world
-        unsafe { self.query_one_unchecked::<Q, F>(entity) }
-    }
-
-    /// Prepare a query against a single entity, without checking the safety of mutable queries
-    ///
-    /// Handy for accessing multiple components simultaneously.
-    ///
-    /// # Safety
-    /// This does not check for mutable query correctness. To be safe, make sure mutable queries
-    /// have unique access to the components they query.
-    #[inline]
-    pub unsafe fn query_one_unchecked<Q: WorldQuery, F: QueryFilter>(
-        &self,
-        entity: Entity,
-    ) -> Result<<Q::Fetch as Fetch>::Item, NoSuchEntity> {
-        let loc = self.entities.get(entity)?;
-        let archetype = &self.archetypes[loc.archetype as usize];
-        let matches_filter = F::get_entity_filter(archetype)
-            .map(|entity_filter| entity_filter.matches_entity(loc.index))
-            .unwrap_or(false);
-        if matches_filter {
-            <Q::Fetch as Fetch>::get(archetype, 0)
-                .map(|fetch| fetch.fetch(loc.index))
-                .ok_or(NoSuchEntity)
-        } else {
-            Err(NoSuchEntity)
-        }
-    }
-
-    /// Borrow the `T` component of `entity`
-    #[inline]
-    pub fn get<T: Component>(&self, entity: Entity) -> Result<&'_ T, ComponentError> {
-        unsafe {
-            let loc = self.entities.get(entity)?;
-            if loc.archetype == 0 {
-                return Err(MissingComponent::new::<T>().into());
-            }
-            Ok(&*self.archetypes[loc.archetype as usize]
-                .get::<T>()
-                .ok_or_else(MissingComponent::new::<T>)?
-                .as_ptr()
-                .add(loc.index as usize))
-        }
-    }
-
-    /// Mutably borrow the `T` component of `entity`
-    #[inline]
-    pub fn get_mut<T: Component>(&mut self, entity: Entity) -> Result<Mut<'_, T>, ComponentError> {
-        // SAFE: uniquely borrows world
-        unsafe { self.get_mut_unchecked(entity) }
-    }
-
-    /// Access an entity regardless of its component types
-    ///
-    /// Does not immediately borrow any component.
-    pub fn entity(&mut self, entity: Entity) -> Result<EntityRef<'_>, NoSuchEntity> {
-        Ok(match self.entities.get(entity)? {
-            Location { archetype: 0, .. } => EntityRef::empty(),
-            loc => unsafe { EntityRef::new(&self.archetypes[loc.archetype as usize], loc.index) },
-        })
-    }
-
-    pub fn entity_count(&self) -> u32 {
-        self.entities.meta.len() as u32 - self.entities.freed_len()
-            + self.entities.reserved_len()
-            + self.entities.pending_len()
-    }
-
-    /// Borrow the `T` component of `entity` without checking if it can be mutated
-    ///
-    /// # Safety
-    /// This does not check for mutable access correctness. To be safe, make sure this is the only
-    /// thing accessing this entity's T component.
-    #[inline]
-    pub unsafe fn get_mut_unchecked<T: Component>(
-        &self,
-        entity: Entity,
-    ) -> Result<Mut<'_, T>, ComponentError> {
-        let loc = self.entities.get(entity)?;
-        if loc.archetype == 0 {
-            return Err(MissingComponent::new::<T>().into());
-        }
-        Ok(Mut::new(
-            &self.archetypes[loc.archetype as usize],
-            loc.index,
-        )?)
-    }
-
-    /// Iterate over all entities in the world
-    ///
-    /// Entities are yielded in arbitrary order. Prefer `World::query` for better performance when
-    /// components will be accessed in predictable patterns.
-    ///
-    /// # Example
-    /// ```
-    /// # use bevy_ecs::*;
-    /// let mut world = World::new();
-    /// let a = world.spawn(());
-    /// let b = world.spawn(());
-    /// let ids = world.iter().map(|(id, _)| id).collect::<Vec<_>>();
-    /// assert_eq!(ids.len(), 2);
-    /// assert!(ids.contains(&a));
-    /// assert!(ids.contains(&b));
-    /// ```
-    pub fn iter(&mut self) -> Iter<'_> {
-        Iter::new(&self.archetypes, &self.entities)
-    }
-
-    #[allow(missing_docs)]
-    pub fn removed<C: Component>(&self) -> &[Entity] {
-        self.removed_components
-            .get(&TypeId::of::<C>())
-            .map_or(&[], |entities| entities.as_slice())
-    }
-
-    /// Add `components` to `entity`
-    ///
-    /// Computational cost is proportional to the number of components `entity` has. If an entity
-    /// already has a component of a certain type, it is dropped and replaced.
-    ///
-    /// When inserting a single component, see `insert_one` for convenience.
-    ///
-    /// # Example
-    /// ```
-    /// # use bevy_ecs::*;
-    /// let mut world = World::new();
-    /// let e = world.spawn((123, "abc"));
-    /// world.insert(e, (456, true));
-    /// assert_eq!(*world.get::<i32>(e).unwrap(), 456);
-    /// assert_eq!(*world.get::<bool>(e).unwrap(), true);
-    /// ```
-    pub fn insert(
-        &mut self,
-        entity: Entity,
-        bundle: impl DynamicBundle,
-    ) -> Result<(), NoSuchEntity> {
-        use std::collections::hash_map::Entry;
-
-        self.flush();
-        let loc = self.entities.get_mut(entity)?;
-        unsafe {
-            // Assemble Vec<TypeInfo> for the final entity
-            let arch = &mut self.archetypes[loc.archetype as usize];
-            let mut info = arch.types().to_vec();
-            for ty in bundle.type_info() {
-                if let Some(ptr) = arch.get_dynamic(ty.id(), ty.layout().size(), loc.index) {
-                    ty.drop(ptr.as_ptr());
-                } else {
-                    info.push(ty);
-                }
-            }
-            info.sort();
-
-            // Find the archetype it'll live in
-            let elements = info.iter().map(|x| x.id()).collect::<Vec<_>>();
-            let target = match self.index.entry(elements) {
-                Entry::Occupied(x) => *x.get(),
-                Entry::Vacant(x) => {
-                    let index = self.archetypes.len() as u32;
-                    self.archetypes.push(Archetype::new(info));
-                    x.insert(index);
-                    self.archetype_generation += 1;
-                    index
-                }
-            };
-
-            if target == loc.archetype {
-                // Update components in the current archetype
-                let arch = &mut self.archetypes[loc.archetype as usize];
-                bundle.put(|ptr, ty, size| {
-                    arch.put_dynamic(ptr, ty, size, loc.index, ComponentFlags::MUTATED);
-                    true
-                });
-                return Ok(());
-            }
-
-            // Move into a new archetype
-            let (source_arch, target_arch) = index2(
-                &mut self.archetypes,
-                loc.archetype as usize,
-                target as usize,
-            );
-            let target_index = target_arch.allocate(entity);
-            loc.archetype = target;
-            let old_index = mem::replace(&mut loc.index, target_index);
-            if let Some(moved) = source_arch.move_to(old_index, |ptr, ty, size, flags| {
-                target_arch.put_dynamic(ptr, ty, size, target_index, ComponentFlags::empty());
-                let type_state = target_arch.get_type_state_mut(ty).unwrap();
-                *type_state.component_flags().as_ptr().add(target_index) = flags;
-            }) {
-                self.entities.get_mut(moved).unwrap().index = old_index;
-            }
-
-            bundle.put(|ptr, ty, size| {
-                let had_component = source_arch.has_dynamic(ty);
-                let flags = if had_component {
-                    ComponentFlags::MUTATED
-                } else {
-                    ComponentFlags::ADDED
-                };
-                target_arch.put_dynamic(ptr, ty, size, target_index, flags);
-                true
-            });
-        }
-        Ok(())
-    }
-
-    /// Add `component` to `entity`
-    ///
-    /// See `insert`.
-    pub fn insert_one(
-        &mut self,
-        entity: Entity,
-        component: impl Component,
-    ) -> Result<(), NoSuchEntity> {
-        self.insert(entity, (component,))
-    }
-
-    /// Remove components from `entity`
-    ///
-    /// Computational cost is proportional to the number of components `entity` has. The entity
-    /// itself is not removed, even if no components remain; use `despawn` for that. If any
-    /// component in `T` is not present in `entity`, no components are removed and an error is
-    /// returned.
-    ///
-    /// When removing a single component, see `remove_one` for convenience.
-    ///
-    /// # Example
-    /// ```
-    /// # use bevy_ecs::*;
-    /// let mut world = World::new();
-    /// let e = world.spawn((123, "abc", true));
-    /// assert_eq!(world.remove::<(i32, &str)>(e), Ok((123, "abc")));
-    /// assert!(world.get::<i32>(e).is_err());
-    /// assert!(world.get::<&str>(e).is_err());
-    /// assert_eq!(*world.get::<bool>(e).unwrap(), true);
-    /// ```
-    pub fn remove<T: Bundle>(&mut self, entity: Entity) -> Result<T, ComponentError> {
-        self.flush();
-        let loc = self.entities.get_mut(entity)?;
-        unsafe {
-            let to_remove = T::with_static_ids(|ids| ids.iter().copied().collect::<HashSet<_>>());
-
-            let old_index = loc.index;
-            let source_arch = &self.archetypes[loc.archetype as usize];
-            let bundle = T::get(|ty, size| source_arch.get_dynamic(ty, size, old_index))?;
-            match self.remove_bundle_internal(entity, to_remove) {
-                Ok(_) => Ok(bundle),
-                Err(err) => Err(err),
-            }
-        }
-    }
-
-    fn remove_bundle_internal<S: core::hash::BuildHasher>(
-        &mut self,
-        entity: Entity,
-        to_remove: std::collections::HashSet<TypeId, S>,
-    ) -> Result<(), ComponentError> {
-        use std::collections::hash_map::Entry;
-
-        let loc = self.entities.get_mut(entity)?;
-        let info = self.archetypes[loc.archetype as usize]
-            .types()
-            .iter()
-            .cloned()
-            .filter(|x| !to_remove.contains(&x.id()))
-            .collect::<Vec<_>>();
-        let elements = info.iter().map(|x| x.id()).collect::<Vec<_>>();
-        let target = match self.index.entry(elements) {
-            Entry::Occupied(x) => *x.get(),
-            Entry::Vacant(x) => {
-                self.archetypes.push(Archetype::new(info));
-                let index = (self.archetypes.len() - 1) as u32;
-                x.insert(index);
-                self.archetype_generation += 1;
-                index
-            }
-        };
-        let old_index = loc.index;
-        let (source_arch, target_arch) = index2(
-            &mut self.archetypes,
-            loc.archetype as usize,
-            target as usize,
-        );
-        let target_index = unsafe { target_arch.allocate(entity) };
-        loc.archetype = target;
-        loc.index = target_index;
-        let removed_components = &mut self.removed_components;
-        if let Some(moved) = unsafe {
-            source_arch.move_to(old_index, |src, ty, size, flags| {
-                // Only move the components present in the target archetype, i.e. the non-removed ones.
-                if let Some(dst) = target_arch.get_dynamic(ty, size, target_index) {
-                    ptr::copy_nonoverlapping(src, dst.as_ptr(), size);
-                    let state = target_arch.get_type_state_mut(ty).unwrap();
-                    *state.component_flags().as_ptr().add(target_index) = flags;
-                } else {
-                    let removed_entities = removed_components.entry(ty).or_insert_with(Vec::new);
-                    removed_entities.push(entity);
-                }
-            })
-        } {
-            self.entities.get_mut(moved).unwrap().index = old_index;
-        }
-        Ok(())
-    }
-
-    /// Remove components from `entity`
-    ///
-    /// Fallback method for `remove` when one of the component in `T` is not present in `entity`.
-    /// In this case, the missing component will be skipped.
-    ///
-    /// See `remove`.
-    pub fn remove_one_by_one<T: Bundle>(&mut self, entity: Entity) -> Result<(), ComponentError> {
-        self.flush();
-
-        let to_remove = T::with_static_ids(|ids| ids.iter().copied().collect::<HashSet<_>>());
-        for component_to_remove in to_remove.into_iter() {
-            let loc = self.entities.get(entity)?;
-            if loc.archetype == 0 {
-                return Err(ComponentError::NoSuchEntity);
-            }
-            if self.archetypes[loc.archetype as usize].has_dynamic(component_to_remove) {
-                let mut single_component_hashset = std::collections::HashSet::new();
-                single_component_hashset.insert(component_to_remove);
-                match self.remove_bundle_internal(entity, single_component_hashset) {
-                    Ok(_) | Err(ComponentError::MissingComponent(_)) => (),
-                    Err(err) => return Err(err),
-                };
-            }
-        }
-        Ok(())
-    }
-
-    /// Remove the `T` component from `entity`
-    ///
-    /// See `remove`.
-    pub fn remove_one<T: Component>(&mut self, entity: Entity) -> Result<T, ComponentError> {
-        self.remove::<(T,)>(entity).map(|(x,)| x)
-    }
-
-    /// Borrow the `T` component at the given location, without safety checks
-    ///
-    /// # Safety
-    /// This does not check that the location is within bounds of the archetype.
-    pub unsafe fn get_ref_at_location_unchecked<T: Component>(
-        &self,
-        location: Location,
-    ) -> Result<Ref<T>, ComponentError> {
-        if location.archetype == 0 {
-            return Err(MissingComponent::new::<T>().into());
-        }
-        Ok(Ref::new(
-            &self.archetypes[location.archetype as usize],
-            location.index,
-        )?)
-    }
-
-    /// Borrow the `T` component at the given location, without safety checks
-    ///
-    /// # Safety
-    /// This does not check that the location is within bounds of the archetype.
-    /// It also does not check for mutable access correctness. To be safe, make sure this is the only
-    /// thing accessing this entity's T component.
-    pub unsafe fn get_ref_mut_at_location_unchecked<T: Component>(
-        &self,
-        location: Location,
-    ) -> Result<RefMut<T>, ComponentError> {
-        if location.archetype == 0 {
-            return Err(MissingComponent::new::<T>().into());
-        }
-        Ok(RefMut::new(
-            &self.archetypes[location.archetype as usize],
-            location.index,
-        )?)
-    }
-
-    /// Borrow the `T` component at the given location, without safety checks
-    /// # Safety
-    /// This does not check that the location is within bounds of the archetype.
-    pub unsafe fn get_at_location_unchecked<T: Component>(
-        &self,
-        location: Location,
-    ) -> Result<&T, ComponentError> {
-        if location.archetype == 0 {
-            return Err(MissingComponent::new::<T>().into());
-        }
-        Ok(&*self.archetypes[location.archetype as usize]
-            .get::<T>()
-            .ok_or_else(MissingComponent::new::<T>)?
-            .as_ptr()
-            .add(location.index as usize))
-    }
-
-    /// Borrow the `T` component at the given location, without safety checks
-    /// # Safety
-    /// This does not check that the location is within bounds of the archetype.
-    /// It also does not check for mutable access correctness. To be safe, make sure this is the only
-    /// thing accessing this entity's T component.
-    pub unsafe fn get_mut_at_location_unchecked<T: Component>(
-        &self,
-        location: Location,
-    ) -> Result<Mut<T>, ComponentError> {
-        if location.archetype == 0 {
-            return Err(MissingComponent::new::<T>().into());
-        }
-        Ok(Mut::new(
-            &self.archetypes[location.archetype as usize],
-            location.index,
-        )?)
-    }
-
-    /// Uniquely borrow the `T` component of `entity` without safety checks
-    ///
-    /// Should only be used as a building block for safe abstractions.
-    ///
-    /// # Safety
-    ///
-    /// `entity` must have been previously obtained from this `World`, and no borrow of the same
-    /// component of `entity` may be live simultaneous to the returned reference.
-    pub unsafe fn get_unchecked_mut<T: Component>(
-        &self,
-        entity: Entity,
-    ) -> Result<&mut T, ComponentError> {
-        let loc = self.entities.get(entity)?;
-        if loc.archetype == 0 {
-            return Err(MissingComponent::new::<T>().into());
-        }
-        Ok(&mut *self.archetypes[loc.archetype as usize]
-            .get::<T>()
-            .ok_or_else(MissingComponent::new::<T>)?
-            .as_ptr()
-            .add(loc.index as usize))
-    }
-
-    /// Convert all reserved entities into empty entities that can be iterated and accessed
-    ///
-    /// Invoked implicitly by `spawn`, `despawn`, `insert`, and `remove`.
-    pub fn flush(&mut self) {
-        let arch = &mut self.archetypes[0];
-        for entity_id in self.entities.flush() {
-            self.entities.meta[entity_id as usize].location.index = unsafe {
-                arch.allocate(Entity {
-                    id: entity_id,
-                    generation: self.entities.meta[entity_id as usize].generation,
-                })
-            };
-        }
-        for i in 0..self.entities.reserved_len() {
-            let id = self.entities.reserved(i);
-            self.entities.meta[id as usize].location.index = unsafe {
-                arch.allocate(Entity {
-                    id,
-                    generation: self.entities.meta[id as usize].generation,
-                })
-            };
-        }
-        self.entities.clear_reserved();
-    }
-
-    /// Inspect the archetypes that entities are organized into
-    ///
-    /// Useful for dynamically scheduling concurrent queries by checking borrows in advance. Does
-    /// not provide access to entities.
-    pub fn archetypes(&self) -> impl ExactSizeIterator<Item = &'_ Archetype> + '_ {
-        self.archetypes.iter()
-    }
-
-    /// Returns a distinct value after `archetypes` is changed
-    ///
-    /// Store the current value after deriving information from `archetypes`, then check whether the
-    /// value returned by this function differs before attempting an operation that relies on its
-    /// correctness. Useful for determining whether e.g. a concurrent query execution plan is still
-    /// correct.
-    ///
-    /// The generation may be, but is not necessarily, changed as a result of adding or removing any
-    /// entity or component.
-    ///
-    /// # Example
-    /// ```
-    /// # use bevy_ecs::*;
-    /// let mut world = World::new();
-    /// let initial_gen = world.archetypes_generation();
-    /// world.spawn((123, "abc"));
-    /// assert_ne!(initial_gen, world.archetypes_generation());
-    /// ```
-    pub fn archetypes_generation(&self) -> ArchetypesGeneration {
-        ArchetypesGeneration(self.archetype_generation)
-    }
-
-    /// Retrieves the entity's current location, if it exists
-    pub fn get_entity_location(&self, entity: Entity) -> Option<Location> {
-        self.entities.get(entity).ok()
-    }
-
-    /// Clears each entity's tracker state. For example, each entity's component "mutated" state will be reset to `false`.
-    pub fn clear_trackers(&mut self) {
-        for archetype in self.archetypes.iter_mut() {
-            archetype.clear_trackers();
-        }
-
-        self.removed_components.clear();
-    }
-
-    /// Gets an entity reserver, which can be used to reserve entity ids in a multi-threaded context.
-    pub fn get_entity_reserver(&self) -> EntityReserver {
-        self.entities.get_reserver()
-    }
-}
-
-unsafe impl Send for World {}
-unsafe impl Sync for World {}
-
-impl Default for World {
-    fn default() -> Self {
-        Self::new()
-    }
-}
-
-impl<'a> IntoIterator for &'a mut World {
-    type IntoIter = Iter<'a>;
-    type Item = (Entity, EntityRef<'a>);
-
-    fn into_iter(self) -> Iter<'a> {
-        self.iter()
-    }
-}
-
-fn index2<T>(x: &mut [T], i: usize, j: usize) -> (&mut T, &mut T) {
-    assert!(i != j);
-    assert!(i < x.len());
-    assert!(j < x.len());
-    let ptr = x.as_mut_ptr();
-    unsafe { (&mut *ptr.add(i), &mut *ptr.add(j)) }
-}
-
-/// Errors that arise when accessing components
-#[derive(Debug, Clone, Eq, PartialEq, Hash)]
-pub enum ComponentError {
-    /// The entity was already despawned
-    NoSuchEntity,
-    /// The entity did not have a requested component
-    MissingComponent(MissingComponent),
-}
-
-#[cfg(feature = "std")]
-impl Error for ComponentError {}
-
-impl fmt::Display for ComponentError {
-    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
-        use ComponentError::*;
-        match *self {
-            NoSuchEntity => f.write_str("no such entity"),
-            MissingComponent(ref x) => x.fmt(f),
-        }
-    }
-}
-
-impl From<NoSuchEntity> for ComponentError {
-    fn from(NoSuchEntity: NoSuchEntity) -> Self {
-        ComponentError::NoSuchEntity
-    }
-}
-
-impl From<MissingComponent> for ComponentError {
-    fn from(x: MissingComponent) -> Self {
-        ComponentError::MissingComponent(x)
-    }
-}
-
-/// Types that can be components, implemented automatically for all `Send + Sync + 'static` types
-///
-/// This is just a convenient shorthand for `Send + Sync + 'static`, and never needs to be
-/// implemented manually.
-pub trait Component: Send + Sync + 'static {}
-impl<T: Send + Sync + 'static> Component for T {}
-
-/// Iterator over all of a world's entities
-pub struct Iter<'a> {
-    archetypes: core::slice::Iter<'a, Archetype>,
-    entities: &'a Entities,
-    current: Option<&'a Archetype>,
-    index: usize,
-}
-
-impl<'a> Iter<'a> {
-    fn new(archetypes: &'a [Archetype], entities: &'a Entities) -> Self {
-        Self {
-            archetypes: archetypes.iter(),
-            entities,
-            current: None,
-            index: 0,
-        }
-    }
-}
-
-unsafe impl Send for Iter<'_> {}
-unsafe impl Sync for Iter<'_> {}
-
-impl<'a> Iterator for Iter<'a> {
-    type Item = (Entity, EntityRef<'a>);
-
-    fn next(&mut self) -> Option<Self::Item> {
-        loop {
-            match self.current {
-                None => {
-                    self.current = Some(self.archetypes.next()?);
-                    self.index = 0;
-                }
-                Some(current) => {
-                    if self.index == current.len() {
-                        self.current = None;
-                        continue;
-                    }
-                    let index = self.index;
-                    self.index += 1;
-                    let id = current.get_entity(index);
-                    return Some((id, unsafe { EntityRef::new(current, index) }));
-                }
-            }
-        }
-    }
-
-    fn size_hint(&self) -> (usize, Option<usize>) {
-        (0, Some(self.entities.meta.len()))
-    }
-}
-
-impl<A: DynamicBundle> Extend<A> for World {
-    fn extend<T>(&mut self, iter: T)
-    where
-        T: IntoIterator<Item = A>,
-    {
-        for x in iter {
-            self.spawn(x);
-        }
-    }
-}
-
-impl<A: DynamicBundle> core::iter::FromIterator<A> for World {
-    fn from_iter<I: IntoIterator<Item = A>>(iter: I) -> Self {
-        let mut world = World::new();
-        world.extend(iter);
-        world
-    }
-}
-
-/// Determines freshness of information derived from `World::archetypes`
-#[derive(Debug, Copy, Clone, Eq, PartialEq)]
-pub struct ArchetypesGeneration(pub u64);
-
-/// Entity IDs created by `World::spawn_batch`
-pub struct SpawnBatchIter<'a, I>
-where
-    I: Iterator,
-    I::Item: Bundle,
-{
-    inner: I,
-    entities: &'a mut Entities,
-    archetype_id: u32,
-    archetype: &'a mut Archetype,
-}
-
-impl<I> Drop for SpawnBatchIter<'_, I>
-where
-    I: Iterator,
-    I::Item: Bundle,
-{
-    fn drop(&mut self) {
-        for _ in self {}
-    }
-}
-
-impl<I> Iterator for SpawnBatchIter<'_, I>
-where
-    I: Iterator,
-    I::Item: Bundle,
-{
-    type Item = Entity;
-
-    fn next(&mut self) -> Option<Entity> {
-        let components = self.inner.next()?;
-        let entity = self.entities.alloc();
-        unsafe {
-            let index = self.archetype.allocate(entity);
-            components.put(|ptr, ty, size| {
-                self.archetype
-                    .put_dynamic(ptr, ty, size, index, ComponentFlags::ADDED);
-                true
-            });
-            self.entities.meta[entity.id as usize].location = Location {
-                archetype: self.archetype_id,
-                index,
-            };
-        }
-        Some(entity)
-    }
-
-    fn size_hint(&self) -> (usize, Option<usize>) {
-        self.inner.size_hint()
-    }
-}
-
-impl<I, T> ExactSizeIterator for SpawnBatchIter<'_, I>
-where
-    I: ExactSizeIterator<Item = T>,
-    T: Bundle,
-{
-    fn len(&self) -> usize {
-        self.inner.len()
-    }
-}
diff --git a/crates/bevy_ecs/src/core/world_builder.rs b/crates/bevy_ecs/src/core/world_builder.rs
deleted file mode 100644
index 471826e4f2d78..0000000000000
--- a/crates/bevy_ecs/src/core/world_builder.rs
+++ /dev/null
@@ -1,78 +0,0 @@
-use crate::{Bundle, Component, DynamicBundle, Entity, World};
-
-/// Converts a reference to `Self` to a [WorldBuilder]
-pub trait WorldBuilderSource {
-    fn build(&mut self) -> WorldBuilder;
-}
-
-impl WorldBuilderSource for World {
-    fn build(&mut self) -> WorldBuilder {
-        WorldBuilder {
-            world: self,
-            current_entity: None,
-        }
-    }
-}
-
-/// Modify a [World] using the builder pattern
-#[derive(Debug)]
-pub struct WorldBuilder<'a> {
-    pub world: &'a mut World,
-    pub current_entity: Option<Entity>,
-}
-
-impl<'a> WorldBuilder<'a> {
-    pub fn entity(&mut self) -> &mut Self {
-        self.current_entity = Some(self.world.reserve_entity());
-        self
-    }
-
-    pub fn set_entity(&mut self, entity: Entity) -> &mut Self {
-        self.current_entity = Some(entity);
-        self
-    }
-
-    pub fn with<T>(&mut self, component: T) -> &mut Self
-    where
-        T: Component,
-    {
-        self.world
-            .insert_one(self.current_entity.expect("Cannot add component because the 'current entity' is not set. You should spawn an entity first."), component)
-            .unwrap();
-        self
-    }
-
-    pub fn with_bundle(&mut self, bundle: impl DynamicBundle) -> &mut Self {
-        self.world
-            .insert(self.current_entity.expect("Cannot add bundle because the 'current entity' is not set. You should spawn an entity first."), bundle)
-            .unwrap();
-        self
-    }
-
-    pub fn spawn_batch<I>(&mut self, bundle_iter: I) -> &mut Self
-    where
-        I: IntoIterator,
-        I::Item: Bundle,
-    {
-        self.world.spawn_batch(bundle_iter);
-        self
-    }
-
-    pub fn spawn(&mut self, bundle: impl DynamicBundle) -> &mut Self {
-        self.current_entity = Some(self.world.spawn(bundle));
-        self
-    }
-
-    #[inline]
-    pub fn current_entity(&self) -> Option<Entity> {
-        self.current_entity
-    }
-
-    pub fn for_current_entity(&mut self, f: impl FnOnce(Entity)) -> &mut Self {
-        let current_entity = self
-            .current_entity
-            .expect("The 'current entity' is not set. You should spawn an entity first.");
-        f(current_entity);
-        self
-    }
-}
diff --git a/crates/bevy_ecs/src/core/entity_map.rs b/crates/bevy_ecs/src/entity/map_entities.rs
similarity index 97%
rename from crates/bevy_ecs/src/core/entity_map.rs
rename to crates/bevy_ecs/src/entity/map_entities.rs
index cf8c45431e44e..b6cf162177859 100644
--- a/crates/bevy_ecs/src/core/entity_map.rs
+++ b/crates/bevy_ecs/src/entity/map_entities.rs
@@ -1,4 +1,4 @@
-use crate::Entity;
+use crate::entity::Entity;
 use bevy_utils::HashMap;
 use std::collections::hash_map::Entry;
 use thiserror::Error;
diff --git a/crates/bevy_ecs/src/entity/mod.rs b/crates/bevy_ecs/src/entity/mod.rs
new file mode 100644
index 0000000000000..85d67e024f0e8
--- /dev/null
+++ b/crates/bevy_ecs/src/entity/mod.rs
@@ -0,0 +1,489 @@
+mod map_entities;
+mod serde;
+
+pub use self::serde::*;
+pub use map_entities::*;
+
+use crate::{archetype::ArchetypeId, storage::SparseSetIndex};
+use std::{
+    convert::TryFrom,
+    fmt, mem,
+    sync::atomic::{AtomicI64, Ordering},
+};
+
+/// Lightweight unique ID of an entity
+///
+/// Obtained from `World::spawn`. Can be stored to refer to an entity in the future.
+#[derive(Clone, Copy, Hash, Eq, Ord, PartialEq, PartialOrd)]
+pub struct Entity {
+    pub(crate) generation: u32,
+    pub(crate) id: u32,
+}
+
+impl Entity {
+    /// Creates a new entity reference with a generation of 0
+    pub fn new(id: u32) -> Entity {
+        Entity { id, generation: 0 }
+    }
+
+    /// Convert to a form convenient for passing outside of rust
+    ///
+    /// Only useful for identifying entities within the same instance of an application. Do not use
+    /// for serialization between runs.
+    ///
+    /// No particular structure is guaranteed for the returned bits.
+    pub fn to_bits(self) -> u64 {
+        u64::from(self.generation) << 32 | u64::from(self.id)
+    }
+
+    /// Reconstruct an `Entity` previously destructured with `to_bits`
+    ///
+    /// Only useful when applied to results from `to_bits` in the same instance of an application.
+    pub fn from_bits(bits: u64) -> Self {
+        Self {
+            generation: (bits >> 32) as u32,
+            id: bits as u32,
+        }
+    }
+
+    /// Return a transiently unique identifier
+    ///
+    /// No two simultaneously-live entities share the same ID, but dead entities' IDs may collide
+    /// with both live and dead entities. Useful for compactly representing entities within a
+    /// specific snapshot of the world, such as when serializing.
+    #[inline]
+    pub fn id(self) -> u32 {
+        self.id
+    }
+
+    /// Returns the generation of this Entity's id. The generation is incremented each time an entity with
+    /// a given id is despawned. This serves as a "count" of the number of times a given id has been reused
+    /// (id, generation) pairs uniquely identify a given Entity.
+    #[inline]
+    pub fn generation(self) -> u32 {
+        self.generation
+    }
+}
+
+impl fmt::Debug for Entity {
+    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+        write!(f, "{}v{}", self.id, self.generation)
+    }
+}
+
+impl SparseSetIndex for Entity {
+    fn sparse_set_index(&self) -> usize {
+        self.id() as usize
+    }
+
+    fn get_sparse_set_index(value: usize) -> Self {
+        Entity::new(value as u32)
+    }
+}
+
+/// An iterator returning a sequence of Entity values from `Entities::reserve_entities`.
+pub struct ReserveEntitiesIterator<'a> {
+    // Metas, so we can recover the current generation for anything in the freelist.
+    meta: &'a [EntityMeta],
+
+    // Reserved IDs formerly in the freelist to hand out.
+    id_iter: std::slice::Iter<'a, u32>,
+
+    // New Entity IDs to hand out, outside the range of meta.len().
+    id_range: std::ops::Range<u32>,
+}
+
+impl<'a> Iterator for ReserveEntitiesIterator<'a> {
+    type Item = Entity;
+
+    fn next(&mut self) -> Option<Self::Item> {
+        self.id_iter
+            .next()
+            .map(|&id| Entity {
+                generation: self.meta[id as usize].generation,
+                id,
+            })
+            .or_else(|| self.id_range.next().map(|id| Entity { generation: 0, id }))
+    }
+
+    fn size_hint(&self) -> (usize, Option<usize>) {
+        let len = self.id_iter.len() + self.id_range.len();
+        (len, Some(len))
+    }
+}
+
+impl<'a> core::iter::ExactSizeIterator for ReserveEntitiesIterator<'a> {}
+
+#[derive(Debug, Default)]
+pub struct Entities {
+    pub meta: Vec<EntityMeta>,
+
+    /// The `pending` and `free_cursor` fields describe three sets of Entity IDs
+    /// that have been freed or are in the process of being allocated:
+    ///
+    /// - The `freelist` IDs, previously freed by `free()`. These IDs are available to any
+    ///   of `alloc()`, `reserve_entity()` or `reserve_entities()`. Allocation will
+    ///   always prefer these over brand new IDs.
+    ///
+    /// - The `reserved` list of IDs that were once in the freelist, but got
+    ///   reserved by `reserve_entities` or `reserve_entity()`. They are now waiting
+    ///   for `flush()` to make them fully allocated.
+    ///
+    /// - The count of new IDs that do not yet exist in `self.meta()`, but which
+    ///   we have handed out and reserved. `flush()` will allocate room for them in `self.meta()`.
+    ///
+    /// The contents of `pending` look like this:
+    ///
+    /// ```txt
+    /// ----------------------------
+    /// |  freelist  |  reserved   |
+    /// ----------------------------
+    ///              ^             ^
+    ///          free_cursor   pending.len()
+    /// ```
+    ///
+    /// As IDs are allocated, `free_cursor` is atomically decremented, moving
+    /// items from the freelist into the reserved list by sliding over the boundary.
+    ///
+    /// Once the freelist runs out, `free_cursor` starts going negative.
+    /// The more negative it is, the more IDs have been reserved starting exactly at
+    /// the end of `meta.len()`.
+    ///
+    /// This formulation allows us to reserve any number of IDs first from the freelist
+    /// and then from the new IDs, using only a single atomic subtract.
+    ///
+    /// Once `flush()` is done, `free_cursor` will equal `pending.len()`.
+    pending: Vec<u32>,
+    free_cursor: AtomicI64,
+    len: u32,
+}
+
+impl Entities {
+    /// Reserve entity IDs concurrently
+    ///
+    /// Storage for entity generation and location is lazily allocated by calling `flush`.
+    pub fn reserve_entities(&self, count: u32) -> ReserveEntitiesIterator {
+        // Use one atomic subtract to grab a range of new IDs. The range might be
+        // entirely nonnegative, meaning all IDs come from the freelist, or entirely
+        // negative, meaning they are all new IDs to allocate, or a mix of both.
+        let range_end = self.free_cursor.fetch_sub(count as i64, Ordering::Relaxed);
+        let range_start = range_end - count as i64;
+
+        let freelist_range = range_start.max(0) as usize..range_end.max(0) as usize;
+
+        let (new_id_start, new_id_end) = if range_start >= 0 {
+            // We satisfied all requests from the freelist.
+            (0, 0)
+        } else {
+            // We need to allocate some new Entity IDs outside of the range of self.meta.
+            //
+            // `range_start` covers some negative territory, e.g. `-3..6`.
+            // Since the nonnegative values `0..6` are handled by the freelist, that
+            // means we need to handle the negative range here.
+            //
+            // In this example, we truncate the end to 0, leaving us with `-3..0`.
+            // Then we negate these values to indicate how far beyond the end of `meta.end()`
+            // to go, yielding `meta.len()+0 .. meta.len()+3`.
+            let base = self.meta.len() as i64;
+
+            let new_id_end = u32::try_from(base - range_start).expect("too many entities");
+
+            // `new_id_end` is in range, so no need to check `start`.
+            let new_id_start = (base - range_end.min(0)) as u32;
+
+            (new_id_start, new_id_end)
+        };
+
+        ReserveEntitiesIterator {
+            meta: &self.meta[..],
+            id_iter: self.pending[freelist_range].iter(),
+            id_range: new_id_start..new_id_end,
+        }
+    }
+
+    /// Reserve one entity ID concurrently
+    ///
+    /// Equivalent to `self.reserve_entities(1).next().unwrap()`, but more efficient.
+    pub fn reserve_entity(&self) -> Entity {
+        let n = self.free_cursor.fetch_sub(1, Ordering::Relaxed);
+        if n > 0 {
+            // Allocate from the freelist.
+            let id = self.pending[(n - 1) as usize];
+            Entity {
+                generation: self.meta[id as usize].generation,
+                id,
+            }
+        } else {
+            // Grab a new ID, outside the range of `meta.len()`. `flush()` must
+            // eventually be called to make it valid.
+            //
+            // As `self.free_cursor` goes more and more negative, we return IDs farther
+            // and farther beyond `meta.len()`.
+            Entity {
+                generation: 0,
+                id: u32::try_from(self.meta.len() as i64 - n).expect("too many entities"),
+            }
+        }
+    }
+
+    /// Check that we do not have pending work requiring `flush()` to be called.
+    fn verify_flushed(&mut self) {
+        debug_assert!(
+            !self.needs_flush(),
+            "flush() needs to be called before this operation is legal"
+        );
+    }
+
+    /// Allocate an entity ID directly
+    ///
+    /// Location should be written immediately.
+    pub fn alloc(&mut self) -> Entity {
+        self.verify_flushed();
+
+        self.len += 1;
+        if let Some(id) = self.pending.pop() {
+            let new_free_cursor = self.pending.len() as i64;
+            *self.free_cursor.get_mut() = new_free_cursor;
+            Entity {
+                generation: self.meta[id as usize].generation,
+                id,
+            }
+        } else {
+            let id = u32::try_from(self.meta.len()).expect("too many entities");
+            self.meta.push(EntityMeta::EMPTY);
+            Entity { generation: 0, id }
+        }
+    }
+
+    /// Allocate a specific entity ID, overwriting its generation
+    ///
+    /// Returns the location of the entity currently using the given ID, if any. Location should be written immediately.
+    pub fn alloc_at(&mut self, entity: Entity) -> Option<EntityLocation> {
+        self.verify_flushed();
+
+        let loc = if entity.id as usize >= self.meta.len() {
+            self.pending.extend((self.meta.len() as u32)..entity.id);
+            let new_free_cursor = self.pending.len() as i64;
+            *self.free_cursor.get_mut() = new_free_cursor;
+            self.meta.resize(entity.id as usize + 1, EntityMeta::EMPTY);
+            self.len += 1;
+            None
+        } else if let Some(index) = self.pending.iter().position(|item| *item == entity.id) {
+            self.pending.swap_remove(index);
+            let new_free_cursor = self.pending.len() as i64;
+            *self.free_cursor.get_mut() = new_free_cursor;
+            self.len += 1;
+            None
+        } else {
+            Some(mem::replace(
+                &mut self.meta[entity.id as usize].location,
+                EntityMeta::EMPTY.location,
+            ))
+        };
+
+        self.meta[entity.id as usize].generation = entity.generation;
+
+        loc
+    }
+
+    /// Destroy an entity, allowing it to be reused
+    ///
+    /// Must not be called while reserved entities are awaiting `flush()`.
+    pub fn free(&mut self, entity: Entity) -> Option<EntityLocation> {
+        self.verify_flushed();
+
+        let meta = &mut self.meta[entity.id as usize];
+        if meta.generation != entity.generation {
+            return None;
+        }
+        meta.generation += 1;
+
+        let loc = mem::replace(&mut meta.location, EntityMeta::EMPTY.location);
+
+        self.pending.push(entity.id);
+
+        let new_free_cursor = self.pending.len() as i64;
+        *self.free_cursor.get_mut() = new_free_cursor;
+        self.len -= 1;
+        Some(loc)
+    }
+
+    /// Ensure at least `n` allocations can succeed without reallocating
+    pub fn reserve(&mut self, additional: u32) {
+        self.verify_flushed();
+
+        let freelist_size = *self.free_cursor.get_mut();
+        let shortfall = additional as i64 - freelist_size;
+        if shortfall > 0 {
+            self.meta.reserve(shortfall as usize);
+        }
+    }
+
+    pub fn contains(&self, entity: Entity) -> bool {
+        // Note that out-of-range IDs are considered to be "contained" because
+        // they must be reserved IDs that we haven't flushed yet.
+        self.meta
+            .get(entity.id as usize)
+            .map_or(true, |meta| meta.generation == entity.generation)
+    }
+
+    pub fn clear(&mut self) {
+        self.meta.clear();
+        self.pending.clear();
+        *self.free_cursor.get_mut() = 0;
+    }
+
+    /// Access the location storage of an entity
+    ///
+    /// Must not be called on pending entities.
+    pub fn get_mut(&mut self, entity: Entity) -> Option<&mut EntityLocation> {
+        let meta = &mut self.meta[entity.id as usize];
+        if meta.generation == entity.generation {
+            Some(&mut meta.location)
+        } else {
+            None
+        }
+    }
+
+    /// Returns `Ok(Location { archetype: 0, index: undefined })` for pending entities
+    pub fn get(&self, entity: Entity) -> Option<EntityLocation> {
+        if (entity.id as usize) < self.meta.len() {
+            let meta = &self.meta[entity.id as usize];
+            if meta.generation != entity.generation {
+                return None;
+            }
+            Some(meta.location)
+        } else {
+            None
+        }
+    }
+
+    /// Panics if the given id would represent an index outside of `meta`.
+    ///
+    /// # Safety
+    /// Must only be called for currently allocated `id`s.
+    pub unsafe fn resolve_unknown_gen(&self, id: u32) -> Entity {
+        let meta_len = self.meta.len();
+
+        if meta_len > id as usize {
+            let meta = &self.meta[id as usize];
+            Entity {
+                generation: meta.generation,
+                id,
+            }
+        } else {
+            // See if it's pending, but not yet flushed.
+            let free_cursor = self.free_cursor.load(Ordering::Relaxed);
+            let num_pending = std::cmp::max(-free_cursor, 0) as usize;
+
+            if meta_len + num_pending > id as usize {
+                // Pending entities will have generation 0.
+                Entity { generation: 0, id }
+            } else {
+                panic!("entity id is out of range");
+            }
+        }
+    }
+
+    fn needs_flush(&mut self) -> bool {
+        *self.free_cursor.get_mut() != self.pending.len() as i64
+    }
+
+    /// Allocates space for entities previously reserved with `reserve_entity` or
+    /// `reserve_entities`, then initializes each one using the supplied function.
+    pub fn flush(&mut self, mut init: impl FnMut(Entity, &mut EntityLocation)) {
+        let free_cursor = self.free_cursor.get_mut();
+        let current_free_cursor = *free_cursor;
+
+        let new_free_cursor = if current_free_cursor >= 0 {
+            current_free_cursor as usize
+        } else {
+            let old_meta_len = self.meta.len();
+            let new_meta_len = old_meta_len + -current_free_cursor as usize;
+            self.meta.resize(new_meta_len, EntityMeta::EMPTY);
+            self.len += -current_free_cursor as u32;
+            for (id, meta) in self.meta.iter_mut().enumerate().skip(old_meta_len) {
+                init(
+                    Entity {
+                        id: id as u32,
+                        generation: meta.generation,
+                    },
+                    &mut meta.location,
+                );
+            }
+
+            *free_cursor = 0;
+            0
+        };
+
+        self.len += (self.pending.len() - new_free_cursor) as u32;
+        for id in self.pending.drain(new_free_cursor..) {
+            let meta = &mut self.meta[id as usize];
+            init(
+                Entity {
+                    id,
+                    generation: meta.generation,
+                },
+                &mut meta.location,
+            );
+        }
+    }
+
+    #[inline]
+    pub fn len(&self) -> u32 {
+        self.len
+    }
+
+    #[inline]
+    pub fn is_empty(&self) -> bool {
+        self.len == 0
+    }
+}
+
+#[derive(Copy, Clone, Debug)]
+pub struct EntityMeta {
+    pub generation: u32,
+    pub location: EntityLocation,
+}
+
+impl EntityMeta {
+    const EMPTY: EntityMeta = EntityMeta {
+        generation: 0,
+        location: EntityLocation {
+            archetype_id: ArchetypeId::empty(),
+            index: usize::max_value(), // dummy value, to be filled in
+        },
+    };
+}
+
+/// A location of an entity in an archetype
+#[derive(Copy, Clone, Debug)]
+pub struct EntityLocation {
+    /// The archetype index
+    pub archetype_id: ArchetypeId,
+
+    /// The index of the entity in the archetype
+    pub index: usize,
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    #[test]
+    fn entity_bits_roundtrip() {
+        let e = Entity {
+            generation: 0xDEADBEEF,
+            id: 0xBAADF00D,
+        };
+        assert_eq!(Entity::from_bits(e.to_bits()), e);
+    }
+
+    #[test]
+    fn reserve_entity_len() {
+        let mut e = Entities::default();
+        e.reserve_entity();
+        e.flush(|_, _| {});
+        assert_eq!(e.len(), 1);
+    }
+}
diff --git a/crates/bevy_ecs/src/core/serde.rs b/crates/bevy_ecs/src/entity/serde.rs
similarity index 94%
rename from crates/bevy_ecs/src/core/serde.rs
rename to crates/bevy_ecs/src/entity/serde.rs
index f7cc2e4ed291e..5c589bda4d200 100644
--- a/crates/bevy_ecs/src/core/serde.rs
+++ b/crates/bevy_ecs/src/entity/serde.rs
@@ -1,6 +1,4 @@
-// modified by Bevy contributors
-
-use crate::Entity;
+use crate::entity::Entity;
 use serde::{de::Visitor, Deserialize, Serialize, Serializer};
 
 impl Serialize for Entity {
diff --git a/crates/bevy_ecs/src/lib.rs b/crates/bevy_ecs/src/lib.rs
index d999401fa719f..e6d0bdb2a0efa 100644
--- a/crates/bevy_ecs/src/lib.rs
+++ b/crates/bevy_ecs/src/lib.rs
@@ -1,27 +1,1162 @@
-mod core;
-mod resource;
-mod schedule;
-mod system;
-
-pub use crate::core::*;
-pub use bevy_ecs_macros::*;
-pub use lazy_static;
-pub use resource::*;
-pub use schedule::*;
-pub use system::{Query, *};
+pub mod archetype;
+pub mod bundle;
+pub mod component;
+pub mod entity;
+pub mod query;
+#[cfg(feature = "bevy_reflect")]
+pub mod reflect;
+pub mod schedule;
+pub mod storage;
+pub mod system;
+pub mod world;
 
 pub mod prelude {
+    #[cfg(feature = "bevy_reflect")]
+    pub use crate::reflect::ReflectComponent;
     pub use crate::{
-        core::WorldBuilderSource,
-        resource::{FromResources, Local, NonSend, Res, ResMut, Resource, Resources},
+        bundle::Bundle,
+        entity::Entity,
+        query::{Added, Changed, Flags, Mutated, QueryState, With, WithBundle, Without},
         schedule::{
-            ExclusiveSystemDescriptorCoercion, ParallelSystemDescriptorCoercion,
-            ReportExecutionOrderAmbiguities, RunOnce, Schedule, Stage, State, StateStage,
-            SystemSet, SystemStage,
+            AmbiguitySetLabel, ExclusiveSystemDescriptorCoercion, ParallelSystemDescriptorCoercion,
+            Schedule, Stage, StageLabel, State, StateStage, SystemLabel, SystemStage,
         },
-        system::{Commands, ExclusiveSystem, IntoExclusiveSystem, IntoSystem, Query, System},
-        Added, AmbiguitySetLabel, Bundle, Changed, Component, Entity, Flags, In, IntoChainSystem,
-        Mut, Mutated, Or, QuerySet, Ref, RefMut, ShouldRun, StageLabel, SystemLabel, With, Without,
-        World,
+        system::{
+            Commands, In, IntoChainSystem, IntoExclusiveSystem, IntoSystem, Local, NonSend,
+            NonSendMut, Query, QuerySet, RemovedComponents, Res, ResMut, System,
+        },
+        world::{FromWorld, Mut, World},
     };
 }
+
+#[cfg(test)]
+mod tests {
+    use crate::{
+        bundle::Bundle,
+        component::{Component, ComponentDescriptor, StorageType, TypeInfo},
+        entity::Entity,
+        query::{Added, Changed, FilterFetch, Flags, Mutated, Or, With, Without, WorldQuery},
+        world::{Mut, World},
+    };
+    use bevy_tasks::TaskPool;
+    use parking_lot::Mutex;
+    use std::{any::TypeId, sync::Arc};
+
+    #[derive(Debug, PartialEq, Eq)]
+    struct A(usize);
+    struct B(usize);
+    struct C;
+
+    #[test]
+    fn random_access() {
+        let mut world = World::new();
+        world
+            .register_component(ComponentDescriptor::new::<i32>(StorageType::SparseSet))
+            .unwrap();
+        let e = world.spawn().insert_bundle(("abc", 123)).id();
+        let f = world.spawn().insert_bundle(("def", 456, true)).id();
+        assert_eq!(*world.get::<&str>(e).unwrap(), "abc");
+        assert_eq!(*world.get::<i32>(e).unwrap(), 123);
+        assert_eq!(*world.get::<&str>(f).unwrap(), "def");
+        assert_eq!(*world.get::<i32>(f).unwrap(), 456);
+
+        // test archetype get_mut()
+        *world.get_mut::<&'static str>(e).unwrap() = "xyz";
+        assert_eq!(*world.get::<&'static str>(e).unwrap(), "xyz");
+
+        // test sparse set get_mut()
+        *world.get_mut::<i32>(f).unwrap() = 42;
+        assert_eq!(*world.get::<i32>(f).unwrap(), 42);
+    }
+
+    #[test]
+    fn bundle_derive() {
+        use crate as bevy_ecs;
+        #[derive(Bundle, PartialEq, Debug)]
+        struct Foo {
+            x: &'static str,
+            y: i32,
+        }
+
+        assert_eq!(
+            <Foo as Bundle>::type_info(),
+            vec![TypeInfo::of::<&'static str>(), TypeInfo::of::<i32>(),]
+        );
+
+        let mut world = World::new();
+        world
+            .register_component(ComponentDescriptor::new::<i32>(StorageType::SparseSet))
+            .unwrap();
+        let e1 = world.spawn().insert_bundle(Foo { x: "abc", y: 123 }).id();
+        let e2 = world.spawn().insert_bundle(("def", 456, true)).id();
+        assert_eq!(*world.get::<&str>(e1).unwrap(), "abc");
+        assert_eq!(*world.get::<i32>(e1).unwrap(), 123);
+        assert_eq!(*world.get::<&str>(e2).unwrap(), "def");
+        assert_eq!(*world.get::<i32>(e2).unwrap(), 456);
+
+        // test archetype get_mut()
+        *world.get_mut::<&'static str>(e1).unwrap() = "xyz";
+        assert_eq!(*world.get::<&'static str>(e1).unwrap(), "xyz");
+
+        // test sparse set get_mut()
+        *world.get_mut::<i32>(e2).unwrap() = 42;
+        assert_eq!(*world.get::<i32>(e2).unwrap(), 42);
+
+        assert_eq!(
+            world.entity_mut(e1).remove_bundle::<Foo>().unwrap(),
+            Foo { x: "xyz", y: 123 }
+        );
+
+        #[derive(Bundle, PartialEq, Debug)]
+        struct Nested {
+            a: usize,
+            #[bundle]
+            foo: Foo,
+            b: u8,
+        }
+
+        assert_eq!(
+            <Nested as Bundle>::type_info(),
+            vec![
+                TypeInfo::of::<usize>(),
+                TypeInfo::of::<&'static str>(),
+                TypeInfo::of::<i32>(),
+                TypeInfo::of::<u8>(),
+            ]
+        );
+
+        let e3 = world
+            .spawn()
+            .insert_bundle(Nested {
+                a: 1,
+                foo: Foo { x: "ghi", y: 789 },
+                b: 2,
+            })
+            .id();
+
+        assert_eq!(*world.get::<&str>(e3).unwrap(), "ghi");
+        assert_eq!(*world.get::<i32>(e3).unwrap(), 789);
+        assert_eq!(*world.get::<usize>(e3).unwrap(), 1);
+        assert_eq!(*world.get::<u8>(e3).unwrap(), 2);
+        assert_eq!(
+            world.entity_mut(e3).remove_bundle::<Nested>().unwrap(),
+            Nested {
+                a: 1,
+                foo: Foo { x: "ghi", y: 789 },
+                b: 2,
+            }
+        );
+    }
+
+    #[test]
+    fn despawn_table_storage() {
+        let mut world = World::new();
+        let e = world.spawn().insert_bundle(("abc", 123)).id();
+        let f = world.spawn().insert_bundle(("def", 456)).id();
+        assert_eq!(world.entities.len(), 2);
+        assert!(world.despawn(e));
+        assert_eq!(world.entities.len(), 1);
+        assert!(world.get::<&str>(e).is_none());
+        assert!(world.get::<i32>(e).is_none());
+        assert_eq!(*world.get::<&str>(f).unwrap(), "def");
+        assert_eq!(*world.get::<i32>(f).unwrap(), 456);
+    }
+
+    #[test]
+    fn despawn_mixed_storage() {
+        let mut world = World::new();
+        world
+            .register_component(ComponentDescriptor::new::<i32>(StorageType::SparseSet))
+            .unwrap();
+        let e = world.spawn().insert_bundle(("abc", 123)).id();
+        let f = world.spawn().insert_bundle(("def", 456)).id();
+        assert_eq!(world.entities.len(), 2);
+        assert!(world.despawn(e));
+        assert_eq!(world.entities.len(), 1);
+        assert!(world.get::<&str>(e).is_none());
+        assert!(world.get::<i32>(e).is_none());
+        assert_eq!(*world.get::<&str>(f).unwrap(), "def");
+        assert_eq!(*world.get::<i32>(f).unwrap(), 456);
+    }
+
+    #[test]
+    fn query_all() {
+        let mut world = World::new();
+        let e = world.spawn().insert_bundle(("abc", 123)).id();
+        let f = world.spawn().insert_bundle(("def", 456)).id();
+
+        let ents = world
+            .query::<(Entity, &i32, &&str)>()
+            .iter(&world)
+            .map(|(e, &i, &s)| (e, i, s))
+            .collect::<Vec<_>>();
+        assert_eq!(ents, &[(e, 123, "abc"), (f, 456, "def")]);
+    }
+
+    #[test]
+    fn query_all_for_each() {
+        let mut world = World::new();
+        let e = world.spawn().insert_bundle(("abc", 123)).id();
+        let f = world.spawn().insert_bundle(("def", 456)).id();
+
+        let mut results = Vec::new();
+        world
+            .query::<(Entity, &i32, &&str)>()
+            .for_each(&world, |(e, &i, &s)| results.push((e, i, s)));
+        assert_eq!(results, &[(e, 123, "abc"), (f, 456, "def")]);
+    }
+
+    #[test]
+    fn query_single_component() {
+        let mut world = World::new();
+        let e = world.spawn().insert_bundle(("abc", 123)).id();
+        let f = world.spawn().insert_bundle(("def", 456, true)).id();
+        let ents = world
+            .query::<(Entity, &i32)>()
+            .iter(&world)
+            .map(|(e, &i)| (e, i))
+            .collect::<Vec<_>>();
+        assert_eq!(ents, &[(e, 123), (f, 456)]);
+    }
+
+    #[test]
+    fn stateful_query_handles_new_archetype() {
+        let mut world = World::new();
+        let e = world.spawn().insert_bundle(("abc", 123)).id();
+        let mut query = world.query::<(Entity, &i32)>();
+
+        let ents = query.iter(&world).map(|(e, &i)| (e, i)).collect::<Vec<_>>();
+        assert_eq!(ents, &[(e, 123)]);
+
+        let f = world.spawn().insert_bundle(("def", 456, true)).id();
+        let ents = query.iter(&world).map(|(e, &i)| (e, i)).collect::<Vec<_>>();
+        assert_eq!(ents, &[(e, 123), (f, 456)]);
+    }
+
+    #[test]
+    fn query_single_component_for_each() {
+        let mut world = World::new();
+        let e = world.spawn().insert_bundle(("abc", 123)).id();
+        let f = world.spawn().insert_bundle(("def", 456, true)).id();
+        let mut results = Vec::new();
+        world
+            .query::<(Entity, &i32)>()
+            .for_each(&world, |(e, &i)| results.push((e, i)));
+        assert_eq!(results, &[(e, 123), (f, 456)]);
+    }
+
+    #[test]
+    fn par_for_each() {
+        let mut world = World::new();
+        let task_pool = TaskPool::default();
+        let e1 = world.spawn().insert(1).id();
+        let e2 = world.spawn().insert(2).id();
+        let e3 = world.spawn().insert(3).id();
+        let e4 = world.spawn().insert_bundle((4, true)).id();
+        let e5 = world.spawn().insert_bundle((5, true)).id();
+        let results = Arc::new(Mutex::new(Vec::new()));
+        world
+            .query::<(Entity, &i32)>()
+            .par_for_each(&world, &task_pool, 2, |(e, &i)| results.lock().push((e, i)));
+        results.lock().sort();
+        assert_eq!(
+            &*results.lock(),
+            &[(e1, 1), (e2, 2), (e3, 3), (e4, 4), (e5, 5)]
+        );
+    }
+
+    #[test]
+    fn query_missing_component() {
+        let mut world = World::new();
+        world.spawn().insert_bundle(("abc", 123));
+        world.spawn().insert_bundle(("def", 456));
+        assert!(world.query::<(&bool, &i32)>().iter(&world).next().is_none());
+    }
+
+    #[test]
+    fn query_sparse_component() {
+        let mut world = World::new();
+        world.spawn().insert_bundle(("abc", 123));
+        let f = world.spawn().insert_bundle(("def", 456, true)).id();
+        let ents = world
+            .query::<(Entity, &bool)>()
+            .iter(&world)
+            .map(|(e, &b)| (e, b))
+            .collect::<Vec<_>>();
+        assert_eq!(ents, &[(f, true)]);
+    }
+
+    #[test]
+    fn query_filter_with() {
+        let mut world = World::new();
+        world.spawn().insert_bundle((123u32, 1.0f32));
+        world.spawn().insert(456u32);
+        let result = world
+            .query_filtered::<&u32, With<f32>>()
+            .iter(&world)
+            .cloned()
+            .collect::<Vec<_>>();
+        assert_eq!(result, vec![123]);
+    }
+
+    #[test]
+    fn query_filter_with_for_each() {
+        let mut world = World::new();
+        world.spawn().insert_bundle((123u32, 1.0f32));
+        world.spawn().insert(456u32);
+
+        let mut results = Vec::new();
+        world
+            .query_filtered::<&u32, With<f32>>()
+            .for_each(&world, |i| results.push(*i));
+        assert_eq!(results, vec![123]);
+    }
+
+    #[test]
+    fn query_filter_with_sparse() {
+        let mut world = World::new();
+        world
+            .register_component(ComponentDescriptor::new::<f32>(StorageType::SparseSet))
+            .unwrap();
+        world.spawn().insert_bundle((123u32, 1.0f32));
+        world.spawn().insert(456u32);
+        let result = world
+            .query_filtered::<&u32, With<f32>>()
+            .iter(&world)
+            .cloned()
+            .collect::<Vec<_>>();
+        assert_eq!(result, vec![123]);
+    }
+
+    #[test]
+    fn query_filter_with_sparse_for_each() {
+        let mut world = World::new();
+        world
+            .register_component(ComponentDescriptor::new::<f32>(StorageType::SparseSet))
+            .unwrap();
+        world.spawn().insert_bundle((123u32, 1.0f32));
+        world.spawn().insert(456u32);
+        let mut results = Vec::new();
+        world
+            .query_filtered::<&u32, With<f32>>()
+            .for_each(&world, |i| results.push(*i));
+        assert_eq!(results, vec![123]);
+    }
+
+    #[test]
+    fn query_filter_without() {
+        let mut world = World::new();
+        world.spawn().insert_bundle((123u32, 1.0f32));
+        world.spawn().insert(456u32);
+        let result = world
+            .query_filtered::<&u32, Without<f32>>()
+            .iter(&world)
+            .cloned()
+            .collect::<Vec<_>>();
+        assert_eq!(result, vec![456]);
+    }
+
+    #[test]
+    fn query_optional_component_table() {
+        let mut world = World::new();
+        let e = world.spawn().insert_bundle(("abc", 123)).id();
+        let f = world.spawn().insert_bundle(("def", 456, true)).id();
+        // this should be skipped
+        world.spawn().insert("abc");
+        let ents = world
+            .query::<(Entity, Option<&bool>, &i32)>()
+            .iter(&world)
+            .map(|(e, b, &i)| (e, b.copied(), i))
+            .collect::<Vec<_>>();
+        assert_eq!(ents, &[(e, None, 123), (f, Some(true), 456)]);
+    }
+
+    #[test]
+    fn query_optional_component_sparse() {
+        let mut world = World::new();
+        world
+            .register_component(ComponentDescriptor::new::<bool>(StorageType::SparseSet))
+            .unwrap();
+        let e = world.spawn().insert_bundle(("abc", 123)).id();
+        let f = world.spawn().insert_bundle(("def", 456, true)).id();
+        // // this should be skipped
+        // world.spawn().insert("abc");
+        let ents = world
+            .query::<(Entity, Option<&bool>, &i32)>()
+            .iter(&world)
+            .map(|(e, b, &i)| (e, b.copied(), i))
+            .collect::<Vec<_>>();
+        assert_eq!(ents, &[(e, None, 123), (f, Some(true), 456)]);
+    }
+
+    #[test]
+    fn query_optional_component_sparse_no_match() {
+        let mut world = World::new();
+        world
+            .register_component(ComponentDescriptor::new::<bool>(StorageType::SparseSet))
+            .unwrap();
+        let e = world.spawn().insert_bundle(("abc", 123)).id();
+        let f = world.spawn().insert_bundle(("def", 456)).id();
+        // // this should be skipped
+        world.spawn().insert("abc");
+        let ents = world
+            .query::<(Entity, Option<&bool>, &i32)>()
+            .iter(&world)
+            .map(|(e, b, &i)| (e, b.copied(), i))
+            .collect::<Vec<_>>();
+        assert_eq!(ents, &[(e, None, 123), (f, None, 456)]);
+    }
+
+    #[test]
+    fn add_remove_components() {
+        let mut world = World::new();
+        let e1 = world.spawn().insert(42).insert_bundle((true, "abc")).id();
+        let e2 = world.spawn().insert(0).insert_bundle((false, "xyz")).id();
+
+        assert_eq!(
+            world
+                .query::<(Entity, &i32, &bool)>()
+                .iter(&world)
+                .map(|(e, &i, &b)| (e, i, b))
+                .collect::<Vec<_>>(),
+            &[(e1, 42, true), (e2, 0, false)]
+        );
+
+        assert_eq!(world.entity_mut(e1).remove::<i32>(), Some(42));
+        assert_eq!(
+            world
+                .query::<(Entity, &i32, &bool)>()
+                .iter(&world)
+                .map(|(e, &i, &b)| (e, i, b))
+                .collect::<Vec<_>>(),
+            &[(e2, 0, false)]
+        );
+        assert_eq!(
+            world
+                .query::<(Entity, &bool, &&str)>()
+                .iter(&world)
+                .map(|(e, &b, &s)| (e, b, s))
+                .collect::<Vec<_>>(),
+            &[(e2, false, "xyz"), (e1, true, "abc")]
+        );
+        world.entity_mut(e1).insert(43);
+        assert_eq!(
+            world
+                .query::<(Entity, &i32, &bool)>()
+                .iter(&world)
+                .map(|(e, &i, &b)| (e, i, b))
+                .collect::<Vec<_>>(),
+            &[(e2, 0, false), (e1, 43, true)]
+        );
+        world.entity_mut(e1).insert(1.0f32);
+        assert_eq!(
+            world
+                .query::<(Entity, &f32)>()
+                .iter(&world)
+                .map(|(e, &f)| (e, f))
+                .collect::<Vec<_>>(),
+            &[(e1, 1.0)]
+        );
+    }
+
+    #[test]
+    fn table_add_remove_many() {
+        let mut world = World::default();
+        let mut entities = Vec::with_capacity(10_000);
+        for _ in 0..1000 {
+            entities.push(world.spawn().insert(0.0f32).id());
+        }
+
+        for (i, entity) in entities.iter().cloned().enumerate() {
+            world.entity_mut(entity).insert(i);
+        }
+
+        for (i, entity) in entities.iter().cloned().enumerate() {
+            assert_eq!(world.entity_mut(entity).remove::<usize>(), Some(i));
+        }
+    }
+
+    #[test]
+    fn sparse_set_add_remove_many() {
+        let mut world = World::default();
+        world
+            .register_component(ComponentDescriptor::new::<usize>(StorageType::SparseSet))
+            .unwrap();
+        let mut entities = Vec::with_capacity(1000);
+        for _ in 0..4 {
+            entities.push(world.spawn().insert(0.0f32).id());
+        }
+
+        for (i, entity) in entities.iter().cloned().enumerate() {
+            world.entity_mut(entity).insert(i);
+        }
+
+        for (i, entity) in entities.iter().cloned().enumerate() {
+            assert_eq!(world.entity_mut(entity).remove::<usize>(), Some(i));
+        }
+    }
+
+    #[test]
+    fn remove_missing() {
+        let mut world = World::new();
+        let e = world.spawn().insert_bundle(("abc", 123)).id();
+        assert!(world.entity_mut(e).remove::<bool>().is_none());
+    }
+
+    #[test]
+    fn spawn_batch() {
+        let mut world = World::new();
+        world.spawn_batch((0..100).map(|x| (x, "abc")));
+        let values = world
+            .query::<&i32>()
+            .iter(&world)
+            .copied()
+            .collect::<Vec<_>>();
+        let expected = (0..100).collect::<Vec<_>>();
+        assert_eq!(values, expected);
+    }
+
+    #[test]
+    fn query_get() {
+        let mut world = World::new();
+        let a = world.spawn().insert_bundle(("abc", 123)).id();
+        let b = world.spawn().insert_bundle(("def", 456)).id();
+        let c = world.spawn().insert_bundle(("ghi", 789, true)).id();
+
+        let mut i32_query = world.query::<&i32>();
+        assert_eq!(i32_query.get(&world, a).unwrap(), &123);
+        assert_eq!(i32_query.get(&world, b).unwrap(), &456);
+
+        let mut i32_bool_query = world.query::<(&i32, &bool)>();
+        assert!(i32_bool_query.get(&world, a).is_err());
+        assert_eq!(i32_bool_query.get(&world, c).unwrap(), (&789, &true));
+        assert!(world.despawn(a));
+        assert!(i32_query.get(&world, a).is_err());
+    }
+
+    #[test]
+    fn remove_tracking() {
+        let mut world = World::new();
+        world
+            .register_component(ComponentDescriptor::new::<&'static str>(
+                StorageType::SparseSet,
+            ))
+            .unwrap();
+        let a = world.spawn().insert_bundle(("abc", 123)).id();
+        let b = world.spawn().insert_bundle(("abc", 123)).id();
+
+        world.entity_mut(a).despawn();
+        assert_eq!(
+            world.removed::<i32>().collect::<Vec<_>>(),
+            &[a],
+            "despawning results in 'removed component' state for table components"
+        );
+        assert_eq!(
+            world.removed::<&'static str>().collect::<Vec<_>>(),
+            &[a],
+            "despawning results in 'removed component' state for sparse set components"
+        );
+
+        world.entity_mut(b).insert(10.0);
+        assert_eq!(
+            world.removed::<i32>().collect::<Vec<_>>(),
+            &[a],
+            "archetype moves does not result in 'removed component' state"
+        );
+
+        world.entity_mut(b).remove::<i32>();
+        assert_eq!(
+            world.removed::<i32>().collect::<Vec<_>>(),
+            &[a, b],
+            "removing a component results in a 'removed component' state"
+        );
+
+        world.clear_trackers();
+        assert_eq!(
+            world.removed::<i32>().collect::<Vec<_>>(),
+            &[],
+            "clearning trackers clears removals"
+        );
+        assert_eq!(
+            world.removed::<&'static str>().collect::<Vec<_>>(),
+            &[],
+            "clearning trackers clears removals"
+        );
+        assert_eq!(
+            world.removed::<f64>().collect::<Vec<_>>(),
+            &[],
+            "clearning trackers clears removals"
+        );
+
+        // TODO: uncomment when world.clear() is implemented
+        // let c = world.spawn().insert_bundle(("abc", 123)).id();
+        // let d = world.spawn().insert_bundle(("abc", 123)).id();
+        // world.clear();
+        // assert_eq!(
+        //     world.removed::<i32>(),
+        //     &[c, d],
+        //     "world clears result in 'removed component' states"
+        // );
+        // assert_eq!(
+        //     world.removed::<&'static str>(),
+        //     &[c, d, b],
+        //     "world clears result in 'removed component' states"
+        // );
+        // assert_eq!(
+        //     world.removed::<f64>(),
+        //     &[b],
+        //     "world clears result in 'removed component' states"
+        // );
+    }
+
+    #[test]
+    fn added_tracking() {
+        let mut world = World::new();
+        let a = world.spawn().insert(123i32).id();
+
+        assert_eq!(world.query::<&i32>().iter(&world).count(), 1);
+        assert_eq!(
+            world
+                .query_filtered::<(), Added<i32>>()
+                .iter(&world)
+                .count(),
+            1
+        );
+        assert_eq!(world.query::<&i32>().iter(&world).count(), 1);
+        assert_eq!(
+            world
+                .query_filtered::<(), Added<i32>>()
+                .iter(&world)
+                .count(),
+            1
+        );
+        assert!(world.query::<&i32>().get(&world, a).is_ok());
+        assert!(world
+            .query_filtered::<(), Added<i32>>()
+            .get(&world, a)
+            .is_ok());
+        assert!(world.query::<&i32>().get(&world, a).is_ok());
+        assert!(world
+            .query_filtered::<(), Added<i32>>()
+            .get(&world, a)
+            .is_ok());
+
+        world.clear_trackers();
+
+        assert_eq!(world.query::<&i32>().iter(&world).count(), 1);
+        assert_eq!(
+            world
+                .query_filtered::<(), Added<i32>>()
+                .iter(&world)
+                .count(),
+            0
+        );
+        assert_eq!(world.query::<&i32>().iter(&world).count(), 1);
+        assert_eq!(
+            world
+                .query_filtered::<(), Added<i32>>()
+                .iter(&world)
+                .count(),
+            0
+        );
+        assert!(world.query::<&i32>().get(&world, a).is_ok());
+        assert!(world
+            .query_filtered::<(), Added<i32>>()
+            .get(&world, a)
+            .is_err());
+        assert!(world.query::<&i32>().get(&world, a).is_ok());
+        assert!(world
+            .query_filtered::<(), Added<i32>>()
+            .get(&world, a)
+            .is_err());
+    }
+
+    #[test]
+    fn added_queries() {
+        let mut world = World::default();
+        let e1 = world.spawn().insert(A(0)).id();
+
+        fn get_added<Com: Component>(world: &mut World) -> Vec<Entity> {
+            world
+                .query_filtered::<Entity, Added<Com>>()
+                .iter(&world)
+                .collect::<Vec<Entity>>()
+        }
+
+        assert_eq!(get_added::<A>(&mut world), vec![e1]);
+        world.entity_mut(e1).insert(B(0));
+        assert_eq!(get_added::<A>(&mut world), vec![e1]);
+        assert_eq!(get_added::<B>(&mut world), vec![e1]);
+
+        world.clear_trackers();
+        assert!(get_added::<A>(&mut world).is_empty());
+        let e2 = world.spawn().insert_bundle((A(1), B(1))).id();
+        assert_eq!(get_added::<A>(&mut world), vec![e2]);
+        assert_eq!(get_added::<B>(&mut world), vec![e2]);
+
+        let added = world
+            .query_filtered::<Entity, (Added<A>, Added<B>)>()
+            .iter(&world)
+            .collect::<Vec<Entity>>();
+        assert_eq!(added, vec![e2]);
+    }
+
+    #[test]
+    fn mutated_trackers() {
+        let mut world = World::default();
+        let e1 = world.spawn().insert_bundle((A(0), B(0))).id();
+        let e2 = world.spawn().insert_bundle((A(0), B(0))).id();
+        let e3 = world.spawn().insert_bundle((A(0), B(0))).id();
+        world.spawn().insert_bundle((A(0), B));
+
+        for (i, mut a) in world.query::<&mut A>().iter_mut(&mut world).enumerate() {
+            if i % 2 == 0 {
+                a.0 += 1;
+            }
+        }
+
+        fn get_filtered<F: WorldQuery>(world: &mut World) -> Vec<Entity>
+        where
+            F::Fetch: FilterFetch,
+        {
+            world
+                .query_filtered::<Entity, F>()
+                .iter(&world)
+                .collect::<Vec<Entity>>()
+        }
+
+        assert_eq!(get_filtered::<Mutated<A>>(&mut world), vec![e1, e3]);
+
+        // ensure changing an entity's archetypes also moves its mutated state
+        world.entity_mut(e1).insert(C);
+
+        assert_eq!(get_filtered::<Mutated<A>>(&mut world), vec![e3, e1], "changed entities list should not change (although the order will due to archetype moves)");
+
+        // spawning a new A entity should not change existing mutated state
+        world.entity_mut(e1).insert_bundle((A(0), B));
+        assert_eq!(
+            get_filtered::<Mutated<A>>(&mut world),
+            vec![e3, e1],
+            "changed entities list should not change"
+        );
+
+        // removing an unchanged entity should not change mutated state
+        assert!(world.despawn(e2));
+        assert_eq!(
+            get_filtered::<Mutated<A>>(&mut world),
+            vec![e3, e1],
+            "changed entities list should not change"
+        );
+
+        // removing a changed entity should remove it from enumeration
+        assert!(world.despawn(e1));
+        assert_eq!(
+            get_filtered::<Mutated<A>>(&mut world),
+            vec![e3],
+            "e1 should no longer be returned"
+        );
+
+        world.clear_trackers();
+
+        assert!(get_filtered::<Mutated<A>>(&mut world).is_empty());
+
+        let e4 = world.spawn().id();
+
+        world.entity_mut(e4).insert(A(0));
+        assert!(get_filtered::<Mutated<A>>(&mut world).is_empty());
+        assert_eq!(get_filtered::<Added<A>>(&mut world), vec![e4]);
+
+        world.entity_mut(e4).insert(A(1));
+        assert_eq!(get_filtered::<Mutated<A>>(&mut world), vec![e4]);
+
+        world.clear_trackers();
+
+        // ensure inserting multiple components set mutated state for
+        // already existing components and set added state for
+        // non existing components even when changing archetype.
+        world.entity_mut(e4).insert_bundle((A(0), B(0)));
+
+        assert!(get_filtered::<Added<A>>(&mut world).is_empty());
+        assert_eq!(get_filtered::<Mutated<A>>(&mut world), vec![e4]);
+        assert_eq!(get_filtered::<Added<B>>(&mut world), vec![e4]);
+        assert!(get_filtered::<Mutated<B>>(&mut world).is_empty());
+    }
+
+    #[test]
+    fn empty_spawn() {
+        let mut world = World::default();
+        let e = world.spawn().id();
+        let mut e_mut = world.entity_mut(e);
+        e_mut.insert(A(0));
+        assert_eq!(e_mut.get::<A>().unwrap(), &A(0));
+    }
+
+    #[test]
+    fn reserve_and_spawn() {
+        let mut world = World::default();
+        let e = world.entities().reserve_entity();
+        world.flush();
+        let mut e_mut = world.entity_mut(e);
+        e_mut.insert(A(0));
+        assert_eq!(e_mut.get::<A>().unwrap(), &A(0));
+    }
+
+    #[test]
+    fn multiple_mutated_query() {
+        let mut world = World::default();
+        world.spawn().insert_bundle((A(0), B(0))).id();
+        let e2 = world.spawn().insert_bundle((A(0), B(0))).id();
+        world.spawn().insert_bundle((A(0), B(0)));
+
+        for mut a in world.query::<&mut A>().iter_mut(&mut world) {
+            a.0 += 1;
+        }
+
+        for mut b in world.query::<&mut B>().iter_mut(&mut world).skip(1).take(1) {
+            b.0 += 1;
+        }
+
+        let a_b_mutated = world
+            .query_filtered::<Entity, (Mutated<A>, Mutated<B>)>()
+            .iter(&world)
+            .collect::<Vec<Entity>>();
+        assert_eq!(a_b_mutated, vec![e2]);
+    }
+
+    #[test]
+    fn or_mutated_query() {
+        let mut world = World::default();
+        let e1 = world.spawn().insert_bundle((A(0), B(0))).id();
+        let e2 = world.spawn().insert_bundle((A(0), B(0))).id();
+        let _e3 = world.spawn().insert_bundle((A(0), B(0))).id();
+        let e4 = world.spawn().insert(A(0)).id(); // ensure filters work for archetypes with only one of the Or filter items
+
+        *world.entity_mut(e1).get_mut::<A>().unwrap() = A(1);
+        *world.entity_mut(e2).get_mut::<B>().unwrap() = B(1);
+        *world.entity_mut(e4).get_mut::<A>().unwrap() = A(1);
+
+        let a_b_mutated = world
+            .query_filtered::<Entity, Or<(Mutated<A>, Mutated<B>)>>()
+            .iter(&world)
+            .collect::<Vec<Entity>>();
+        // e1 has mutated A, e3 has mutated B, e2 has mutated A and B, _e4 has no mutated component
+        assert_eq!(a_b_mutated, vec![e1, e2, e4]);
+    }
+
+    #[test]
+    fn changed_query() {
+        let mut world = World::default();
+        let e1 = world.spawn().insert_bundle((A(0), B(0))).id();
+
+        fn get_changed(world: &mut World) -> Vec<Entity> {
+            world
+                .query_filtered::<Entity, Changed<A>>()
+                .iter(&world)
+                .collect::<Vec<Entity>>()
+        }
+        assert_eq!(get_changed(&mut world), vec![e1]);
+        world.clear_trackers();
+        assert_eq!(get_changed(&mut world), vec![]);
+        *world.get_mut(e1).unwrap() = A(1);
+        assert_eq!(get_changed(&mut world), vec![e1]);
+    }
+
+    #[test]
+    fn resource() {
+        let mut world = World::default();
+        assert!(world.get_resource::<i32>().is_none());
+        assert!(!world.contains_resource::<i32>());
+
+        world.insert_resource(123);
+        let resource_id = world
+            .components()
+            .get_resource_id(TypeId::of::<i32>())
+            .unwrap();
+        let archetype_component_id = world
+            .archetypes()
+            .resource()
+            .get_archetype_component_id(resource_id)
+            .unwrap();
+
+        assert_eq!(*world.get_resource::<i32>().expect("resource exists"), 123);
+        assert!(world.contains_resource::<i32>());
+
+        world.insert_resource(456u64);
+        assert_eq!(
+            *world.get_resource::<u64>().expect("resource exists"),
+            456u64
+        );
+
+        world.insert_resource(789u64);
+        assert_eq!(*world.get_resource::<u64>().expect("resource exists"), 789);
+
+        {
+            let mut value = world.get_resource_mut::<u64>().expect("resource exists");
+            assert_eq!(*value, 789);
+            *value = 10;
+        }
+
+        assert_eq!(
+            world.get_resource::<u64>(),
+            Some(&10),
+            "resource changes are preserved"
+        );
+
+        assert_eq!(
+            world.remove_resource::<u64>(),
+            Some(10),
+            "removed resource has the correct value"
+        );
+        assert_eq!(
+            world.get_resource::<u64>(),
+            None,
+            "removed resource no longer exists"
+        );
+        assert_eq!(
+            world.remove_resource::<u64>(),
+            None,
+            "double remove returns nothing"
+        );
+
+        world.insert_resource(1u64);
+        assert_eq!(
+            world.get_resource::<u64>(),
+            Some(&1u64),
+            "re-inserting resources works"
+        );
+
+        assert_eq!(
+            world.get_resource::<i32>(),
+            Some(&123),
+            "other resources are unaffected"
+        );
+
+        let current_resource_id = world
+            .components()
+            .get_resource_id(TypeId::of::<i32>())
+            .unwrap();
+        assert_eq!(
+            resource_id, current_resource_id,
+            "resource id does not change after removing / re-adding"
+        );
+
+        let current_archetype_component_id = world
+            .archetypes()
+            .resource()
+            .get_archetype_component_id(current_resource_id)
+            .unwrap();
+
+        assert_eq!(
+            archetype_component_id, current_archetype_component_id,
+            "resource archetype component id does not change after removing / re-adding"
+        );
+    }
+
+    #[test]
+    fn remove_intersection() {
+        let mut world = World::default();
+        let e1 = world.spawn().insert_bundle((1, 1.0, "a")).id();
+
+        let mut e = world.entity_mut(e1);
+        assert_eq!(e.get::<&'static str>(), Some(&"a"));
+        assert_eq!(e.get::<i32>(), Some(&1));
+        assert_eq!(e.get::<f64>(), Some(&1.0));
+        assert_eq!(
+            e.get::<usize>(),
+            None,
+            "usize is not in the entity, so it should not exist"
+        );
+
+        e.remove_bundle_intersection::<(i32, f64, usize)>();
+        assert_eq!(
+            e.get::<&'static str>(),
+            Some(&"a"),
+            "&'static str is not in the removed bundle, so it should exist"
+        );
+        assert_eq!(
+            e.get::<i32>(),
+            None,
+            "i32 is in the removed bundle, so it should not exist"
+        );
+        assert_eq!(
+            e.get::<f64>(),
+            None,
+            "f64 is in the removed bundle, so it should not exist"
+        );
+        assert_eq!(
+            e.get::<usize>(),
+            None,
+            "usize is in the removed bundle, so it should not exist"
+        );
+    }
+
+    #[test]
+    fn remove_bundle() {
+        let mut world = World::default();
+        world.spawn().insert_bundle((1, 1.0, 1usize)).id();
+        let e2 = world.spawn().insert_bundle((2, 2.0, 2usize)).id();
+        world.spawn().insert_bundle((3, 3.0, 3usize)).id();
+
+        let mut query = world.query::<(&f64, &usize)>();
+        let results = query
+            .iter(&world)
+            .map(|(a, b)| (*a, *b))
+            .collect::<Vec<_>>();
+        assert_eq!(results, vec![(1.0, 1usize), (2.0, 2usize), (3.0, 3usize),]);
+
+        let removed_bundle = world
+            .entity_mut(e2)
+            .remove_bundle::<(f64, usize)>()
+            .unwrap();
+        assert_eq!(removed_bundle, (2.0, 2usize));
+
+        let results = query
+            .iter(&world)
+            .map(|(a, b)| (*a, *b))
+            .collect::<Vec<_>>();
+        assert_eq!(results, vec![(1.0, 1usize), (3.0, 3usize),]);
+
+        let mut i32_query = world.query::<&i32>();
+        let results = i32_query.iter(&world).cloned().collect::<Vec<_>>();
+        assert_eq!(results, vec![1, 3, 2]);
+
+        let entity_ref = world.entity(e2);
+        assert_eq!(
+            entity_ref.get::<i32>(),
+            Some(&2),
+            "i32 is not in the removed bundle, so it should exist"
+        );
+        assert_eq!(
+            entity_ref.get::<f64>(),
+            None,
+            "f64 is in the removed bundle, so it should not exist"
+        );
+        assert_eq!(
+            entity_ref.get::<usize>(),
+            None,
+            "usize is in the removed bundle, so it should not exist"
+        );
+    }
+
+    #[test]
+    fn non_send_resource() {
+        let mut world = World::default();
+        world.insert_non_send(123i32);
+        world.insert_non_send(456i64);
+        assert_eq!(*world.get_non_send_resource::<i32>().unwrap(), 123);
+        assert_eq!(*world.get_non_send_resource_mut::<i64>().unwrap(), 456);
+    }
+
+    #[test]
+    #[should_panic]
+    fn non_send_resource_panic() {
+        let mut world = World::default();
+        world.insert_non_send(0i32);
+        std::thread::spawn(move || {
+            let _ = world.get_non_send_resource_mut::<i32>();
+        })
+        .join()
+        .unwrap();
+    }
+
+    #[test]
+    fn flags_query() {
+        let mut world = World::default();
+        let e1 = world.spawn().insert_bundle((A(0), B(0))).id();
+        world.spawn().insert(B(0));
+
+        let mut flags_query = world.query::<Option<Flags<A>>>();
+        let flags = flags_query.iter(&world).collect::<Vec<_>>();
+        let a_flags = flags[0].as_ref().unwrap();
+        assert!(flags[1].is_none());
+        assert!(a_flags.added());
+        assert!(!a_flags.mutated());
+        assert!(a_flags.changed());
+        world.clear_trackers();
+        let flags = flags_query.iter(&world).collect::<Vec<_>>();
+        let a_flags = flags[0].as_ref().unwrap();
+        assert!(!a_flags.added());
+        assert!(!a_flags.mutated());
+        assert!(!a_flags.changed());
+        *world.get_mut(e1).unwrap() = A(1);
+        let flags = flags_query.iter(&world).collect::<Vec<_>>();
+        let a_flags = flags[0].as_ref().unwrap();
+        assert!(!a_flags.added());
+        assert!(a_flags.mutated());
+        assert!(a_flags.changed());
+    }
+
+    #[test]
+    fn exact_size_query() {
+        let mut world = World::default();
+        world.spawn().insert_bundle((A(0), B(0)));
+        world.spawn().insert_bundle((A(0), B(0)));
+        world.spawn().insert_bundle((A(0), B(0), C));
+        world.spawn().insert(C);
+
+        let mut query = world.query::<(&A, &B)>();
+        assert_eq!(query.iter(&world).len(), 3);
+    }
+
+    #[test]
+    #[should_panic]
+    fn duplicate_components_panic() {
+        let mut world = World::new();
+        world.spawn().insert_bundle((1, 2));
+    }
+
+    #[test]
+    #[should_panic]
+    fn ref_and_mut_query_panic() {
+        let mut world = World::new();
+        world.query::<(&A, &mut A)>();
+    }
+
+    #[test]
+    #[should_panic]
+    fn mut_and_mut_query_panic() {
+        let mut world = World::new();
+        world.query::<(&mut A, &mut A)>();
+    }
+
+    #[test]
+    #[should_panic]
+    fn multiple_worlds_same_query_iter() {
+        let mut world_a = World::new();
+        let world_b = World::new();
+        let mut query = world_a.query::<&i32>();
+        query.iter(&world_a);
+        query.iter(&world_b);
+    }
+
+    #[test]
+    #[should_panic]
+    fn multiple_worlds_same_query_get() {
+        let mut world_a = World::new();
+        let world_b = World::new();
+        let mut query = world_a.query::<&i32>();
+        let _ = query.get(&world_a, Entity::new(0));
+        let _ = query.get(&world_b, Entity::new(0));
+    }
+
+    #[test]
+    #[should_panic]
+    fn multiple_worlds_same_query_for_each() {
+        let mut world_a = World::new();
+        let world_b = World::new();
+        let mut query = world_a.query::<&i32>();
+        query.for_each(&world_a, |_| {});
+        query.for_each(&world_b, |_| {});
+    }
+
+    #[test]
+    fn resource_scope() {
+        let mut world = World::default();
+        world.insert_resource::<i32>(0);
+        world.resource_scope(|mut value: Mut<i32>, world: &mut World| {
+            *value += 1;
+            assert!(!world.contains_resource::<i32>());
+        });
+        assert_eq!(*world.get_resource::<i32>().unwrap(), 1);
+    }
+}
diff --git a/crates/bevy_ecs/src/query/access.rs b/crates/bevy_ecs/src/query/access.rs
new file mode 100644
index 0000000000000..5904f12837829
--- /dev/null
+++ b/crates/bevy_ecs/src/query/access.rs
@@ -0,0 +1,200 @@
+use crate::storage::SparseSetIndex;
+use fixedbitset::FixedBitSet;
+use std::marker::PhantomData;
+
+#[derive(Debug, Eq, PartialEq, Clone)]
+pub struct Access<T: SparseSetIndex> {
+    reads_all: bool,
+    /// A combined set of T read and write accesses.
+    reads_and_writes: FixedBitSet,
+    writes: FixedBitSet,
+    marker: PhantomData<T>,
+}
+
+impl<T: SparseSetIndex> Default for Access<T> {
+    fn default() -> Self {
+        Self {
+            reads_all: false,
+            reads_and_writes: Default::default(),
+            writes: Default::default(),
+            marker: PhantomData,
+        }
+    }
+}
+
+impl<T: SparseSetIndex> Access<T> {
+    pub fn grow(&mut self, bits: usize) {
+        self.reads_and_writes.grow(bits);
+        self.writes.grow(bits);
+    }
+
+    pub fn add_read(&mut self, index: T) {
+        self.reads_and_writes.grow(index.sparse_set_index() + 1);
+        self.reads_and_writes.insert(index.sparse_set_index());
+    }
+
+    pub fn add_write(&mut self, index: T) {
+        self.reads_and_writes.grow(index.sparse_set_index() + 1);
+        self.writes.grow(index.sparse_set_index() + 1);
+        self.reads_and_writes.insert(index.sparse_set_index());
+        self.writes.insert(index.sparse_set_index());
+    }
+
+    pub fn has_read(&self, index: T) -> bool {
+        if self.reads_all {
+            true
+        } else {
+            self.reads_and_writes.contains(index.sparse_set_index())
+        }
+    }
+
+    pub fn has_write(&self, index: T) -> bool {
+        self.writes.contains(index.sparse_set_index())
+    }
+
+    pub fn read_all(&mut self) {
+        self.reads_all = true;
+    }
+
+    pub fn reads_all(&self) -> bool {
+        self.reads_all
+    }
+
+    pub fn clear(&mut self) {
+        self.reads_all = false;
+        self.reads_and_writes.clear();
+        self.writes.clear();
+    }
+
+    pub fn extend(&mut self, other: &Access<T>) {
+        self.reads_all = self.reads_all || other.reads_all;
+        self.reads_and_writes.union_with(&other.reads_and_writes);
+        self.writes.union_with(&other.writes);
+    }
+
+    pub fn is_compatible(&self, other: &Access<T>) -> bool {
+        if self.reads_all {
+            0 == other.writes.count_ones(..)
+        } else if other.reads_all {
+            0 == self.writes.count_ones(..)
+        } else {
+            self.writes.is_disjoint(&other.reads_and_writes)
+                && self.reads_and_writes.is_disjoint(&other.writes)
+        }
+    }
+
+    pub fn get_conflicts(&self, other: &Access<T>) -> Vec<T> {
+        let mut conflicts = FixedBitSet::default();
+        if self.reads_all {
+            conflicts.extend(other.writes.ones());
+        }
+
+        if other.reads_all {
+            conflicts.extend(self.writes.ones());
+        }
+        conflicts.extend(self.writes.intersection(&other.reads_and_writes));
+        conflicts.extend(self.reads_and_writes.intersection(&other.writes));
+        conflicts
+            .ones()
+            .map(SparseSetIndex::get_sparse_set_index)
+            .collect()
+    }
+}
+
+#[derive(Clone)]
+pub struct FilteredAccess<T: SparseSetIndex> {
+    access: Access<T>,
+    with: FixedBitSet,
+    without: FixedBitSet,
+}
+
+impl<T: SparseSetIndex> Default for FilteredAccess<T> {
+    fn default() -> Self {
+        Self {
+            access: Access::default(),
+            with: Default::default(),
+            without: Default::default(),
+        }
+    }
+}
+
+impl<T: SparseSetIndex> FilteredAccess<T> {
+    #[inline]
+    pub fn access(&self) -> &Access<T> {
+        &self.access
+    }
+
+    pub fn add_read(&mut self, index: T) {
+        self.access.add_read(index.clone());
+        self.add_with(index);
+    }
+
+    pub fn add_write(&mut self, index: T) {
+        self.access.add_write(index.clone());
+        self.add_with(index);
+    }
+
+    pub fn add_with(&mut self, index: T) {
+        self.with.grow(index.sparse_set_index() + 1);
+        self.with.insert(index.sparse_set_index());
+    }
+
+    pub fn add_without(&mut self, index: T) {
+        self.without.grow(index.sparse_set_index() + 1);
+        self.without.insert(index.sparse_set_index());
+    }
+
+    pub fn is_compatible(&self, other: &FilteredAccess<T>) -> bool {
+        if self.access.is_compatible(&other.access) {
+            true
+        } else {
+            self.with.intersection(&other.without).next().is_some()
+                || self.without.intersection(&other.with).next().is_some()
+        }
+    }
+}
+
+pub struct FilteredAccessSet<T: SparseSetIndex> {
+    combined_access: Access<T>,
+    filtered_accesses: Vec<FilteredAccess<T>>,
+}
+
+impl<T: SparseSetIndex> FilteredAccessSet<T> {
+    #[inline]
+    pub fn combined_access(&self) -> &Access<T> {
+        &self.combined_access
+    }
+
+    #[inline]
+    pub fn combined_access_mut(&mut self) -> &mut Access<T> {
+        &mut self.combined_access
+    }
+
+    pub fn get_conflicts(&self, filtered_access: &FilteredAccess<T>) -> Vec<T> {
+        // if combined unfiltered access is incompatible, check each filtered access for compatibility
+        if !filtered_access.access.is_compatible(&self.combined_access) {
+            for current_filtered_access in self.filtered_accesses.iter() {
+                if !current_filtered_access.is_compatible(&filtered_access) {
+                    return current_filtered_access
+                        .access
+                        .get_conflicts(&filtered_access.access);
+                }
+            }
+        }
+        Vec::new()
+    }
+
+    pub fn add(&mut self, filtered_access: FilteredAccess<T>) {
+        self.combined_access.extend(&filtered_access.access);
+        self.filtered_accesses.push(filtered_access);
+    }
+}
+
+impl<T: SparseSetIndex> Default for FilteredAccessSet<T> {
+    fn default() -> Self {
+        Self {
+            combined_access: Default::default(),
+            filtered_accesses: Vec::new(),
+        }
+    }
+}
diff --git a/crates/bevy_ecs/src/query/fetch.rs b/crates/bevy_ecs/src/query/fetch.rs
new file mode 100644
index 0000000000000..10f7f6b4ab094
--- /dev/null
+++ b/crates/bevy_ecs/src/query/fetch.rs
@@ -0,0 +1,813 @@
+use crate::{
+    archetype::{Archetype, ArchetypeComponentId},
+    component::{Component, ComponentFlags, ComponentId, StorageType},
+    entity::Entity,
+    query::{Access, FilteredAccess},
+    storage::{ComponentSparseSet, Table, Tables},
+    world::{Mut, World},
+};
+use bevy_ecs_macros::all_tuples;
+use std::{
+    marker::PhantomData,
+    ptr::{self, NonNull},
+};
+
+pub trait WorldQuery {
+    type Fetch: for<'a> Fetch<'a, State = Self::State>;
+    type State: FetchState;
+}
+
+pub trait Fetch<'w>: Sized {
+    type Item;
+    type State: FetchState;
+
+    /// Creates a new instance of this fetch.
+    /// # Safety
+    /// `state` must have been initialized (via [FetchState::init]) using the same `world` passed in to this function.
+    unsafe fn init(world: &World, state: &Self::State) -> Self;
+
+    /// Returns true if (and only if) every table of every archetype matched by this Fetch contains all of the matched components.
+    /// This is used to select a more efficient "table iterator" for "dense" queries.
+    /// If this returns true, [Fetch::set_table] and [Fetch::table_fetch] will be called for iterators
+    /// If this returns false, [Fetch::set_archetype] and [Fetch::archetype_fetch] will be called for iterators
+    fn is_dense(&self) -> bool;
+
+    /// Adjusts internal state to account for the next [Archetype]. This will always be called on archetypes that match this [Fetch]
+    /// # Safety
+    /// `archetype` and `tables` must be from the [World] [Fetch::init] was called on. `state` must be the [Self::State] this was initialized with.
+    unsafe fn set_archetype(&mut self, state: &Self::State, archetype: &Archetype, tables: &Tables);
+
+    /// Adjusts internal state to account for the next [Table]. This will always be called on tables that match this [Fetch]
+    /// # Safety
+    /// `table` must be from the [World] [Fetch::init] was called on. `state` must be the [Self::State] this was initialized with.
+    unsafe fn set_table(&mut self, state: &Self::State, table: &Table);
+
+    /// Fetch [Self::Item] for the given `archetype_index` in the current [Archetype]. This must always be called after [Fetch::set_archetype] with an `archetype_index`
+    /// in the range of the current [Archetype]
+    /// # Safety
+    /// Must always be called _after_ [Fetch::set_archetype]. `archetype_index` must be in the range of the current archetype
+    unsafe fn archetype_fetch(&mut self, archetype_index: usize) -> Self::Item;
+
+    /// Fetch [Self::Item] for the given `table_row` in the current [Table]. This must always be called after [Fetch::set_table] with a `table_row`
+    /// in the range of the current [Table]
+    /// # Safety
+    /// Must always be called _after_ [Fetch::set_table]. `table_row` must be in the range of the current table
+    unsafe fn table_fetch(&mut self, table_row: usize) -> Self::Item;
+}
+
+/// State used to construct a Fetch. This will be cached inside QueryState, so it is best to move as much data /
+/// computation here as possible to reduce the cost of constructing Fetch.
+/// SAFETY:
+/// Implementor must ensure that [FetchState::update_component_access] and [FetchState::update_archetype_component_access] exactly
+/// reflects the results of [FetchState::matches_archetype], [FetchState::matches_table], [Fetch::archetype_fetch], and [Fetch::table_fetch]
+pub unsafe trait FetchState: Send + Sync + Sized {
+    fn init(world: &mut World) -> Self;
+    fn update_component_access(&self, access: &mut FilteredAccess<ComponentId>);
+    fn update_archetype_component_access(
+        &self,
+        archetype: &Archetype,
+        access: &mut Access<ArchetypeComponentId>,
+    );
+    fn matches_archetype(&self, archetype: &Archetype) -> bool;
+    fn matches_table(&self, table: &Table) -> bool;
+}
+
+/// A fetch that is read only. This must only be implemented for read-only fetches.
+pub unsafe trait ReadOnlyFetch {}
+
+impl WorldQuery for Entity {
+    type Fetch = EntityFetch;
+    type State = EntityState;
+}
+
+pub struct EntityFetch {
+    entities: *const Entity,
+}
+
+/// SAFE: access is read only
+unsafe impl ReadOnlyFetch for EntityFetch {}
+
+pub struct EntityState;
+
+// SAFE: no component or archetype access
+unsafe impl FetchState for EntityState {
+    fn init(_world: &mut World) -> Self {
+        Self
+    }
+
+    fn update_component_access(&self, _access: &mut FilteredAccess<ComponentId>) {}
+
+    fn update_archetype_component_access(
+        &self,
+        _archetype: &Archetype,
+        _access: &mut Access<ArchetypeComponentId>,
+    ) {
+    }
+
+    #[inline]
+    fn matches_archetype(&self, _archetype: &Archetype) -> bool {
+        true
+    }
+
+    #[inline]
+    fn matches_table(&self, _table: &Table) -> bool {
+        true
+    }
+}
+
+impl<'w> Fetch<'w> for EntityFetch {
+    type Item = Entity;
+    type State = EntityState;
+
+    #[inline]
+    fn is_dense(&self) -> bool {
+        true
+    }
+
+    unsafe fn init(_world: &World, _state: &Self::State) -> Self {
+        Self {
+            entities: std::ptr::null::<Entity>(),
+        }
+    }
+
+    #[inline]
+    unsafe fn set_archetype(
+        &mut self,
+        _state: &Self::State,
+        archetype: &Archetype,
+        _tables: &Tables,
+    ) {
+        self.entities = archetype.entities().as_ptr();
+    }
+
+    #[inline]
+    unsafe fn set_table(&mut self, _state: &Self::State, table: &Table) {
+        self.entities = table.entities().as_ptr();
+    }
+
+    #[inline]
+    unsafe fn table_fetch(&mut self, table_row: usize) -> Self::Item {
+        *self.entities.add(table_row)
+    }
+
+    #[inline]
+    unsafe fn archetype_fetch(&mut self, archetype_index: usize) -> Self::Item {
+        *self.entities.add(archetype_index)
+    }
+}
+
+impl<T: Component> WorldQuery for &T {
+    type Fetch = ReadFetch<T>;
+    type State = ReadState<T>;
+}
+
+pub struct ReadState<T> {
+    component_id: ComponentId,
+    storage_type: StorageType,
+    marker: PhantomData<T>,
+}
+
+// SAFE: component access and archetype component access are properly updated to reflect that T is read
+unsafe impl<T: Component> FetchState for ReadState<T> {
+    fn init(world: &mut World) -> Self {
+        let component_info = world.components.get_or_insert_info::<T>();
+        ReadState {
+            component_id: component_info.id(),
+            storage_type: component_info.storage_type(),
+            marker: PhantomData,
+        }
+    }
+
+    fn update_component_access(&self, access: &mut FilteredAccess<ComponentId>) {
+        access.add_read(self.component_id)
+    }
+
+    fn update_archetype_component_access(
+        &self,
+        archetype: &Archetype,
+        access: &mut Access<ArchetypeComponentId>,
+    ) {
+        if let Some(archetype_component_id) =
+            archetype.get_archetype_component_id(self.component_id)
+        {
+            access.add_read(archetype_component_id);
+        }
+    }
+
+    fn matches_archetype(&self, archetype: &Archetype) -> bool {
+        archetype.contains(self.component_id)
+    }
+
+    fn matches_table(&self, table: &Table) -> bool {
+        table.has_column(self.component_id)
+    }
+}
+
+pub struct ReadFetch<T> {
+    storage_type: StorageType,
+    table_components: NonNull<T>,
+    entity_table_rows: *const usize,
+    entities: *const Entity,
+    sparse_set: *const ComponentSparseSet,
+}
+
+/// SAFE: access is read only
+unsafe impl<T> ReadOnlyFetch for ReadFetch<T> {}
+
+impl<'w, T: Component> Fetch<'w> for ReadFetch<T> {
+    type Item = &'w T;
+    type State = ReadState<T>;
+
+    #[inline]
+    fn is_dense(&self) -> bool {
+        match self.storage_type {
+            StorageType::Table => true,
+            StorageType::SparseSet => false,
+        }
+    }
+
+    unsafe fn init(world: &World, state: &Self::State) -> Self {
+        let mut value = Self {
+            storage_type: state.storage_type,
+            table_components: NonNull::dangling(),
+            entities: ptr::null::<Entity>(),
+            entity_table_rows: ptr::null::<usize>(),
+            sparse_set: ptr::null::<ComponentSparseSet>(),
+        };
+        if state.storage_type == StorageType::SparseSet {
+            value.sparse_set = world
+                .storages()
+                .sparse_sets
+                .get(state.component_id)
+                .unwrap();
+        }
+        value
+    }
+
+    #[inline]
+    unsafe fn set_archetype(
+        &mut self,
+        state: &Self::State,
+        archetype: &Archetype,
+        tables: &Tables,
+    ) {
+        match state.storage_type {
+            StorageType::Table => {
+                self.entity_table_rows = archetype.entity_table_rows().as_ptr();
+                // SAFE: archetype tables always exist
+                let table = tables.get_unchecked(archetype.table_id());
+                let column = table.get_column(state.component_id).unwrap();
+                self.table_components = column.get_ptr().cast::<T>();
+            }
+            StorageType::SparseSet => self.entities = archetype.entities().as_ptr(),
+        }
+    }
+
+    #[inline]
+    unsafe fn set_table(&mut self, state: &Self::State, table: &Table) {
+        self.table_components = table
+            .get_column(state.component_id)
+            .unwrap()
+            .get_ptr()
+            .cast::<T>();
+    }
+
+    #[inline]
+    unsafe fn archetype_fetch(&mut self, archetype_index: usize) -> Self::Item {
+        match self.storage_type {
+            StorageType::Table => {
+                let table_row = *self.entity_table_rows.add(archetype_index);
+                &*self.table_components.as_ptr().add(table_row)
+            }
+            StorageType::SparseSet => {
+                let entity = *self.entities.add(archetype_index);
+                &*(*self.sparse_set).get(entity).unwrap().cast::<T>()
+            }
+        }
+    }
+
+    #[inline]
+    unsafe fn table_fetch(&mut self, table_row: usize) -> Self::Item {
+        &*self.table_components.as_ptr().add(table_row)
+    }
+}
+
+impl<T: Component> WorldQuery for &mut T {
+    type Fetch = WriteFetch<T>;
+    type State = WriteState<T>;
+}
+
+pub struct WriteFetch<T> {
+    storage_type: StorageType,
+    table_components: NonNull<T>,
+    table_flags: *mut ComponentFlags,
+    entities: *const Entity,
+    entity_table_rows: *const usize,
+    sparse_set: *const ComponentSparseSet,
+}
+
+pub struct WriteState<T> {
+    component_id: ComponentId,
+    storage_type: StorageType,
+    marker: PhantomData<T>,
+}
+
+// SAFE: component access and archetype component access are properly updated to reflect that T is written
+unsafe impl<T: Component> FetchState for WriteState<T> {
+    fn init(world: &mut World) -> Self {
+        let component_info = world.components.get_or_insert_info::<T>();
+        WriteState {
+            component_id: component_info.id(),
+            storage_type: component_info.storage_type(),
+            marker: PhantomData,
+        }
+    }
+
+    fn update_component_access(&self, access: &mut FilteredAccess<ComponentId>) {
+        if access.access().has_read(self.component_id) {
+            panic!("&mut {} conflicts with a previous access in this query. Mutable component access must be unique.",
+                std::any::type_name::<T>());
+        }
+        access.add_write(self.component_id);
+    }
+
+    fn update_archetype_component_access(
+        &self,
+        archetype: &Archetype,
+        access: &mut Access<ArchetypeComponentId>,
+    ) {
+        if let Some(archetype_component_id) =
+            archetype.get_archetype_component_id(self.component_id)
+        {
+            access.add_write(archetype_component_id);
+        }
+    }
+
+    fn matches_archetype(&self, archetype: &Archetype) -> bool {
+        archetype.contains(self.component_id)
+    }
+
+    fn matches_table(&self, table: &Table) -> bool {
+        table.has_column(self.component_id)
+    }
+}
+
+impl<'w, T: Component> Fetch<'w> for WriteFetch<T> {
+    type Item = Mut<'w, T>;
+    type State = WriteState<T>;
+
+    #[inline]
+    fn is_dense(&self) -> bool {
+        match self.storage_type {
+            StorageType::Table => true,
+            StorageType::SparseSet => false,
+        }
+    }
+
+    unsafe fn init(world: &World, state: &Self::State) -> Self {
+        let mut value = Self {
+            storage_type: state.storage_type,
+            table_components: NonNull::dangling(),
+            entities: ptr::null::<Entity>(),
+            entity_table_rows: ptr::null::<usize>(),
+            sparse_set: ptr::null::<ComponentSparseSet>(),
+            table_flags: ptr::null_mut::<ComponentFlags>(),
+        };
+        if state.storage_type == StorageType::SparseSet {
+            value.sparse_set = world
+                .storages()
+                .sparse_sets
+                .get(state.component_id)
+                .unwrap();
+        }
+        value
+    }
+
+    #[inline]
+    unsafe fn set_archetype(
+        &mut self,
+        state: &Self::State,
+        archetype: &Archetype,
+        tables: &Tables,
+    ) {
+        match state.storage_type {
+            StorageType::Table => {
+                self.entity_table_rows = archetype.entity_table_rows().as_ptr();
+                // SAFE: archetype tables always exist
+                let table = tables.get_unchecked(archetype.table_id());
+                let column = table.get_column(state.component_id).unwrap();
+                self.table_components = column.get_ptr().cast::<T>();
+                self.table_flags = column.get_flags_mut_ptr();
+            }
+            StorageType::SparseSet => self.entities = archetype.entities().as_ptr(),
+        }
+    }
+
+    #[inline]
+    unsafe fn set_table(&mut self, state: &Self::State, table: &Table) {
+        let column = table.get_column(state.component_id).unwrap();
+        self.table_components = column.get_ptr().cast::<T>();
+        self.table_flags = column.get_flags_mut_ptr();
+    }
+
+    #[inline]
+    unsafe fn archetype_fetch(&mut self, archetype_index: usize) -> Self::Item {
+        match self.storage_type {
+            StorageType::Table => {
+                let table_row = *self.entity_table_rows.add(archetype_index);
+                Mut {
+                    value: &mut *self.table_components.as_ptr().add(table_row),
+                    flags: &mut *self.table_flags.add(table_row),
+                }
+            }
+            StorageType::SparseSet => {
+                let entity = *self.entities.add(archetype_index);
+                let (component, flags) = (*self.sparse_set).get_with_flags(entity).unwrap();
+                Mut {
+                    value: &mut *component.cast::<T>(),
+                    flags: &mut *flags,
+                }
+            }
+        }
+    }
+
+    #[inline]
+    unsafe fn table_fetch(&mut self, table_row: usize) -> Self::Item {
+        Mut {
+            value: &mut *self.table_components.as_ptr().add(table_row),
+            flags: &mut *self.table_flags.add(table_row),
+        }
+    }
+}
+
+impl<T: WorldQuery> WorldQuery for Option<T> {
+    type Fetch = OptionFetch<T::Fetch>;
+    type State = OptionState<T::State>;
+}
+
+pub struct OptionFetch<T> {
+    fetch: T,
+    matches: bool,
+}
+
+/// SAFE: OptionFetch is read only because T is read only
+unsafe impl<T: ReadOnlyFetch> ReadOnlyFetch for OptionFetch<T> {}
+
+pub struct OptionState<T: FetchState> {
+    state: T,
+}
+
+// SAFE: component access and archetype component access are properly updated according to the internal Fetch
+unsafe impl<T: FetchState> FetchState for OptionState<T> {
+    fn init(world: &mut World) -> Self {
+        Self {
+            state: T::init(world),
+        }
+    }
+
+    fn update_component_access(&self, access: &mut FilteredAccess<ComponentId>) {
+        self.state.update_component_access(access);
+    }
+
+    fn update_archetype_component_access(
+        &self,
+        archetype: &Archetype,
+        access: &mut Access<ArchetypeComponentId>,
+    ) {
+        if self.state.matches_archetype(archetype) {
+            self.state
+                .update_archetype_component_access(archetype, access)
+        }
+    }
+
+    fn matches_archetype(&self, _archetype: &Archetype) -> bool {
+        true
+    }
+
+    fn matches_table(&self, _table: &Table) -> bool {
+        true
+    }
+}
+
+impl<'w, T: Fetch<'w>> Fetch<'w> for OptionFetch<T> {
+    type Item = Option<T::Item>;
+    type State = OptionState<T::State>;
+
+    #[inline]
+    fn is_dense(&self) -> bool {
+        self.fetch.is_dense()
+    }
+
+    unsafe fn init(world: &World, state: &Self::State) -> Self {
+        Self {
+            fetch: T::init(world, &state.state),
+            matches: false,
+        }
+    }
+
+    #[inline]
+    unsafe fn set_archetype(
+        &mut self,
+        state: &Self::State,
+        archetype: &Archetype,
+        tables: &Tables,
+    ) {
+        self.matches = state.state.matches_archetype(archetype);
+        if self.matches {
+            self.fetch.set_archetype(&state.state, archetype, tables);
+        }
+    }
+
+    #[inline]
+    unsafe fn set_table(&mut self, state: &Self::State, table: &Table) {
+        self.matches = state.state.matches_table(table);
+        if self.matches {
+            self.fetch.set_table(&state.state, table);
+        }
+    }
+
+    #[inline]
+    unsafe fn archetype_fetch(&mut self, archetype_index: usize) -> Self::Item {
+        if self.matches {
+            Some(self.fetch.archetype_fetch(archetype_index))
+        } else {
+            None
+        }
+    }
+
+    #[inline]
+    unsafe fn table_fetch(&mut self, table_row: usize) -> Self::Item {
+        if self.matches {
+            Some(self.fetch.table_fetch(table_row))
+        } else {
+            None
+        }
+    }
+}
+
+/// Flags on component `T` that happened since the start of the frame.
+#[derive(Clone)]
+pub struct Flags<T: Component> {
+    flags: ComponentFlags,
+    marker: PhantomData<T>,
+}
+impl<T: Component> std::fmt::Debug for Flags<T> {
+    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+        f.debug_struct("Flags")
+            .field("added", &self.added())
+            .field("mutated", &self.mutated())
+            .finish()
+    }
+}
+
+impl<T: Component> Flags<T> {
+    /// Has this component been added since the start of the frame.
+    pub fn added(&self) -> bool {
+        self.flags.contains(ComponentFlags::ADDED)
+    }
+
+    /// Has this component been mutated since the start of the frame.
+    pub fn mutated(&self) -> bool {
+        self.flags.contains(ComponentFlags::MUTATED)
+    }
+
+    /// Has this component been either mutated or added since the start of the frame.
+    pub fn changed(&self) -> bool {
+        self.flags
+            .intersects(ComponentFlags::ADDED | ComponentFlags::MUTATED)
+    }
+}
+
+impl<T: Component> WorldQuery for Flags<T> {
+    type Fetch = FlagsFetch<T>;
+    type State = FlagsState<T>;
+}
+
+pub struct FlagsState<T> {
+    component_id: ComponentId,
+    storage_type: StorageType,
+    marker: PhantomData<T>,
+}
+
+// SAFE: component access and archetype component access are properly updated to reflect that T is read
+unsafe impl<T: Component> FetchState for FlagsState<T> {
+    fn init(world: &mut World) -> Self {
+        let component_info = world.components.get_or_insert_info::<T>();
+        Self {
+            component_id: component_info.id(),
+            storage_type: component_info.storage_type(),
+            marker: PhantomData,
+        }
+    }
+
+    fn update_component_access(&self, access: &mut FilteredAccess<ComponentId>) {
+        access.add_read(self.component_id)
+    }
+
+    fn update_archetype_component_access(
+        &self,
+        archetype: &Archetype,
+        access: &mut Access<ArchetypeComponentId>,
+    ) {
+        if let Some(archetype_component_id) =
+            archetype.get_archetype_component_id(self.component_id)
+        {
+            access.add_read(archetype_component_id);
+        }
+    }
+
+    fn matches_archetype(&self, archetype: &Archetype) -> bool {
+        archetype.contains(self.component_id)
+    }
+
+    fn matches_table(&self, table: &Table) -> bool {
+        table.has_column(self.component_id)
+    }
+}
+
+pub struct FlagsFetch<T> {
+    storage_type: StorageType,
+    table_flags: *const ComponentFlags,
+    entity_table_rows: *const usize,
+    entities: *const Entity,
+    sparse_set: *const ComponentSparseSet,
+    marker: PhantomData<T>,
+}
+
+/// SAFE: access is read only  
+unsafe impl<T> ReadOnlyFetch for FlagsFetch<T> {}
+
+impl<'w, T: Component> Fetch<'w> for FlagsFetch<T> {
+    type Item = Flags<T>;
+    type State = FlagsState<T>;
+
+    #[inline]
+    fn is_dense(&self) -> bool {
+        match self.storage_type {
+            StorageType::Table => true,
+            StorageType::SparseSet => false,
+        }
+    }
+
+    unsafe fn init(world: &World, state: &Self::State) -> Self {
+        let mut value = Self {
+            storage_type: state.storage_type,
+            table_flags: ptr::null::<ComponentFlags>(),
+            entities: ptr::null::<Entity>(),
+            entity_table_rows: ptr::null::<usize>(),
+            sparse_set: ptr::null::<ComponentSparseSet>(),
+            marker: PhantomData,
+        };
+        if state.storage_type == StorageType::SparseSet {
+            value.sparse_set = world
+                .storages()
+                .sparse_sets
+                .get(state.component_id)
+                .unwrap();
+        }
+        value
+    }
+
+    #[inline]
+    unsafe fn set_archetype(
+        &mut self,
+        state: &Self::State,
+        archetype: &Archetype,
+        tables: &Tables,
+    ) {
+        match state.storage_type {
+            StorageType::Table => {
+                self.entity_table_rows = archetype.entity_table_rows().as_ptr();
+                // SAFE: archetype tables always exist
+                let table = tables.get_unchecked(archetype.table_id());
+                let column = table.get_column(state.component_id).unwrap();
+                self.table_flags = column.get_flags_mut_ptr().cast::<ComponentFlags>();
+            }
+            StorageType::SparseSet => self.entities = archetype.entities().as_ptr(),
+        }
+    }
+
+    #[inline]
+    unsafe fn set_table(&mut self, state: &Self::State, table: &Table) {
+        self.table_flags = table
+            .get_column(state.component_id)
+            .unwrap()
+            .get_flags_mut_ptr()
+            .cast::<ComponentFlags>();
+    }
+
+    #[inline]
+    unsafe fn archetype_fetch(&mut self, archetype_index: usize) -> Self::Item {
+        match self.storage_type {
+            StorageType::Table => {
+                let table_row = *self.entity_table_rows.add(archetype_index);
+                Flags {
+                    flags: *self.table_flags.add(table_row),
+                    marker: PhantomData,
+                }
+            }
+            StorageType::SparseSet => {
+                let entity = *self.entities.add(archetype_index);
+                Flags {
+                    flags: *(*self.sparse_set).get_flags(entity).unwrap(),
+                    marker: PhantomData,
+                }
+            }
+        }
+    }
+
+    #[inline]
+    unsafe fn table_fetch(&mut self, table_row: usize) -> Self::Item {
+        Flags {
+            flags: *self.table_flags.add(table_row),
+            marker: PhantomData,
+        }
+    }
+}
+
+macro_rules! impl_tuple_fetch {
+    ($(($name: ident, $state: ident)),*) => {
+        #[allow(non_snake_case)]
+        impl<'a, $($name: Fetch<'a>),*> Fetch<'a> for ($($name,)*) {
+            type Item = ($($name::Item,)*);
+            type State = ($($name::State,)*);
+
+            unsafe fn init(_world: &World, state: &Self::State) -> Self {
+                let ($($name,)*) = state;
+                ($($name::init(_world, $name),)*)
+            }
+
+
+            #[inline]
+            fn is_dense(&self) -> bool {
+                let ($($name,)*) = self;
+                true $(&& $name.is_dense())*
+            }
+
+            #[inline]
+            unsafe fn set_archetype(&mut self, _state: &Self::State, _archetype: &Archetype, _tables: &Tables) {
+                let ($($name,)*) = self;
+                let ($($state,)*) = _state;
+                $($name.set_archetype($state, _archetype, _tables);)*
+            }
+
+            #[inline]
+            unsafe fn set_table(&mut self, _state: &Self::State, _table: &Table) {
+                let ($($name,)*) = self;
+                let ($($state,)*) = _state;
+                $($name.set_table($state, _table);)*
+            }
+
+            #[inline]
+            unsafe fn table_fetch(&mut self, _table_row: usize) -> Self::Item {
+                let ($($name,)*) = self;
+                ($($name.table_fetch(_table_row),)*)
+            }
+
+            #[inline]
+            unsafe fn archetype_fetch(&mut self, _archetype_index: usize) -> Self::Item {
+                let ($($name,)*) = self;
+                ($($name.archetype_fetch(_archetype_index),)*)
+            }
+        }
+
+        // SAFE: update_component_access and update_archetype_component_access are called for each item in the tuple
+        #[allow(non_snake_case)]
+        unsafe impl<$($name: FetchState),*> FetchState for ($($name,)*) {
+            fn init(_world: &mut World) -> Self {
+                ($($name::init(_world),)*)
+            }
+
+            fn update_component_access(&self, _access: &mut FilteredAccess<ComponentId>) {
+                let ($($name,)*) = self;
+                $($name.update_component_access(_access);)*
+            }
+
+            fn update_archetype_component_access(&self, _archetype: &Archetype, _access: &mut Access<ArchetypeComponentId>) {
+                let ($($name,)*) = self;
+                $($name.update_archetype_component_access(_archetype, _access);)*
+            }
+
+            fn matches_archetype(&self, _archetype: &Archetype) -> bool {
+                let ($($name,)*) = self;
+                true $(&& $name.matches_archetype(_archetype))*
+            }
+
+            fn matches_table(&self, _table: &Table) -> bool {
+                let ($($name,)*) = self;
+                true $(&& $name.matches_table(_table))*
+            }
+        }
+
+        impl<$($name: WorldQuery),*> WorldQuery for ($($name,)*) {
+            type Fetch = ($($name::Fetch,)*);
+            type State = ($($name::State,)*);
+        }
+
+        /// SAFE: each item in the tuple is read only
+        unsafe impl<$($name: ReadOnlyFetch),*> ReadOnlyFetch for ($($name,)*) {}
+
+    };
+}
+
+all_tuples!(impl_tuple_fetch, 0, 15, F, S);
diff --git a/crates/bevy_ecs/src/query/filter.rs b/crates/bevy_ecs/src/query/filter.rs
new file mode 100644
index 0000000000000..1f9d8c8eeae12
--- /dev/null
+++ b/crates/bevy_ecs/src/query/filter.rs
@@ -0,0 +1,599 @@
+use crate::{
+    archetype::{Archetype, ArchetypeComponentId},
+    bundle::Bundle,
+    component::{Component, ComponentFlags, ComponentId, StorageType},
+    entity::Entity,
+    query::{Access, Fetch, FetchState, FilteredAccess, WorldQuery},
+    storage::{ComponentSparseSet, Table, Tables},
+    world::World,
+};
+use bevy_ecs_macros::all_tuples;
+use std::{marker::PhantomData, ptr};
+
+// TODO: uncomment this and use as shorthand (remove where F::Fetch: FilterFetch everywhere) when this bug is fixed in Rust 1.51:
+// https://github.com/rust-lang/rust/pull/81671
+// pub trait QueryFilter: WorldQuery
+// where
+//     Self::Fetch: FilterFetch,
+// {
+// }
+
+// impl<T: WorldQuery> QueryFilter for T where T::Fetch: FilterFetch {
+// }
+
+/// Fetch methods used by query filters. This trait exists to allow "short circuit" behaviors for relevant query filter fetches.
+pub trait FilterFetch: for<'a> Fetch<'a> {
+    /// # Safety
+    /// Must always be called _after_ [Fetch::set_archetype]. `archetype_index` must be in the range of the current archetype
+    unsafe fn archetype_filter_fetch(&mut self, archetype_index: usize) -> bool;
+
+    /// # Safety
+    /// Must always be called _after_ [Fetch::set_table]. `table_row` must be in the range of the current table
+    unsafe fn table_filter_fetch(&mut self, table_row: usize) -> bool;
+}
+
+impl<T> FilterFetch for T
+where
+    T: for<'a> Fetch<'a, Item = bool>,
+{
+    #[inline]
+    unsafe fn archetype_filter_fetch(&mut self, archetype_index: usize) -> bool {
+        self.archetype_fetch(archetype_index)
+    }
+
+    #[inline]
+    unsafe fn table_filter_fetch(&mut self, table_row: usize) -> bool {
+        self.table_fetch(table_row)
+    }
+}
+
+/// Filter that retrieves components of type `T` that have either been mutated or added since the start of the frame.
+pub struct With<T>(PhantomData<T>);
+
+impl<T: Component> WorldQuery for With<T> {
+    type Fetch = WithFetch<T>;
+    type State = WithState<T>;
+}
+
+pub struct WithFetch<T> {
+    storage_type: StorageType,
+    marker: PhantomData<T>,
+}
+pub struct WithState<T> {
+    component_id: ComponentId,
+    storage_type: StorageType,
+    marker: PhantomData<T>,
+}
+
+// SAFE: no component access or archetype component access
+unsafe impl<T: Component> FetchState for WithState<T> {
+    fn init(world: &mut World) -> Self {
+        let component_info = world.components.get_or_insert_info::<T>();
+        Self {
+            component_id: component_info.id(),
+            storage_type: component_info.storage_type(),
+            marker: PhantomData,
+        }
+    }
+
+    #[inline]
+    fn update_component_access(&self, access: &mut FilteredAccess<ComponentId>) {
+        access.add_with(self.component_id);
+    }
+
+    #[inline]
+    fn update_archetype_component_access(
+        &self,
+        _archetype: &Archetype,
+        _access: &mut Access<ArchetypeComponentId>,
+    ) {
+    }
+
+    fn matches_archetype(&self, archetype: &Archetype) -> bool {
+        archetype.contains(self.component_id)
+    }
+
+    fn matches_table(&self, table: &Table) -> bool {
+        table.has_column(self.component_id)
+    }
+}
+
+impl<'a, T: Component> Fetch<'a> for WithFetch<T> {
+    type Item = bool;
+    type State = WithState<T>;
+
+    unsafe fn init(_world: &World, state: &Self::State) -> Self {
+        Self {
+            storage_type: state.storage_type,
+            marker: PhantomData,
+        }
+    }
+
+    #[inline]
+    fn is_dense(&self) -> bool {
+        self.storage_type == StorageType::Table
+    }
+
+    #[inline]
+    unsafe fn set_table(&mut self, _state: &Self::State, _table: &Table) {}
+
+    #[inline]
+    unsafe fn set_archetype(
+        &mut self,
+        _state: &Self::State,
+        _archetype: &Archetype,
+        _tables: &Tables,
+    ) {
+    }
+
+    #[inline]
+    unsafe fn archetype_fetch(&mut self, _archetype_index: usize) -> Self::Item {
+        true
+    }
+
+    #[inline]
+    unsafe fn table_fetch(&mut self, _table_row: usize) -> bool {
+        true
+    }
+}
+
+/// Filter that retrieves components of type `T` that have either been mutated or added since the start of the frame.
+pub struct Without<T>(PhantomData<T>);
+
+impl<T: Component> WorldQuery for Without<T> {
+    type Fetch = WithoutFetch<T>;
+    type State = WithoutState<T>;
+}
+
+pub struct WithoutFetch<T> {
+    storage_type: StorageType,
+    marker: PhantomData<T>,
+}
+
+pub struct WithoutState<T> {
+    component_id: ComponentId,
+    storage_type: StorageType,
+    marker: PhantomData<T>,
+}
+
+// SAFE: no component access or archetype component access
+unsafe impl<T: Component> FetchState for WithoutState<T> {
+    fn init(world: &mut World) -> Self {
+        let component_info = world.components.get_or_insert_info::<T>();
+        Self {
+            component_id: component_info.id(),
+            storage_type: component_info.storage_type(),
+            marker: PhantomData,
+        }
+    }
+
+    #[inline]
+    fn update_component_access(&self, access: &mut FilteredAccess<ComponentId>) {
+        access.add_without(self.component_id);
+    }
+
+    #[inline]
+    fn update_archetype_component_access(
+        &self,
+        _archetype: &Archetype,
+        _access: &mut Access<ArchetypeComponentId>,
+    ) {
+    }
+
+    fn matches_archetype(&self, archetype: &Archetype) -> bool {
+        !archetype.contains(self.component_id)
+    }
+
+    fn matches_table(&self, table: &Table) -> bool {
+        !table.has_column(self.component_id)
+    }
+}
+
+impl<'a, T: Component> Fetch<'a> for WithoutFetch<T> {
+    type Item = bool;
+    type State = WithoutState<T>;
+
+    unsafe fn init(_world: &World, state: &Self::State) -> Self {
+        Self {
+            storage_type: state.storage_type,
+            marker: PhantomData,
+        }
+    }
+
+    #[inline]
+    fn is_dense(&self) -> bool {
+        self.storage_type == StorageType::Table
+    }
+
+    #[inline]
+    unsafe fn set_table(&mut self, _state: &Self::State, _table: &Table) {}
+
+    #[inline]
+    unsafe fn set_archetype(
+        &mut self,
+        _state: &Self::State,
+        _archetype: &Archetype,
+        _tables: &Tables,
+    ) {
+    }
+
+    #[inline]
+    unsafe fn archetype_fetch(&mut self, _archetype_index: usize) -> bool {
+        true
+    }
+
+    #[inline]
+    unsafe fn table_fetch(&mut self, _table_row: usize) -> bool {
+        true
+    }
+}
+
+pub struct WithBundle<T: Bundle>(PhantomData<T>);
+
+pub struct WithBundleFetch<T: Bundle> {
+    is_dense: bool,
+    marker: PhantomData<T>,
+}
+
+pub struct WithBundleState<T: Bundle> {
+    component_ids: Vec<ComponentId>,
+    is_dense: bool,
+    marker: PhantomData<T>,
+}
+
+// SAFE: no component access or archetype component access
+unsafe impl<T: Bundle> FetchState for WithBundleState<T> {
+    fn init(world: &mut World) -> Self {
+        let bundle_info = world.bundles.init_info::<T>(&mut world.components);
+        let components = &world.components;
+        Self {
+            component_ids: bundle_info.component_ids.clone(),
+            is_dense: !bundle_info.component_ids.iter().any(|id| unsafe {
+                components.get_info_unchecked(*id).storage_type() != StorageType::Table
+            }),
+            marker: PhantomData,
+        }
+    }
+
+    #[inline]
+    fn update_component_access(&self, access: &mut FilteredAccess<ComponentId>) {
+        for component_id in self.component_ids.iter().cloned() {
+            access.add_with(component_id);
+        }
+    }
+
+    #[inline]
+    fn update_archetype_component_access(
+        &self,
+        _archetype: &Archetype,
+        _access: &mut Access<ArchetypeComponentId>,
+    ) {
+    }
+
+    fn matches_archetype(&self, archetype: &Archetype) -> bool {
+        self.component_ids.iter().all(|id| archetype.contains(*id))
+    }
+
+    fn matches_table(&self, table: &Table) -> bool {
+        self.component_ids.iter().all(|id| table.has_column(*id))
+    }
+}
+
+impl<'a, T: Bundle> Fetch<'a> for WithBundleFetch<T> {
+    type Item = bool;
+    type State = WithBundleState<T>;
+
+    unsafe fn init(_world: &World, state: &Self::State) -> Self {
+        Self {
+            is_dense: state.is_dense,
+            marker: PhantomData,
+        }
+    }
+
+    #[inline]
+    fn is_dense(&self) -> bool {
+        self.is_dense
+    }
+
+    #[inline]
+    unsafe fn set_table(&mut self, _state: &Self::State, _table: &Table) {}
+
+    #[inline]
+    unsafe fn set_archetype(
+        &mut self,
+        _state: &Self::State,
+        _archetype: &Archetype,
+        _tables: &Tables,
+    ) {
+    }
+
+    #[inline]
+    unsafe fn archetype_fetch(&mut self, _archetype_index: usize) -> bool {
+        true
+    }
+
+    #[inline]
+    unsafe fn table_fetch(&mut self, _table_row: usize) -> bool {
+        true
+    }
+}
+
+pub struct Or<T>(pub T);
+pub struct OrFetch<T: FilterFetch> {
+    fetch: T,
+    matches: bool,
+}
+
+macro_rules! impl_query_filter_tuple {
+    ($(($filter: ident, $state: ident)),*) => {
+        #[allow(unused_variables)]
+        #[allow(non_snake_case)]
+        impl<'a, $($filter: FilterFetch),*> FilterFetch for ($($filter,)*) {
+            #[inline]
+            unsafe fn table_filter_fetch(&mut self, table_row: usize) -> bool {
+                let ($($filter,)*) = self;
+                true $(&& $filter.table_filter_fetch(table_row))*
+            }
+
+            #[inline]
+            unsafe fn archetype_filter_fetch(&mut self, archetype_index: usize) -> bool {
+                let ($($filter,)*) = self;
+                true $(&& $filter.archetype_filter_fetch(archetype_index))*
+            }
+        }
+
+        impl<$($filter: WorldQuery),*> WorldQuery for Or<($($filter,)*)>
+            where $($filter::Fetch: FilterFetch),*
+        {
+            type Fetch = Or<($(OrFetch<$filter::Fetch>,)*)>;
+            type State = Or<($($filter::State,)*)>;
+        }
+
+
+        #[allow(unused_variables)]
+        #[allow(non_snake_case)]
+        impl<'a, $($filter: FilterFetch),*> Fetch<'a> for Or<($(OrFetch<$filter>,)*)> {
+            type State = Or<($(<$filter as Fetch<'a>>::State,)*)>;
+            type Item = bool;
+
+            unsafe fn init(world: &World, state: &Self::State) -> Self {
+                let ($($filter,)*) = &state.0;
+                Or(($(OrFetch {
+                    fetch: $filter::init(world, $filter),
+                    matches: false,
+                },)*))
+            }
+
+            #[inline]
+            fn is_dense(&self) -> bool {
+                let ($($filter,)*) = &self.0;
+                true $(&& $filter.fetch.is_dense())*
+            }
+
+            #[inline]
+            unsafe fn set_table(&mut self, state: &Self::State, table: &Table) {
+                let ($($filter,)*) = &mut self.0;
+                let ($($state,)*) = &state.0;
+                $(
+                    $filter.matches = $state.matches_table(table);
+                    if $filter.matches {
+                        $filter.fetch.set_table($state, table);
+                    }
+                )*
+            }
+
+            #[inline]
+            unsafe fn set_archetype(&mut self, state: &Self::State, archetype: &Archetype, tables: &Tables) {
+                let ($($filter,)*) = &mut self.0;
+                let ($($state,)*) = &state.0;
+                $(
+                    $filter.matches = $state.matches_archetype(archetype);
+                    if $filter.matches {
+                        $filter.fetch.set_archetype($state, archetype, tables);
+                    }
+                )*
+            }
+
+            #[inline]
+            unsafe fn table_fetch(&mut self, table_row: usize) -> bool {
+                let ($($filter,)*) = &mut self.0;
+                false $(|| ($filter.matches && $filter.fetch.table_filter_fetch(table_row)))*
+            }
+
+            #[inline]
+            unsafe fn archetype_fetch(&mut self, archetype_index: usize) -> bool {
+                let ($($filter,)*) = &mut self.0;
+                false $(|| ($filter.matches && $filter.fetch.archetype_filter_fetch(archetype_index)))*
+            }
+        }
+
+        // SAFE: update_component_access and update_archetype_component_access are called for each item in the tuple
+        #[allow(unused_variables)]
+        #[allow(non_snake_case)]
+        unsafe impl<$($filter: FetchState),*> FetchState for Or<($($filter,)*)> {
+            fn init(world: &mut World) -> Self {
+                Or(($($filter::init(world),)*))
+            }
+
+            fn update_component_access(&self, access: &mut FilteredAccess<ComponentId>) {
+                let ($($filter,)*) = &self.0;
+                $($filter.update_component_access(access);)*
+            }
+
+            fn update_archetype_component_access(&self, archetype: &Archetype, access: &mut Access<ArchetypeComponentId>) {
+                let ($($filter,)*) = &self.0;
+                $($filter.update_archetype_component_access(archetype, access);)*
+            }
+
+            fn matches_archetype(&self, archetype: &Archetype) -> bool {
+                let ($($filter,)*) = &self.0;
+                false $(|| $filter.matches_archetype(archetype))*
+            }
+
+            fn matches_table(&self, table: &Table) -> bool {
+                let ($($filter,)*) = &self.0;
+                false $(|| $filter.matches_table(table))*
+            }
+        }
+    };
+}
+
+all_tuples!(impl_query_filter_tuple, 0, 15, F, S);
+
+macro_rules! impl_flag_filter {
+    (
+        $(#[$meta:meta])*
+        $name: ident, $state_name: ident, $fetch_name: ident, $($flags: expr),+) => {
+        $(#[$meta])*
+        pub struct $name<T>(PhantomData<T>);
+
+        pub struct $fetch_name<T> {
+            storage_type: StorageType,
+            table_flags: *mut ComponentFlags,
+            entity_table_rows: *const usize,
+            marker: PhantomData<T>,
+            entities: *const Entity,
+            sparse_set: *const ComponentSparseSet,
+        }
+
+        pub struct $state_name<T> {
+            component_id: ComponentId,
+            storage_type: StorageType,
+            marker: PhantomData<T>,
+        }
+
+        impl<T: Component> WorldQuery for $name<T> {
+            type Fetch = $fetch_name<T>;
+            type State = $state_name<T>;
+        }
+
+
+        // SAFE: this reads the T component. archetype component access and component access are updated to reflect that
+        unsafe impl<T: Component> FetchState for $state_name<T> {
+            fn init(world: &mut World) -> Self {
+                let component_info = world.components.get_or_insert_info::<T>();
+                Self {
+                    component_id: component_info.id(),
+                    storage_type: component_info.storage_type(),
+                    marker: PhantomData,
+                }
+            }
+
+            #[inline]
+            fn update_component_access(&self, access: &mut FilteredAccess<ComponentId>) {
+                access.add_read(self.component_id);
+            }
+
+            #[inline]
+            fn update_archetype_component_access(
+                &self,
+                archetype: &Archetype,
+                access: &mut Access<ArchetypeComponentId>,
+            ) {
+                if let Some(archetype_component_id) = archetype.get_archetype_component_id(self.component_id) {
+                    access.add_read(archetype_component_id);
+                }
+            }
+
+            fn matches_archetype(&self, archetype: &Archetype) -> bool {
+                archetype.contains(self.component_id)
+            }
+
+            fn matches_table(&self, table: &Table) -> bool {
+                table.has_column(self.component_id)
+            }
+        }
+
+        impl<'a, T: Component> Fetch<'a> for $fetch_name<T> {
+            type State = $state_name<T>;
+            type Item = bool;
+
+            unsafe fn init(world: &World, state: &Self::State) -> Self {
+                let mut value = Self {
+                    storage_type: state.storage_type,
+                    table_flags: ptr::null_mut::<ComponentFlags>(),
+                    entities: ptr::null::<Entity>(),
+                    entity_table_rows: ptr::null::<usize>(),
+                    sparse_set: ptr::null::<ComponentSparseSet>(),
+                    marker: PhantomData,
+                };
+                if state.storage_type == StorageType::SparseSet {
+                    value.sparse_set = world
+                        .storages()
+                        .sparse_sets
+                        .get(state.component_id).unwrap();
+                }
+                value
+            }
+
+            #[inline]
+            fn is_dense(&self) -> bool {
+                self.storage_type == StorageType::Table
+            }
+
+            unsafe fn set_table(&mut self, state: &Self::State, table: &Table) {
+                self.table_flags = table
+                    .get_column(state.component_id).unwrap()
+                    .get_flags_mut_ptr();
+            }
+
+            unsafe fn set_archetype(&mut self, state: &Self::State, archetype: &Archetype, tables: &Tables) {
+                match state.storage_type {
+                    StorageType::Table => {
+                        self.entity_table_rows = archetype.entity_table_rows().as_ptr();
+                        // SAFE: archetype tables always exist
+                        let table = tables.get_unchecked(archetype.table_id());
+                        self.table_flags = table
+                            .get_column(state.component_id).unwrap()
+                            .get_flags_mut_ptr();
+                    }
+                    StorageType::SparseSet => self.entities = archetype.entities().as_ptr(),
+                }
+            }
+
+            unsafe fn table_fetch(&mut self, table_row: usize) -> bool {
+                false $(|| (*self.table_flags.add(table_row)).contains($flags))+
+            }
+
+            unsafe fn archetype_fetch(&mut self, archetype_index: usize) -> bool {
+                match self.storage_type {
+                    StorageType::Table => {
+                        let table_row = *self.entity_table_rows.add(archetype_index);
+                        false $(|| (*self.table_flags.add(table_row)).contains($flags))+
+                    }
+                    StorageType::SparseSet => {
+                        let entity = *self.entities.add(archetype_index);
+                        let flags = (*(*self.sparse_set).get_flags(entity).unwrap());
+                        false $(|| flags.contains($flags))+
+                    }
+                }
+            }
+        }
+    };
+}
+
+impl_flag_filter!(
+    /// Filter that retrieves components of type `T` that have been added since the start of the frame
+    Added,
+    AddedState,
+    AddedFetch,
+    ComponentFlags::ADDED
+);
+
+impl_flag_filter!(
+    /// Filter that retrieves components of type `T` that have been mutated since the start of the frame.
+    /// Added components do not count as mutated.
+    Mutated,
+    MutatedState,
+    MutatedFetch,
+    ComponentFlags::MUTATED
+);
+
+impl_flag_filter!(
+    /// Filter that retrieves components of type `T` that have been added or mutated since the start of the frame
+    Changed,
+    ChangedState,
+    ChangedFetch,
+    ComponentFlags::ADDED,
+    ComponentFlags::MUTATED
+);
diff --git a/crates/bevy_ecs/src/query/iter.rs b/crates/bevy_ecs/src/query/iter.rs
new file mode 100644
index 0000000000000..9a38d9135d883
--- /dev/null
+++ b/crates/bevy_ecs/src/query/iter.rs
@@ -0,0 +1,131 @@
+use crate::{
+    archetype::{ArchetypeId, Archetypes},
+    query::{Fetch, FilterFetch, QueryState, WorldQuery},
+    storage::{TableId, Tables},
+    world::World,
+};
+
+pub struct QueryIter<'w, 's, Q: WorldQuery, F: WorldQuery>
+where
+    F::Fetch: FilterFetch,
+{
+    tables: &'w Tables,
+    archetypes: &'w Archetypes,
+    query_state: &'s QueryState<Q, F>,
+    world: &'w World,
+    table_id_iter: std::slice::Iter<'s, TableId>,
+    archetype_id_iter: std::slice::Iter<'s, ArchetypeId>,
+    fetch: Q::Fetch,
+    filter: F::Fetch,
+    is_dense: bool,
+    current_len: usize,
+    current_index: usize,
+}
+
+impl<'w, 's, Q: WorldQuery, F: WorldQuery> QueryIter<'w, 's, Q, F>
+where
+    F::Fetch: FilterFetch,
+{
+    pub(crate) unsafe fn new(world: &'w World, query_state: &'s QueryState<Q, F>) -> Self {
+        let fetch = <Q::Fetch as Fetch>::init(world, &query_state.fetch_state);
+        let filter = <F::Fetch as Fetch>::init(world, &query_state.filter_state);
+        QueryIter {
+            is_dense: fetch.is_dense() && filter.is_dense(),
+            world,
+            query_state,
+            fetch,
+            filter,
+            tables: &world.storages().tables,
+            archetypes: &world.archetypes,
+            table_id_iter: query_state.matched_table_ids.iter(),
+            archetype_id_iter: query_state.matched_archetype_ids.iter(),
+            current_len: 0,
+            current_index: 0,
+        }
+    }
+}
+
+impl<'w, 's, Q: WorldQuery, F: WorldQuery> Iterator for QueryIter<'w, 's, Q, F>
+where
+    F::Fetch: FilterFetch,
+{
+    type Item = <Q::Fetch as Fetch<'w>>::Item;
+
+    #[inline]
+    fn next(&mut self) -> Option<Self::Item> {
+        unsafe {
+            if self.is_dense {
+                loop {
+                    if self.current_index == self.current_len {
+                        let table_id = self.table_id_iter.next()?;
+                        let table = self.tables.get_unchecked(*table_id);
+                        self.fetch.set_table(&self.query_state.fetch_state, table);
+                        self.filter.set_table(&self.query_state.filter_state, table);
+                        self.current_len = table.len();
+                        self.current_index = 0;
+                        continue;
+                    }
+
+                    if !self.filter.table_filter_fetch(self.current_index) {
+                        self.current_index += 1;
+                        continue;
+                    }
+
+                    let item = self.fetch.table_fetch(self.current_index);
+
+                    self.current_index += 1;
+                    return Some(item);
+                }
+            } else {
+                loop {
+                    if self.current_index == self.current_len {
+                        let archetype_id = self.archetype_id_iter.next()?;
+                        let archetype = self.archetypes.get_unchecked(*archetype_id);
+                        self.fetch.set_archetype(
+                            &self.query_state.fetch_state,
+                            archetype,
+                            self.tables,
+                        );
+                        self.filter.set_archetype(
+                            &self.query_state.filter_state,
+                            archetype,
+                            self.tables,
+                        );
+                        self.current_len = archetype.len();
+                        self.current_index = 0;
+                        continue;
+                    }
+
+                    if !self.filter.archetype_filter_fetch(self.current_index) {
+                        self.current_index += 1;
+                        continue;
+                    }
+
+                    let item = self.fetch.archetype_fetch(self.current_index);
+                    self.current_index += 1;
+                    return Some(item);
+                }
+            }
+        }
+    }
+}
+
+// NOTE: We can cheaply implement this for unfiltered Queries because we have:
+// (1) pre-computed archetype matches
+// (2) each archetype pre-computes length
+// (3) there are no per-entity filters
+// TODO: add an ArchetypeOnlyFilter that enables us to implement this for filters like With<T>
+impl<'w, 's, Q: WorldQuery> ExactSizeIterator for QueryIter<'w, 's, Q, ()> {
+    fn len(&self) -> usize {
+        self.query_state
+            .matched_archetypes
+            .ones()
+            .map(|index| {
+                // SAFE: matched archetypes always exist
+                let archetype =
+                    unsafe { self.world.archetypes.get_unchecked(ArchetypeId::new(index)) };
+                archetype.len()
+            })
+            .sum()
+    }
+}
diff --git a/crates/bevy_ecs/src/query/mod.rs b/crates/bevy_ecs/src/query/mod.rs
new file mode 100644
index 0000000000000..95b4d7b6e8912
--- /dev/null
+++ b/crates/bevy_ecs/src/query/mod.rs
@@ -0,0 +1,60 @@
+mod access;
+mod fetch;
+mod filter;
+mod iter;
+mod state;
+
+pub use access::*;
+pub use fetch::*;
+pub use filter::*;
+pub use iter::*;
+pub use state::*;
+
+#[cfg(test)]
+mod tests {
+    use crate::{
+        component::{ComponentDescriptor, StorageType},
+        world::World,
+    };
+
+    #[derive(Debug, Eq, PartialEq)]
+    struct A(usize);
+    #[derive(Debug, Eq, PartialEq)]
+    struct B(usize);
+
+    #[test]
+    fn query() {
+        let mut world = World::new();
+        world.spawn().insert_bundle((A(1), B(1)));
+        world.spawn().insert_bundle((A(2),));
+        let values = world.query::<&A>().iter(&world).collect::<Vec<&A>>();
+        assert_eq!(values, vec![&A(1), &A(2)]);
+
+        for (_a, mut b) in world.query::<(&A, &mut B)>().iter_mut(&mut world) {
+            b.0 = 3;
+        }
+        let values = world.query::<&B>().iter(&world).collect::<Vec<&B>>();
+        assert_eq!(values, vec![&B(3)]);
+    }
+
+    #[test]
+    fn multi_storage_query() {
+        let mut world = World::new();
+        world
+            .register_component(ComponentDescriptor::new::<A>(StorageType::SparseSet))
+            .unwrap();
+
+        world.spawn().insert_bundle((A(1), B(2)));
+        world.spawn().insert_bundle((A(2),));
+
+        let values = world.query::<&A>().iter(&world).collect::<Vec<&A>>();
+        assert_eq!(values, vec![&A(1), &A(2)]);
+
+        for (_a, mut b) in world.query::<(&A, &mut B)>().iter_mut(&mut world) {
+            b.0 = 3;
+        }
+
+        let values = world.query::<&B>().iter(&world).collect::<Vec<&B>>();
+        assert_eq!(values, vec![&B(3)]);
+    }
+}
diff --git a/crates/bevy_ecs/src/query/state.rs b/crates/bevy_ecs/src/query/state.rs
new file mode 100644
index 0000000000000..b87fc7c637dc6
--- /dev/null
+++ b/crates/bevy_ecs/src/query/state.rs
@@ -0,0 +1,420 @@
+use crate::{
+    archetype::{Archetype, ArchetypeComponentId, ArchetypeGeneration, ArchetypeId},
+    component::ComponentId,
+    entity::Entity,
+    query::{
+        Access, Fetch, FetchState, FilterFetch, FilteredAccess, QueryIter, ReadOnlyFetch,
+        WorldQuery,
+    },
+    storage::TableId,
+    world::{World, WorldId},
+};
+use bevy_tasks::TaskPool;
+use fixedbitset::FixedBitSet;
+use thiserror::Error;
+
+pub struct QueryState<Q: WorldQuery, F: WorldQuery = ()>
+where
+    F::Fetch: FilterFetch,
+{
+    world_id: WorldId,
+    pub(crate) archetype_generation: ArchetypeGeneration,
+    pub(crate) matched_tables: FixedBitSet,
+    pub(crate) matched_archetypes: FixedBitSet,
+    pub(crate) archetype_component_access: Access<ArchetypeComponentId>,
+    pub(crate) component_access: FilteredAccess<ComponentId>,
+    // NOTE: we maintain both a TableId bitset and a vec because iterating the vec is faster
+    pub(crate) matched_table_ids: Vec<TableId>,
+    // NOTE: we maintain both a ArchetypeId bitset and a vec because iterating the vec is faster
+    pub(crate) matched_archetype_ids: Vec<ArchetypeId>,
+    pub(crate) fetch_state: Q::State,
+    pub(crate) filter_state: F::State,
+}
+
+impl<Q: WorldQuery, F: WorldQuery> QueryState<Q, F>
+where
+    F::Fetch: FilterFetch,
+{
+    pub fn new(world: &mut World) -> Self {
+        let fetch_state = <Q::State as FetchState>::init(world);
+        let filter_state = <F::State as FetchState>::init(world);
+        let mut component_access = Default::default();
+        fetch_state.update_component_access(&mut component_access);
+        filter_state.update_component_access(&mut component_access);
+        let mut state = Self {
+            world_id: world.id(),
+            archetype_generation: ArchetypeGeneration::new(usize::MAX),
+            matched_table_ids: Vec::new(),
+            matched_archetype_ids: Vec::new(),
+            fetch_state,
+            filter_state,
+            component_access,
+            matched_tables: Default::default(),
+            matched_archetypes: Default::default(),
+            archetype_component_access: Default::default(),
+        };
+        state.validate_world_and_update_archetypes(world);
+        state
+    }
+
+    pub fn validate_world_and_update_archetypes(&mut self, world: &World) {
+        if world.id() != self.world_id {
+            panic!("Attempted to use {} with a mismatched World. QueryStates can only be used with the World they were created from.",
+                std::any::type_name::<Self>());
+        }
+        let archetypes = world.archetypes();
+        let old_generation = self.archetype_generation;
+        let archetype_index_range = if old_generation == archetypes.generation() {
+            0..0
+        } else {
+            self.archetype_generation = archetypes.generation();
+            if old_generation.value() == usize::MAX {
+                0..archetypes.len()
+            } else {
+                old_generation.value()..archetypes.len()
+            }
+        };
+        for archetype_index in archetype_index_range {
+            // SAFE: archetype indices less than the archetype generation are guaranteed to exist
+            let archetype = unsafe { archetypes.get_unchecked(ArchetypeId::new(archetype_index)) };
+            self.new_archetype(archetype);
+        }
+    }
+
+    pub fn new_archetype(&mut self, archetype: &Archetype) {
+        let table_index = archetype.table_id().index();
+        if self.fetch_state.matches_archetype(archetype)
+            && self.filter_state.matches_archetype(archetype)
+        {
+            self.fetch_state
+                .update_archetype_component_access(archetype, &mut self.archetype_component_access);
+            self.filter_state
+                .update_archetype_component_access(archetype, &mut self.archetype_component_access);
+            self.matched_archetypes.grow(archetype.id().index() + 1);
+            self.matched_archetypes.set(archetype.id().index(), true);
+            self.matched_archetype_ids.push(archetype.id());
+            if !self.matched_tables.contains(table_index) {
+                self.matched_tables.grow(table_index + 1);
+                self.matched_tables.set(table_index, true);
+                self.matched_table_ids.push(archetype.table_id());
+            }
+        }
+    }
+
+    #[inline]
+    pub fn get<'w>(
+        &mut self,
+        world: &'w World,
+        entity: Entity,
+    ) -> Result<<Q::Fetch as Fetch<'w>>::Item, QueryEntityError>
+    where
+        Q::Fetch: ReadOnlyFetch,
+    {
+        // SAFE: query is read only
+        unsafe { self.get_unchecked(world, entity) }
+    }
+
+    #[inline]
+    pub fn get_mut<'w>(
+        &mut self,
+        world: &'w mut World,
+        entity: Entity,
+    ) -> Result<<Q::Fetch as Fetch<'w>>::Item, QueryEntityError> {
+        // SAFE: query has unique world access
+        unsafe { self.get_unchecked(world, entity) }
+    }
+
+    /// # Safety
+    /// This does not check for mutable query correctness. To be safe, make sure mutable queries
+    /// have unique access to the components they query.
+    #[inline]
+    pub unsafe fn get_unchecked<'w>(
+        &mut self,
+        world: &'w World,
+        entity: Entity,
+    ) -> Result<<Q::Fetch as Fetch<'w>>::Item, QueryEntityError> {
+        self.validate_world_and_update_archetypes(world);
+        self.get_unchecked_manual(world, entity)
+    }
+
+    /// # Safety
+    /// This does not check for mutable query correctness. To be safe, make sure mutable queries
+    /// have unique access to the components they query.
+    pub unsafe fn get_unchecked_manual<'w>(
+        &self,
+        world: &'w World,
+        entity: Entity,
+    ) -> Result<<Q::Fetch as Fetch<'w>>::Item, QueryEntityError> {
+        let location = world
+            .entities
+            .get(entity)
+            .ok_or(QueryEntityError::NoSuchEntity)?;
+        if !self
+            .matched_archetypes
+            .contains(location.archetype_id.index())
+        {
+            return Err(QueryEntityError::QueryDoesNotMatch);
+        }
+        // SAFE: live entities always exist in an archetype
+        let archetype = world.archetypes.get_unchecked(location.archetype_id);
+        let mut fetch = <Q::Fetch as Fetch>::init(world, &self.fetch_state);
+        let mut filter = <F::Fetch as Fetch>::init(world, &self.filter_state);
+
+        fetch.set_archetype(&self.fetch_state, archetype, &world.storages().tables);
+        filter.set_archetype(&self.filter_state, archetype, &world.storages().tables);
+        if filter.archetype_filter_fetch(location.index) {
+            Ok(fetch.archetype_fetch(location.index))
+        } else {
+            Err(QueryEntityError::QueryDoesNotMatch)
+        }
+    }
+
+    #[inline]
+    pub fn iter<'w, 's>(&'s mut self, world: &'w World) -> QueryIter<'w, 's, Q, F>
+    where
+        Q::Fetch: ReadOnlyFetch,
+    {
+        // SAFE: query is read only
+        unsafe { self.iter_unchecked(world) }
+    }
+
+    #[inline]
+    pub fn iter_mut<'w, 's>(&'s mut self, world: &'w mut World) -> QueryIter<'w, 's, Q, F> {
+        // SAFE: query has unique world access
+        unsafe { self.iter_unchecked(world) }
+    }
+
+    /// # Safety
+    /// This does not check for mutable query correctness. To be safe, make sure mutable queries
+    /// have unique access to the components they query.
+    #[inline]
+    pub unsafe fn iter_unchecked<'w, 's>(
+        &'s mut self,
+        world: &'w World,
+    ) -> QueryIter<'w, 's, Q, F> {
+        self.validate_world_and_update_archetypes(world);
+        self.iter_unchecked_manual(world)
+    }
+
+    /// # Safety
+    /// This does not check for mutable query correctness. To be safe, make sure mutable queries
+    /// have unique access to the components they query.
+    /// This does not validate that `world.id()` matches `self.world_id`. Calling this on a `world` with
+    /// a mismatched WorldId is unsafe.
+    #[inline]
+    pub(crate) unsafe fn iter_unchecked_manual<'w, 's>(
+        &'s self,
+        world: &'w World,
+    ) -> QueryIter<'w, 's, Q, F> {
+        QueryIter::new(world, self)
+    }
+
+    #[inline]
+    pub fn for_each<'w>(
+        &mut self,
+        world: &'w World,
+        func: impl FnMut(<Q::Fetch as Fetch<'w>>::Item),
+    ) where
+        Q::Fetch: ReadOnlyFetch,
+    {
+        // SAFE: query is read only
+        unsafe {
+            self.for_each_unchecked(world, func);
+        }
+    }
+
+    #[inline]
+    pub fn for_each_mut<'w>(
+        &mut self,
+        world: &'w mut World,
+        func: impl FnMut(<Q::Fetch as Fetch<'w>>::Item),
+    ) {
+        // SAFE: query has unique world access
+        unsafe {
+            self.for_each_unchecked(world, func);
+        }
+    }
+
+    /// # Safety
+    /// This does not check for mutable query correctness. To be safe, make sure mutable queries
+    /// have unique access to the components they query.
+    #[inline]
+    pub unsafe fn for_each_unchecked<'w>(
+        &mut self,
+        world: &'w World,
+        func: impl FnMut(<Q::Fetch as Fetch<'w>>::Item),
+    ) {
+        self.validate_world_and_update_archetypes(world);
+        self.for_each_unchecked_manual(world, func);
+    }
+
+    #[inline]
+    pub fn par_for_each<'w>(
+        &mut self,
+        world: &'w World,
+        task_pool: &TaskPool,
+        batch_size: usize,
+        func: impl Fn(<Q::Fetch as Fetch<'w>>::Item) + Send + Sync + Clone,
+    ) where
+        Q::Fetch: ReadOnlyFetch,
+    {
+        // SAFE: query is read only
+        unsafe {
+            self.par_for_each_unchecked(world, task_pool, batch_size, func);
+        }
+    }
+
+    #[inline]
+    pub fn par_for_each_mut<'w>(
+        &mut self,
+        world: &'w mut World,
+        task_pool: &TaskPool,
+        batch_size: usize,
+        func: impl Fn(<Q::Fetch as Fetch<'w>>::Item) + Send + Sync + Clone,
+    ) {
+        // SAFE: query has unique world access
+        unsafe {
+            self.par_for_each_unchecked(world, task_pool, batch_size, func);
+        }
+    }
+
+    /// # Safety
+    /// This does not check for mutable query correctness. To be safe, make sure mutable queries
+    /// have unique access to the components they query.
+    #[inline]
+    pub unsafe fn par_for_each_unchecked<'w>(
+        &mut self,
+        world: &'w World,
+        task_pool: &TaskPool,
+        batch_size: usize,
+        func: impl Fn(<Q::Fetch as Fetch<'w>>::Item) + Send + Sync + Clone,
+    ) {
+        self.validate_world_and_update_archetypes(world);
+        self.par_for_each_unchecked_manual(world, task_pool, batch_size, func);
+    }
+
+    /// # Safety
+    /// This does not check for mutable query correctness. To be safe, make sure mutable queries
+    /// have unique access to the components they query.
+    /// This does not validate that `world.id()` matches `self.world_id`. Calling this on a `world` with
+    /// a mismatched WorldId is unsafe.
+    pub(crate) unsafe fn for_each_unchecked_manual<'w, 's>(
+        &'s self,
+        world: &'w World,
+        mut func: impl FnMut(<Q::Fetch as Fetch<'w>>::Item),
+    ) {
+        let mut fetch = <Q::Fetch as Fetch>::init(world, &self.fetch_state);
+        let mut filter = <F::Fetch as Fetch>::init(world, &self.filter_state);
+        if fetch.is_dense() && filter.is_dense() {
+            let tables = &world.storages().tables;
+            for table_id in self.matched_table_ids.iter() {
+                let table = tables.get_unchecked(*table_id);
+                fetch.set_table(&self.fetch_state, table);
+                filter.set_table(&self.filter_state, table);
+
+                for table_index in 0..table.len() {
+                    if !filter.table_filter_fetch(table_index) {
+                        continue;
+                    }
+                    let item = fetch.table_fetch(table_index);
+                    func(item);
+                }
+            }
+        } else {
+            let archetypes = &world.archetypes;
+            let tables = &world.storages().tables;
+            for archetype_id in self.matched_archetype_ids.iter() {
+                let archetype = archetypes.get_unchecked(*archetype_id);
+                fetch.set_archetype(&self.fetch_state, archetype, tables);
+                filter.set_archetype(&self.filter_state, archetype, tables);
+
+                for archetype_index in 0..archetype.len() {
+                    if !filter.archetype_filter_fetch(archetype_index) {
+                        continue;
+                    }
+                    func(fetch.archetype_fetch(archetype_index));
+                }
+            }
+        }
+    }
+
+    /// # Safety
+    /// This does not check for mutable query correctness. To be safe, make sure mutable queries
+    /// have unique access to the components they query.
+    /// This does not validate that `world.id()` matches `self.world_id`. Calling this on a `world` with
+    /// a mismatched WorldId is unsafe.
+    pub unsafe fn par_for_each_unchecked_manual<'w, 's>(
+        &'s self,
+        world: &'w World,
+        task_pool: &TaskPool,
+        batch_size: usize,
+        func: impl Fn(<Q::Fetch as Fetch<'w>>::Item) + Send + Sync + Clone,
+    ) {
+        task_pool.scope(|scope| {
+            let fetch = <Q::Fetch as Fetch>::init(world, &self.fetch_state);
+            let filter = <F::Fetch as Fetch>::init(world, &self.filter_state);
+
+            if fetch.is_dense() && filter.is_dense() {
+                let tables = &world.storages().tables;
+                for table_id in self.matched_table_ids.iter() {
+                    let table = tables.get_unchecked(*table_id);
+                    let mut offset = 0;
+                    while offset < table.len() {
+                        let func = func.clone();
+                        scope.spawn(async move {
+                            let mut fetch = <Q::Fetch as Fetch>::init(world, &self.fetch_state);
+                            let mut filter = <F::Fetch as Fetch>::init(world, &self.filter_state);
+                            let tables = &world.storages().tables;
+                            let table = tables.get_unchecked(*table_id);
+                            fetch.set_table(&self.fetch_state, table);
+                            filter.set_table(&self.filter_state, table);
+                            let len = batch_size.min(table.len() - offset);
+                            for table_index in offset..offset + len {
+                                if !filter.table_filter_fetch(table_index) {
+                                    continue;
+                                }
+                                let item = fetch.table_fetch(table_index);
+                                func(item);
+                            }
+                        });
+                        offset += batch_size;
+                    }
+                }
+            } else {
+                let archetypes = &world.archetypes;
+                for archetype_id in self.matched_archetype_ids.iter() {
+                    let mut offset = 0;
+                    let archetype = archetypes.get_unchecked(*archetype_id);
+                    while offset < archetype.len() {
+                        let func = func.clone();
+                        scope.spawn(async move {
+                            let mut fetch = <Q::Fetch as Fetch>::init(world, &self.fetch_state);
+                            let mut filter = <F::Fetch as Fetch>::init(world, &self.filter_state);
+                            let tables = &world.storages().tables;
+                            let archetype = world.archetypes.get_unchecked(*archetype_id);
+                            fetch.set_archetype(&self.fetch_state, archetype, tables);
+                            filter.set_archetype(&self.filter_state, archetype, tables);
+
+                            for archetype_index in 0..archetype.len() {
+                                if !filter.archetype_filter_fetch(archetype_index) {
+                                    continue;
+                                }
+                                func(fetch.archetype_fetch(archetype_index));
+                            }
+                        });
+                        offset += batch_size;
+                    }
+                }
+            }
+        });
+    }
+}
+
+/// An error that occurs when retrieving a specific [Entity]'s query result.
+#[derive(Error, Debug)]
+pub enum QueryEntityError {
+    #[error("The given entity does not have the requested component.")]
+    QueryDoesNotMatch,
+    #[error("The requested entity does not exist.")]
+    NoSuchEntity,
+}
diff --git a/crates/bevy_ecs/src/reflect.rs b/crates/bevy_ecs/src/reflect.rs
new file mode 100644
index 0000000000000..c2a462027feee
--- /dev/null
+++ b/crates/bevy_ecs/src/reflect.rs
@@ -0,0 +1,165 @@
+use std::ops::{Deref, DerefMut};
+
+use crate::{
+    component::{Component, ComponentFlags},
+    entity::{Entity, EntityMap, MapEntities, MapEntitiesError},
+    world::{FromWorld, World},
+};
+use bevy_reflect::{impl_reflect_value, FromType, Reflect, ReflectDeserialize};
+
+#[derive(Clone)]
+pub struct ReflectComponent {
+    add_component: fn(&mut World, Entity, &dyn Reflect),
+    apply_component: fn(&mut World, Entity, &dyn Reflect),
+    reflect_component: fn(&World, Entity) -> Option<&dyn Reflect>,
+    reflect_component_mut: unsafe fn(&World, Entity) -> Option<ReflectMut>,
+    copy_component: fn(&World, &mut World, Entity, Entity),
+}
+
+impl ReflectComponent {
+    pub fn add_component(&self, world: &mut World, entity: Entity, component: &dyn Reflect) {
+        (self.add_component)(world, entity, component);
+    }
+
+    pub fn apply_component(&self, world: &mut World, entity: Entity, component: &dyn Reflect) {
+        (self.apply_component)(world, entity, component);
+    }
+
+    pub fn reflect_component<'a>(
+        &self,
+        world: &'a World,
+        entity: Entity,
+    ) -> Option<&'a dyn Reflect> {
+        (self.reflect_component)(world, entity)
+    }
+
+    pub fn reflect_component_mut<'a>(
+        &self,
+        world: &'a mut World,
+        entity: Entity,
+    ) -> Option<ReflectMut<'a>> {
+        // SAFE: unique world access
+        unsafe { (self.reflect_component_mut)(world, entity) }
+    }
+
+    /// # Safety
+    /// This method does not prevent you from having two mutable pointers to the same data, violating Rust's aliasing rules. To avoid this:
+    /// * Only call this method in an exclusive system to avoid sharing across threads (or use a scheduler that enforces safe memory access).
+    /// * Don't call this method more than once in the same scope for a given component.
+    pub unsafe fn reflect_component_unchecked_mut<'a>(
+        &self,
+        world: &'a World,
+        entity: Entity,
+    ) -> Option<ReflectMut<'a>> {
+        (self.reflect_component_mut)(world, entity)
+    }
+
+    pub fn copy_component(
+        &self,
+        source_world: &World,
+        destination_world: &mut World,
+        source_entity: Entity,
+        destination_entity: Entity,
+    ) {
+        (self.copy_component)(
+            source_world,
+            destination_world,
+            source_entity,
+            destination_entity,
+        );
+    }
+}
+
+impl<C: Component + Reflect + FromWorld> FromType<C> for ReflectComponent {
+    fn from_type() -> Self {
+        ReflectComponent {
+            add_component: |world, entity, reflected_component| {
+                let mut component = C::from_world(world);
+                component.apply(reflected_component);
+                world.entity_mut(entity).insert(component);
+            },
+            apply_component: |world, entity, reflected_component| {
+                let mut component = world.get_mut::<C>(entity).unwrap();
+                component.apply(reflected_component);
+            },
+            copy_component: |source_world, destination_world, source_entity, destination_entity| {
+                let source_component = source_world.get::<C>(source_entity).unwrap();
+                let mut destination_component = C::from_world(destination_world);
+                destination_component.apply(source_component);
+                destination_world
+                    .entity_mut(destination_entity)
+                    .insert(destination_component);
+            },
+            reflect_component: |world, entity| {
+                world
+                    .get_entity(entity)?
+                    .get::<C>()
+                    .map(|c| c as &dyn Reflect)
+            },
+            reflect_component_mut: |world, entity| unsafe {
+                world
+                    .get_entity(entity)?
+                    .get_unchecked_mut::<C>()
+                    .map(|c| ReflectMut {
+                        value: c.value as &mut dyn Reflect,
+                        flags: c.flags,
+                    })
+            },
+        }
+    }
+}
+
+/// Unique borrow of a Reflected component
+pub struct ReflectMut<'a> {
+    pub(crate) value: &'a mut dyn Reflect,
+    pub(crate) flags: &'a mut ComponentFlags,
+}
+
+impl<'a> Deref for ReflectMut<'a> {
+    type Target = dyn Reflect;
+
+    #[inline]
+    fn deref(&self) -> &dyn Reflect {
+        self.value
+    }
+}
+
+impl<'a> DerefMut for ReflectMut<'a> {
+    #[inline]
+    fn deref_mut(&mut self) -> &mut dyn Reflect {
+        self.flags.insert(ComponentFlags::MUTATED);
+        self.value
+    }
+}
+
+impl_reflect_value!(Entity(Hash, PartialEq, Serialize, Deserialize));
+
+#[derive(Clone)]
+pub struct ReflectMapEntities {
+    map_entities: fn(&mut World, &EntityMap) -> Result<(), MapEntitiesError>,
+}
+
+impl ReflectMapEntities {
+    pub fn map_entities(
+        &self,
+        world: &mut World,
+        entity_map: &EntityMap,
+    ) -> Result<(), MapEntitiesError> {
+        (self.map_entities)(world, entity_map)
+    }
+}
+
+impl<C: Component + MapEntities> FromType<C> for ReflectMapEntities {
+    fn from_type() -> Self {
+        ReflectMapEntities {
+            map_entities: |world, entity_map| {
+                for entity in entity_map.values() {
+                    if let Some(mut component) = world.get_mut::<C>(entity) {
+                        component.map_entities(entity_map)?;
+                    }
+                }
+                Ok(())
+            },
+        }
+    }
+}
diff --git a/crates/bevy_ecs/src/resource/mod.rs b/crates/bevy_ecs/src/resource/mod.rs
deleted file mode 100644
index cf4d3f75413a5..0000000000000
--- a/crates/bevy_ecs/src/resource/mod.rs
+++ /dev/null
@@ -1,5 +0,0 @@
-mod resource_query;
-mod resources;
-
-pub use resource_query::*;
-pub use resources::*;
diff --git a/crates/bevy_ecs/src/resource/resource_query.rs b/crates/bevy_ecs/src/resource/resource_query.rs
deleted file mode 100644
index 42ca61ea97944..0000000000000
--- a/crates/bevy_ecs/src/resource/resource_query.rs
+++ /dev/null
@@ -1,221 +0,0 @@
-use super::FromResources;
-use crate::{Resource, ResourceIndex, Resources, SystemId};
-use std::{
-    marker::PhantomData,
-    ops::{Deref, DerefMut},
-    ptr::NonNull,
-};
-
-// TODO: align TypeAccess api with Query::Fetch
-
-/// Shared borrow of a Resource
-#[derive(Debug)]
-pub struct Res<'a, T: Resource> {
-    value: &'a T,
-    added: bool,
-    mutated: bool,
-}
-
-impl<'a, T: Resource> Res<'a, T> {
-    /// Creates a reference cell to a Resource from a pointer
-    ///
-    /// # Safety
-    /// The pointer must have correct lifetime / storage
-    pub unsafe fn new(value: NonNull<T>, added: bool, changed: bool) -> Self {
-        Self {
-            value: &*value.as_ptr(),
-            added,
-            mutated: changed,
-        }
-    }
-}
-
-impl<'a, T: Resource> Deref for Res<'a, T> {
-    type Target = T;
-
-    fn deref(&self) -> &T {
-        self.value
-    }
-}
-
-impl<'a, T: Resource> Res<'a, T> {
-    #[inline(always)]
-    pub fn added(this: &Self) -> bool {
-        this.added
-    }
-
-    #[inline(always)]
-    pub fn mutated(this: &Self) -> bool {
-        this.mutated
-    }
-
-    #[inline(always)]
-    pub fn changed(this: &Self) -> bool {
-        this.added || this.mutated
-    }
-}
-
-/// Unique borrow of a Resource
-#[derive(Debug)]
-pub struct ResMut<'a, T: Resource> {
-    _marker: PhantomData<&'a T>,
-    value: *mut T,
-    added: bool,
-    mutated: *mut bool,
-}
-
-impl<'a, T: Resource> ResMut<'a, T> {
-    /// Creates a mutable reference cell to a Resource from a pointer
-    ///
-    /// # Safety
-    /// The pointer must have correct lifetime / storage / ownership
-    pub unsafe fn new(value: NonNull<T>, added: bool, mutated: NonNull<bool>) -> Self {
-        Self {
-            value: value.as_ptr(),
-            mutated: mutated.as_ptr(),
-            added,
-            _marker: Default::default(),
-        }
-    }
-}
-
-impl<'a, T: Resource> Deref for ResMut<'a, T> {
-    type Target = T;
-
-    fn deref(&self) -> &T {
-        unsafe { &*self.value }
-    }
-}
-
-impl<'a, T: Resource> DerefMut for ResMut<'a, T> {
-    fn deref_mut(&mut self) -> &mut T {
-        unsafe {
-            *self.mutated = true;
-            &mut *self.value
-        }
-    }
-}
-
-impl<'a, T: Resource> ResMut<'a, T> {
-    #[inline(always)]
-    pub fn added(this: Self) -> bool {
-        this.added
-    }
-
-    #[inline(always)]
-    pub fn mutated(this: Self) -> bool {
-        unsafe { *this.mutated }
-    }
-
-    #[inline(always)]
-    pub fn changed(this: Self) -> bool {
-        this.added || Self::mutated(this)
-    }
-}
-
-/// Local<T> resources are unique per-system. Two instances of the same system will each have their own resource.
-/// Local resources are automatically initialized using the FromResources trait.
-#[derive(Debug)]
-pub struct Local<'a, T: Resource + FromResources> {
-    value: *mut T,
-    _marker: PhantomData<&'a T>,
-}
-
-impl<'a, T: Resource + FromResources> Local<'a, T> {
-    pub(crate) unsafe fn new(resources: &Resources, id: SystemId) -> Self {
-        Local {
-            value: resources
-                .get_unsafe_ref::<T>(ResourceIndex::System(id))
-                .as_ptr(),
-            _marker: Default::default(),
-        }
-    }
-}
-
-impl<'a, T: Resource + FromResources> Deref for Local<'a, T> {
-    type Target = T;
-
-    fn deref(&self) -> &T {
-        unsafe { &*self.value }
-    }
-}
-
-impl<'a, T: Resource + FromResources> DerefMut for Local<'a, T> {
-    fn deref_mut(&mut self) -> &mut T {
-        unsafe { &mut *self.value }
-    }
-}
-
-/// `NonSend<T>` resources cannot leave the main thread, so any system that wants access to
-/// a non-send resource will run on the main thread. See `Resources::insert_non_send()` and friends.
-#[derive(Debug)]
-pub struct NonSend<'a, T: 'static> {
-    value: *mut T,
-    _marker: PhantomData<&'a T>,
-}
-
-impl<'a, T: 'static> NonSend<'a, T> {
-    pub(crate) unsafe fn new(resources: &Resources) -> Self {
-        NonSend {
-            value: resources.get_unsafe_non_send_ref::<T>().as_ptr(),
-            _marker: Default::default(),
-        }
-    }
-}
-
-impl<'a, T: 'static> Deref for NonSend<'a, T> {
-    type Target = T;
-
-    fn deref(&self) -> &T {
-        unsafe { &*self.value }
-    }
-}
-
-impl<'a, T: 'static> DerefMut for NonSend<'a, T> {
-    fn deref_mut(&mut self) -> &mut T {
-        unsafe { &mut *self.value }
-    }
-}
-
-// #[cfg(test)]
-// mod tests {
-//     use super::*;
-
-//     #[test]
-//     fn changed_resource() {
-//         let mut resources = Resources::default();
-//         resources.insert(123);
-//         assert_eq!(
-//             resources.query::<ChangedRes<i32>>().as_deref(),
-//             Some(&(123 as i32))
-//         );
-//         resources.clear_trackers();
-//         assert_eq!(resources.query::<ChangedRes<i32>>().as_deref(), None);
-//         *resources.query::<ResMut<i32>>().unwrap() += 1;
-//         assert_eq!(
-//             resources.query::<ChangedRes<i32>>().as_deref(),
-//             Some(&(124 as i32))
-//         );
-//     }
-
-//     #[test]
-//     fn or_changed_resource() {
-//         let mut resources = Resources::default();
-//         resources.insert(123);
-//         resources.insert(0.2);
-//         assert!(resources
-//             .query::<OrRes<(ChangedRes<i32>, ChangedRes<f64>)>>()
-//             .is_some(),);
-//         resources.clear_trackers();
-//         assert!(resources
-//             .query::<OrRes<(ChangedRes<i32>, ChangedRes<f64>)>>()
-//             .is_none(),);
-//         *resources.query::<ResMut<i32>>().unwrap() += 1;
-//         assert!(resources
-//             .query::<OrRes<(ChangedRes<i32>, ChangedRes<f64>)>>()
-//             .is_some(),);
-//         assert!(resources
-//             .query::<(ChangedRes<i32>, ChangedRes<f64>)>()
-//             .is_none(),);
-//     }
-// }
diff --git a/crates/bevy_ecs/src/resource/resources.rs b/crates/bevy_ecs/src/resource/resources.rs
deleted file mode 100644
index f1c3b17233cc0..0000000000000
--- a/crates/bevy_ecs/src/resource/resources.rs
+++ /dev/null
@@ -1,593 +0,0 @@
-use crate::{system::SystemId, AtomicBorrow};
-use bevy_utils::HashMap;
-use core::any::TypeId;
-use downcast_rs::{impl_downcast, Downcast};
-use std::{
-    cell::UnsafeCell,
-    fmt::Debug,
-    ops::{Deref, DerefMut},
-    ptr::NonNull,
-    thread::ThreadId,
-};
-
-/// A Resource type
-pub trait Resource: Send + Sync + 'static {}
-impl<T: Send + Sync + 'static> Resource for T {}
-
-pub(crate) struct ResourceData {
-    storage: Box<dyn ResourceStorage>,
-    default_index: Option<usize>,
-    system_id_to_archetype_index: HashMap<usize, usize>,
-}
-
-#[derive(Debug)]
-pub enum ResourceIndex {
-    Global,
-    System(SystemId),
-}
-
-// TODO: consider using this for normal resources (would require change tracking)
-trait ResourceStorage: Downcast {
-    fn clear_trackers(&mut self);
-}
-impl_downcast!(ResourceStorage);
-
-struct StoredResource<T: 'static> {
-    value: UnsafeCell<T>,
-    added: UnsafeCell<bool>,
-    mutated: UnsafeCell<bool>,
-    atomic_borrow: AtomicBorrow,
-}
-
-pub struct VecResourceStorage<T: 'static> {
-    stored: Vec<StoredResource<T>>,
-}
-
-impl<T: 'static> VecResourceStorage<T> {
-    fn get(&self, index: usize) -> Option<ResourceRef<'_, T>> {
-        self.stored
-            .get(index)
-            .map(|stored| ResourceRef::new(stored))
-    }
-
-    fn get_mut(&self, index: usize) -> Option<ResourceRefMut<'_, T>> {
-        self.stored
-            .get(index)
-            .map(|stored| ResourceRefMut::new(stored))
-    }
-
-    unsafe fn get_unsafe_ref(&self, index: usize) -> NonNull<T> {
-        NonNull::new_unchecked(self.stored.get_unchecked(index).value.get())
-    }
-
-    fn push(&mut self, resource: T) {
-        self.stored.push(StoredResource {
-            atomic_borrow: AtomicBorrow::new(),
-            value: UnsafeCell::new(resource),
-            added: UnsafeCell::new(true),
-            mutated: UnsafeCell::new(true),
-        });
-    }
-
-    fn set(&mut self, index: usize, resource: T) {
-        self.stored[index].value = UnsafeCell::new(resource);
-        self.stored[index].mutated = UnsafeCell::new(true);
-    }
-
-    fn is_empty(&self) -> bool {
-        self.stored.is_empty()
-    }
-}
-
-impl<T: 'static> Default for VecResourceStorage<T> {
-    fn default() -> Self {
-        Self {
-            stored: Default::default(),
-        }
-    }
-}
-
-impl<T: 'static> ResourceStorage for VecResourceStorage<T> {
-    fn clear_trackers(&mut self) {
-        for stored in &mut self.stored {
-            stored.added = UnsafeCell::new(false);
-            stored.mutated = UnsafeCell::new(false);
-        }
-    }
-}
-
-/// A collection of resource instances identified by their type.
-pub struct Resources {
-    pub(crate) resource_data: HashMap<TypeId, ResourceData>,
-    non_send_data: HashMap<TypeId, Box<dyn ResourceStorage>>,
-    main_thread_id: ThreadId,
-}
-
-impl Default for Resources {
-    fn default() -> Self {
-        Resources {
-            resource_data: Default::default(),
-            non_send_data: Default::default(),
-            main_thread_id: std::thread::current().id(),
-        }
-    }
-}
-
-impl Resources {
-    pub fn insert<T: Resource>(&mut self, resource: T) {
-        self.insert_resource(resource, ResourceIndex::Global);
-    }
-
-    pub fn insert_non_send<T: 'static>(&mut self, resource: T) {
-        self.check_if_main_thread();
-        let entry = self
-            .non_send_data
-            .entry(TypeId::of::<T>())
-            .or_insert_with(|| Box::new(VecResourceStorage::<T>::default()));
-        let resources = entry.downcast_mut::<VecResourceStorage<T>>().unwrap();
-        if resources.is_empty() {
-            resources.push(resource);
-        } else {
-            resources.set(0, resource);
-        }
-    }
-
-    fn check_if_main_thread(&self) {
-        if std::thread::current().id() != self.main_thread_id {
-            panic!("Attempted to access a non-send resource off of the main thread.")
-        }
-    }
-
-    pub fn contains<T: Resource>(&self) -> bool {
-        self.get_resource::<T>(ResourceIndex::Global).is_some()
-    }
-
-    pub fn get<T: Resource>(&self) -> Option<ResourceRef<'_, T>> {
-        self.get_resource(ResourceIndex::Global)
-    }
-
-    pub fn get_mut<T: Resource>(&self) -> Option<ResourceRefMut<'_, T>> {
-        self.get_resource_mut(ResourceIndex::Global)
-    }
-
-    pub fn get_non_send<T: 'static>(&self) -> Option<ResourceRef<'_, T>> {
-        self.check_if_main_thread();
-        self.non_send_data
-            .get(&TypeId::of::<T>())
-            .and_then(|storage| {
-                let resources = storage.downcast_ref::<VecResourceStorage<T>>().unwrap();
-                resources.get(0)
-            })
-    }
-
-    pub fn get_non_send_mut<T: 'static>(&self) -> Option<ResourceRefMut<'_, T>> {
-        self.check_if_main_thread();
-        self.non_send_data
-            .get(&TypeId::of::<T>())
-            .and_then(|storage| {
-                let resources = storage.downcast_ref::<VecResourceStorage<T>>().unwrap();
-                resources.get_mut(0)
-            })
-    }
-
-    pub fn get_or_insert_with<T: Resource>(
-        &mut self,
-        get_resource: impl FnOnce() -> T,
-    ) -> ResourceRefMut<'_, T> {
-        // NOTE: this double-get is really weird. why cant we use an if-let here?
-        if self.get::<T>().is_some() {
-            return self.get_mut::<T>().unwrap();
-        }
-        self.insert(get_resource());
-        self.get_mut().unwrap()
-    }
-
-    /// Returns a clone of the underlying resource, this is helpful when borrowing something
-    /// cloneable (like a task pool) without taking a borrow on the resource map
-    pub fn get_cloned<T: Resource + Clone>(&self) -> Option<T> {
-        self.get::<T>().map(|r| (*r).clone())
-    }
-
-    #[allow(clippy::needless_lifetimes)]
-    pub fn get_local<'a, T: Resource>(&'a self, id: SystemId) -> Option<ResourceRef<'a, T>> {
-        self.get_resource(ResourceIndex::System(id))
-    }
-
-    #[allow(clippy::needless_lifetimes)]
-    pub fn get_local_mut<'a, T: Resource>(&'a self, id: SystemId) -> Option<ResourceRefMut<'a, T>> {
-        self.get_resource_mut(ResourceIndex::System(id))
-    }
-
-    pub fn insert_local<T: Resource>(&mut self, id: SystemId, resource: T) {
-        self.insert_resource(resource, ResourceIndex::System(id))
-    }
-
-    fn insert_resource<T: Resource>(&mut self, resource: T, resource_index: ResourceIndex) {
-        let type_id = TypeId::of::<T>();
-        let data = self
-            .resource_data
-            .entry(type_id)
-            .or_insert_with(|| ResourceData {
-                storage: Box::new(VecResourceStorage::<T>::default()),
-                default_index: None,
-                system_id_to_archetype_index: HashMap::default(),
-            });
-
-        let storage = data
-            .storage
-            .downcast_mut::<VecResourceStorage<T>>()
-            .unwrap();
-        let index = match resource_index {
-            ResourceIndex::Global => *data
-                .default_index
-                .get_or_insert_with(|| storage.stored.len()),
-            ResourceIndex::System(id) => *data
-                .system_id_to_archetype_index
-                .entry(id.0)
-                .or_insert_with(|| storage.stored.len()),
-        };
-
-        use std::cmp::Ordering;
-        match index.cmp(&storage.stored.len()) {
-            Ordering::Equal => {
-                storage.push(resource);
-            }
-            Ordering::Greater => panic!("Attempted to access index beyond 'current_capacity + 1'."),
-            Ordering::Less => {
-                *storage.get_mut(index).unwrap() = resource;
-            }
-        }
-    }
-
-    fn get_resource<T: Resource>(
-        &self,
-        resource_index: ResourceIndex,
-    ) -> Option<ResourceRef<'_, T>> {
-        self.get_resource_data_index::<T>(resource_index)
-            .and_then(|(data, index)| {
-                let resources = data
-                    .storage
-                    .downcast_ref::<VecResourceStorage<T>>()
-                    .unwrap();
-                resources.get(index)
-            })
-    }
-
-    fn get_resource_mut<T: Resource>(
-        &self,
-        resource_index: ResourceIndex,
-    ) -> Option<ResourceRefMut<'_, T>> {
-        self.get_resource_data_index::<T>(resource_index)
-            .and_then(|(data, index)| {
-                let resources = data
-                    .storage
-                    .downcast_ref::<VecResourceStorage<T>>()
-                    .unwrap();
-                resources.get_mut(index)
-            })
-    }
-
-    #[inline]
-    #[allow(clippy::missing_safety_doc)]
-    pub unsafe fn get_unsafe_ref<T: Resource>(&self, resource_index: ResourceIndex) -> NonNull<T> {
-        self.get_resource_data_index::<T>(resource_index)
-            .map(|(data, index)| {
-                let resources = data
-                    .storage
-                    .downcast_ref::<VecResourceStorage<T>>()
-                    .unwrap();
-                resources.get_unsafe_ref(index)
-            })
-            .unwrap_or_else(|| panic!("Resource does not exist {}.", std::any::type_name::<T>()))
-    }
-
-    #[inline]
-    #[allow(clippy::missing_safety_doc)]
-    pub unsafe fn get_unsafe_non_send_ref<T: 'static>(&self) -> NonNull<T> {
-        self.check_if_main_thread();
-        self.non_send_data
-            .get(&TypeId::of::<T>())
-            .map(|storage| {
-                let resources = storage.downcast_ref::<VecResourceStorage<T>>().unwrap();
-                resources.get_unsafe_ref(0)
-            })
-            .unwrap_or_else(|| {
-                panic!(
-                    "Non-send resource does not exist {}.",
-                    std::any::type_name::<T>()
-                )
-            })
-    }
-
-    #[inline]
-    #[allow(clippy::missing_safety_doc)]
-    pub unsafe fn get_unsafe_ref_with_added_and_mutated<T: Resource>(
-        &self,
-        resource_index: ResourceIndex,
-    ) -> (NonNull<T>, NonNull<bool>, NonNull<bool>) {
-        self.get_resource_data_index::<T>(resource_index)
-            .map(|(data, index)| {
-                let resources = data
-                    .storage
-                    .downcast_ref::<VecResourceStorage<T>>()
-                    .unwrap();
-
-                (
-                    resources.get_unsafe_ref(index),
-                    NonNull::new_unchecked(resources.stored[index].added.get()),
-                    NonNull::new_unchecked(resources.stored[index].mutated.get()),
-                )
-            })
-            .unwrap_or_else(|| panic!("Resource does not exist {}.", std::any::type_name::<T>()))
-    }
-
-    #[inline]
-    fn get_resource_data_index<T: Resource>(
-        &self,
-        resource_index: ResourceIndex,
-    ) -> Option<(&ResourceData, usize)> {
-        self.resource_data.get(&TypeId::of::<T>()).and_then(|data| {
-            let index = match resource_index {
-                ResourceIndex::Global => data.default_index?,
-                ResourceIndex::System(id) => {
-                    data.system_id_to_archetype_index.get(&id.0).cloned()?
-                }
-            };
-            Some((data, index as usize))
-        })
-    }
-
-    /// Clears each resource's tracker state.
-    /// For example, each resource's component "mutated" state will be reset to `false`.
-    pub fn clear_trackers(&mut self) {
-        for (_, resource_data) in self.resource_data.iter_mut() {
-            resource_data.storage.clear_trackers();
-        }
-    }
-
-    pub fn remove<T: Resource>(&mut self) {
-        self.resource_data.remove(&TypeId::of::<T>());
-    }
-}
-
-unsafe impl Send for Resources {}
-unsafe impl Sync for Resources {}
-
-/// Creates `Self` using data from the `Resources` collection
-pub trait FromResources {
-    /// Creates `Self` using data from the `Resources` collection
-    fn from_resources(resources: &Resources) -> Self;
-}
-
-impl<T> FromResources for T
-where
-    T: Default,
-{
-    fn from_resources(_resources: &Resources) -> Self {
-        Self::default()
-    }
-}
-
-/// Shared borrow of an entity's component
-#[derive(Clone)]
-pub struct ResourceRef<'a, T: 'static> {
-    borrow: &'a AtomicBorrow,
-    resource: &'a T,
-}
-
-impl<'a, T: 'static> ResourceRef<'a, T> {
-    /// Creates a new resource borrow
-    fn new(
-        StoredResource {
-            value,
-            added: _,
-            mutated: _,
-            atomic_borrow,
-        }: &'a StoredResource<T>,
-    ) -> Self {
-        if atomic_borrow.borrow() {
-            Self {
-                // Safe because we acquired the lock
-                resource: unsafe { &*value.get() },
-                borrow: atomic_borrow,
-            }
-        } else {
-            panic!(
-                "Failed to acquire shared lock on resource: {}.",
-                std::any::type_name::<T>()
-            );
-        }
-    }
-}
-
-unsafe impl<T: 'static> Send for ResourceRef<'_, T> {}
-unsafe impl<T: 'static> Sync for ResourceRef<'_, T> {}
-
-impl<'a, T: 'static> Drop for ResourceRef<'a, T> {
-    fn drop(&mut self) {
-        self.borrow.release()
-    }
-}
-
-impl<'a, T: 'static> Deref for ResourceRef<'a, T> {
-    type Target = T;
-
-    fn deref(&self) -> &T {
-        self.resource
-    }
-}
-
-impl<'a, T: 'static> Debug for ResourceRef<'a, T>
-where
-    T: Debug,
-{
-    fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
-        self.deref().fmt(f)
-    }
-}
-
-/// Unique borrow of a resource
-pub struct ResourceRefMut<'a, T: 'static> {
-    borrow: &'a AtomicBorrow,
-    resource: &'a mut T,
-    mutated: &'a mut bool,
-}
-
-impl<'a, T: 'static> ResourceRefMut<'a, T> {
-    /// Creates a new entity component mutable borrow
-    fn new(
-        StoredResource {
-            value,
-            added: _,
-            mutated,
-            atomic_borrow,
-        }: &'a StoredResource<T>,
-    ) -> Self {
-        if atomic_borrow.borrow_mut() {
-            Self {
-                // Safe because we acquired the lock
-                resource: unsafe { &mut *value.get() },
-                // same
-                mutated: unsafe { &mut *mutated.get() },
-                borrow: atomic_borrow,
-            }
-        } else {
-            panic!(
-                "Failed to acquire exclusive lock on resource: {}.",
-                std::any::type_name::<T>()
-            );
-        }
-    }
-}
-
-unsafe impl<T: 'static> Send for ResourceRefMut<'_, T> {}
-unsafe impl<T: 'static> Sync for ResourceRefMut<'_, T> {}
-
-impl<'a, T: 'static> Drop for ResourceRefMut<'a, T> {
-    fn drop(&mut self) {
-        self.borrow.release_mut();
-    }
-}
-
-impl<'a, T: 'static> Deref for ResourceRefMut<'a, T> {
-    type Target = T;
-
-    fn deref(&self) -> &T {
-        self.resource
-    }
-}
-
-impl<'a, T: 'static> DerefMut for ResourceRefMut<'a, T> {
-    fn deref_mut(&mut self) -> &mut T {
-        *self.mutated = true;
-        self.resource
-    }
-}
-
-impl<'a, T: 'static> Debug for ResourceRefMut<'a, T>
-where
-    T: Debug,
-{
-    fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
-        self.deref().fmt(f)
-    }
-}
-
-#[cfg(test)]
-mod tests {
-    use super::Resources;
-    use crate::system::SystemId;
-
-    #[test]
-    #[allow(clippy::float_cmp)]
-    fn resource() {
-        let mut resources = Resources::default();
-        assert!(resources.get::<i32>().is_none());
-
-        resources.insert(123);
-        assert_eq!(*resources.get::<i32>().expect("resource exists"), 123);
-
-        resources.insert(456.0);
-        assert_eq!(*resources.get::<f64>().expect("resource exists"), 456.0);
-
-        resources.insert(789.0);
-        assert_eq!(*resources.get::<f64>().expect("resource exists"), 789.0);
-
-        {
-            let mut value = resources.get_mut::<f64>().expect("resource exists");
-            assert_eq!(*value, 789.0);
-            *value = -1.0;
-        }
-
-        assert_eq!(*resources.get::<f64>().expect("resource exists"), -1.0);
-
-        assert!(resources.get_local::<i32>(SystemId(0)).is_none());
-        resources.insert_local(SystemId(0), 111);
-        assert_eq!(
-            *resources
-                .get_local::<i32>(SystemId(0))
-                .expect("resource exists"),
-            111
-        );
-        assert_eq!(*resources.get::<i32>().expect("resource exists"), 123);
-        resources.insert_local(SystemId(0), 222);
-        assert_eq!(
-            *resources
-                .get_local::<i32>(SystemId(0))
-                .expect("resource exists"),
-            222
-        );
-        assert_eq!(*resources.get::<i32>().expect("resource exists"), 123);
-        resources.remove::<i32>();
-        assert!(resources.get::<i32>().is_none());
-    }
-
-    #[test]
-    #[should_panic(expected = "Failed to acquire exclusive lock on resource: i32")]
-    fn resource_double_mut_panic() {
-        let mut resources = Resources::default();
-        resources.insert(123);
-        let _x = resources.get_mut::<i32>();
-        let _y = resources.get_mut::<i32>();
-    }
-
-    #[test]
-    fn non_send_resource() {
-        let mut resources = Resources::default();
-        resources.insert_non_send(123i32);
-        resources.insert_non_send(456i64);
-        assert_eq!(*resources.get_non_send::<i32>().unwrap(), 123);
-        assert_eq!(*resources.get_non_send_mut::<i64>().unwrap(), 456);
-    }
-
-    #[test]
-    fn non_send_resource_ref_aliasing() {
-        let mut resources = Resources::default();
-        resources.insert_non_send(123i32);
-        let a = resources.get_non_send::<i32>().unwrap();
-        let b = resources.get_non_send::<i32>().unwrap();
-        assert_eq!(*a, 123);
-        assert_eq!(*b, 123);
-    }
-
-    #[test]
-    #[should_panic]
-    fn non_send_resource_mut_ref_aliasing() {
-        let mut resources = Resources::default();
-        resources.insert_non_send(123i32);
-        let _a = resources.get_non_send::<i32>().unwrap();
-        let _b = resources.get_non_send_mut::<i32>().unwrap();
-    }
-
-    #[test]
-    #[should_panic]
-    fn non_send_resource_panic() {
-        let mut resources = Resources::default();
-        resources.insert_non_send(0i32);
-        std::thread::spawn(move || {
-            let _ = resources.get_non_send_mut::<i32>();
-        })
-        .join()
-        .unwrap();
-    }
-}
diff --git a/crates/bevy_ecs/src/schedule/executor.rs b/crates/bevy_ecs/src/schedule/executor.rs
index d220e9ff4fd71..18184cc25cc74 100644
--- a/crates/bevy_ecs/src/schedule/executor.rs
+++ b/crates/bevy_ecs/src/schedule/executor.rs
@@ -1,17 +1,11 @@
+use crate::{schedule::ParallelSystemContainer, world::World};
 use downcast_rs::{impl_downcast, Downcast};
 
-use crate::{ParallelSystemContainer, Resources, World};
-
 pub trait ParallelSystemExecutor: Downcast + Send + Sync {
     /// Called by `SystemStage` whenever `systems` have been changed.
-    fn rebuild_cached_data(&mut self, systems: &mut [ParallelSystemContainer], world: &World);
+    fn rebuild_cached_data(&mut self, systems: &[ParallelSystemContainer]);
 
-    fn run_systems(
-        &mut self,
-        systems: &mut [ParallelSystemContainer],
-        world: &mut World,
-        resources: &mut Resources,
-    );
+    fn run_systems(&mut self, systems: &mut [ParallelSystemContainer], world: &mut World);
 }
 
 impl_downcast!(ParallelSystemExecutor);
@@ -20,17 +14,12 @@ impl_downcast!(ParallelSystemExecutor);
 pub struct SingleThreadedExecutor;
 
 impl ParallelSystemExecutor for SingleThreadedExecutor {
-    fn rebuild_cached_data(&mut self, _: &mut [ParallelSystemContainer], _: &World) {}
+    fn rebuild_cached_data(&mut self, _: &[ParallelSystemContainer]) {}
 
-    fn run_systems(
-        &mut self,
-        systems: &mut [ParallelSystemContainer],
-        world: &mut World,
-        resources: &mut Resources,
-    ) {
+    fn run_systems(&mut self, systems: &mut [ParallelSystemContainer], world: &mut World) {
         for system in systems {
             if system.should_run() {
-                system.system_mut().run((), world, resources);
+                system.system_mut().run((), world);
             }
         }
     }
diff --git a/crates/bevy_ecs/src/schedule/executor_parallel.rs b/crates/bevy_ecs/src/schedule/executor_parallel.rs
index 8e9a71dfdb0d6..49ae06b6738a9 100644
--- a/crates/bevy_ecs/src/schedule/executor_parallel.rs
+++ b/crates/bevy_ecs/src/schedule/executor_parallel.rs
@@ -1,13 +1,13 @@
+use crate::{
+    archetype::{ArchetypeComponentId, ArchetypeGeneration},
+    query::Access,
+    schedule::{ParallelSystemContainer, ParallelSystemExecutor},
+    world::World,
+};
 use async_channel::{Receiver, Sender};
 use bevy_tasks::{ComputeTaskPool, Scope, TaskPool};
-use bevy_utils::HashSet;
 use fixedbitset::FixedBitSet;
 
-use crate::{
-    ArchetypesGeneration, CondensedTypeAccess, ParallelSystemContainer, ParallelSystemExecutor,
-    Resources, System, World,
-};
-
 #[cfg(test)]
 use SchedulingEvent::*;
 
@@ -23,23 +23,21 @@ struct SystemSchedulingMetadata {
     dependencies_total: usize,
     /// Amount of unsatisfied dependencies, when it reaches 0 the system is queued to be started.
     dependencies_now: usize,
-    /// Archetype-component access information condensed into executor-specific bitsets.
-    archetype_component_access: CondensedTypeAccess,
-    /// Resource access information condensed into executor-specific bitsets.
-    resource_access: CondensedTypeAccess,
+    /// Archetype-component access information.
+    archetype_component_access: Access<ArchetypeComponentId>,
+    /// Whether or not this system is send-able
+    is_send: bool,
 }
 
 pub struct ParallelExecutor {
     /// Last archetypes generation observed by parallel systems.
-    last_archetypes_generation: ArchetypesGeneration,
+    archetype_generation: ArchetypeGeneration,
     /// Cached metadata of every system.
     system_metadata: Vec<SystemSchedulingMetadata>,
     /// Used by systems to notify the executor that they have finished.
     finish_sender: Sender<usize>,
     /// Receives finish events from systems.
     finish_receiver: Receiver<usize>,
-    /// Systems that must run on the main thread.
-    non_send: FixedBitSet,
     /// Systems that should be started at next opportunity.
     queued: FixedBitSet,
     /// Systems that are currently running.
@@ -49,9 +47,7 @@ pub struct ParallelExecutor {
     /// Systems that should run this iteration.
     should_run: FixedBitSet,
     /// Compound archetype-component access information of currently running systems.
-    active_archetype_component_access: CondensedTypeAccess,
-    /// Compound resource access information of currently running systems.
-    active_resource_access: CondensedTypeAccess,
+    active_archetype_component_access: Access<ArchetypeComponentId>,
     /// Scratch space to avoid reallocating a vector when updating dependency counters.
     dependants_scratch: Vec<usize>,
     #[cfg(test)]
@@ -63,17 +59,15 @@ impl Default for ParallelExecutor {
         let (finish_sender, finish_receiver) = async_channel::unbounded();
         Self {
             // MAX ensures access information will be initialized on first run.
-            last_archetypes_generation: ArchetypesGeneration(u64::MAX),
+            archetype_generation: ArchetypeGeneration::new(usize::MAX),
             system_metadata: Default::default(),
             finish_sender,
             finish_receiver,
-            non_send: Default::default(),
             queued: Default::default(),
             running: Default::default(),
             non_send_running: false,
             should_run: Default::default(),
             active_archetype_component_access: Default::default(),
-            active_resource_access: Default::default(),
             dependants_scratch: Default::default(),
             #[cfg(test)]
             events_sender: None,
@@ -82,50 +76,16 @@ impl Default for ParallelExecutor {
 }
 
 impl ParallelSystemExecutor for ParallelExecutor {
-    fn rebuild_cached_data(&mut self, systems: &mut [ParallelSystemContainer], world: &World) {
+    fn rebuild_cached_data(&mut self, systems: &[ParallelSystemContainer]) {
         self.system_metadata.clear();
-        self.non_send.clear();
-        self.non_send.grow(systems.len());
         self.queued.grow(systems.len());
         self.running.grow(systems.len());
         self.should_run.grow(systems.len());
-        // Collect all distinct types accessed by systems in order to condense their
-        // access sets into bitsets.
-        let mut all_archetype_components = HashSet::default();
-        let mut all_resource_types = HashSet::default();
-        let mut gather_distinct_access_types = |system: &dyn System<In = (), Out = ()>| {
-            if let Some(archetype_components) =
-                system.archetype_component_access().all_distinct_types()
-            {
-                all_archetype_components.extend(archetype_components);
-            }
-            if let Some(resources) = system.resource_access().all_distinct_types() {
-                all_resource_types.extend(resources);
-            }
-        };
-        // If the archetypes were changed too, system access should be updated
-        // before gathering the types.
-        if self.last_archetypes_generation != world.archetypes_generation() {
-            for container in systems.iter_mut() {
-                let system = container.system_mut();
-                system.update_access(world);
-                gather_distinct_access_types(system);
-            }
-            self.last_archetypes_generation = world.archetypes_generation();
-        } else {
-            for container in systems.iter() {
-                gather_distinct_access_types(container.system());
-            }
-        }
-        let all_archetype_components = all_archetype_components.drain().collect::<Vec<_>>();
-        let all_resource_types = all_resource_types.drain().collect::<Vec<_>>();
+
         // Construct scheduling data for systems.
         for container in systems.iter() {
             let dependencies_total = container.dependencies().len();
             let system = container.system();
-            if system.is_non_send() {
-                self.non_send.insert(self.system_metadata.len());
-            }
             let (start_sender, start_receiver) = async_channel::bounded(1);
             self.system_metadata.push(SystemSchedulingMetadata {
                 start_sender,
@@ -133,10 +93,8 @@ impl ParallelSystemExecutor for ParallelExecutor {
                 dependants: vec![],
                 dependencies_total,
                 dependencies_now: 0,
-                archetype_component_access: system
-                    .archetype_component_access()
-                    .condense(&all_archetype_components),
-                resource_access: system.resource_access().condense(&all_resource_types),
+                is_send: system.is_send(),
+                archetype_component_access: Default::default(),
             });
         }
         // Populate the dependants lists in the scheduling metadata.
@@ -147,27 +105,21 @@ impl ParallelSystemExecutor for ParallelExecutor {
         }
     }
 
-    fn run_systems(
-        &mut self,
-        systems: &mut [ParallelSystemContainer],
-        world: &mut World,
-        resources: &mut Resources,
-    ) {
+    fn run_systems(&mut self, systems: &mut [ParallelSystemContainer], world: &mut World) {
         #[cfg(test)]
         if self.events_sender.is_none() {
             let (sender, receiver) = async_channel::unbounded::<SchedulingEvent>();
-            resources.insert(receiver);
+            world.insert_resource(receiver);
             self.events_sender = Some(sender);
         }
-        if self.last_archetypes_generation != world.archetypes_generation() {
-            self.update_access(systems, world);
-            self.last_archetypes_generation = world.archetypes_generation();
-        }
-        let compute_pool = resources
-            .get_or_insert_with(|| ComputeTaskPool(TaskPool::default()))
+
+        self.update_archetypes(systems, world);
+
+        let compute_pool = world
+            .get_resource_or_insert_with(|| ComputeTaskPool(TaskPool::default()))
             .clone();
         compute_pool.scope(|scope| {
-            self.prepare_systems(scope, systems, world, resources);
+            self.prepare_systems(scope, systems, world);
             scope.spawn(async {
                 // All systems have been ran if there are no queued or running systems.
                 while 0 != self.queued.count_ones(..) + self.running.count_ones(..) {
@@ -196,27 +148,32 @@ impl ParallelSystemExecutor for ParallelExecutor {
 }
 
 impl ParallelExecutor {
-    /// Updates access and recondenses the archetype component bitsets of systems.
-    fn update_access(&mut self, systems: &mut [ParallelSystemContainer], world: &mut World) {
-        let mut all_archetype_components = HashSet::default();
-        for container in systems.iter_mut() {
-            let system = container.system_mut();
-            system.update_access(world);
-            if let Some(archetype_components) =
-                system.archetype_component_access().all_distinct_types()
-            {
-                all_archetype_components.extend(archetype_components);
-            }
+    /// Calls system.new_archetype() for each archetype added since the last call to [update_archetypes] and
+    /// updates cached archetype_component_access.
+    fn update_archetypes(&mut self, systems: &mut [ParallelSystemContainer], world: &World) {
+        let archetypes = world.archetypes();
+        let old_generation = self.archetype_generation;
+        let new_generation = archetypes.generation();
+        if old_generation == new_generation {
+            return;
         }
-        let all_archetype_components = all_archetype_components.drain().collect::<Vec<_>>();
-        for (index, container) in systems.iter().enumerate() {
-            let system = container.system();
-            if !system.archetype_component_access().reads_all() {
-                self.system_metadata[index].archetype_component_access = system
-                    .archetype_component_access()
-                    .condense(&all_archetype_components);
+
+        let archetype_index_range = if old_generation.value() == usize::MAX {
+            0..archetypes.len()
+        } else {
+            old_generation.value()..archetypes.len()
+        };
+        for archetype in archetypes.archetypes[archetype_index_range].iter() {
+            for (index, container) in systems.iter_mut().enumerate() {
+                let meta = &mut self.system_metadata[index];
+                let system = container.system_mut();
+                system.new_archetype(archetype);
+                meta.archetype_component_access
+                    .extend(system.archetype_component_access());
             }
         }
+
+        self.archetype_generation = new_generation;
     }
 
     /// Populates `should_run` bitset, spawns tasks for systems that should run this iteration,
@@ -226,7 +183,6 @@ impl ParallelExecutor {
         scope: &mut Scope<'scope, ()>,
         systems: &'scope [ParallelSystemContainer],
         world: &'scope World,
-        resources: &'scope Resources,
     ) {
         self.should_run.clear();
         for (index, system_data) in self.system_metadata.iter_mut().enumerate() {
@@ -241,16 +197,16 @@ impl ParallelExecutor {
                         .recv()
                         .await
                         .unwrap_or_else(|error| unreachable!(error));
-                    unsafe { system.run_unsafe((), world, resources) };
+                    unsafe { system.run_unsafe((), world) };
                     finish_sender
                         .send(index)
                         .await
                         .unwrap_or_else(|error| unreachable!(error));
                 };
-                if self.non_send[index] {
-                    scope.spawn_local(task);
-                } else {
+                if system_data.is_send {
                     scope.spawn(task);
+                } else {
+                    scope.spawn_local(task);
                 }
             }
             // Queue the system if it has no dependencies, otherwise reset its dependency counter.
@@ -266,10 +222,7 @@ impl ParallelExecutor {
     fn can_start_now(&self, index: usize) -> bool {
         let system_data = &self.system_metadata[index];
         // Non-send systems are considered conflicting with each other.
-        !(self.non_send[index] && self.non_send_running)
-            && system_data
-                .resource_access
-                .is_compatible(&self.active_resource_access)
+        (!self.non_send_running || system_data.is_send)
             && system_data
                 .archetype_component_access
                 .is_compatible(&self.active_archetype_component_access)
@@ -284,29 +237,26 @@ impl ParallelExecutor {
         for index in self.queued.ones() {
             // If the system shouldn't actually run this iteration, process it as completed
             // immediately; otherwise, check for conflicts and signal its task to start.
+            let system_metadata = &self.system_metadata[index];
             if !self.should_run[index] {
-                self.dependants_scratch
-                    .extend(&self.system_metadata[index].dependants);
+                self.dependants_scratch.extend(&system_metadata.dependants);
             } else if self.can_start_now(index) {
                 #[cfg(test)]
                 {
                     started_systems += 1;
                 }
-                let system_data = &self.system_metadata[index];
-                system_data
+                system_metadata
                     .start_sender
                     .send(())
                     .await
                     .unwrap_or_else(|error| unreachable!(error));
                 self.running.set(index, true);
-                if self.non_send[index] {
+                if !system_metadata.is_send {
                     self.non_send_running = true;
                 }
                 // Add this system's access information to the active access information.
                 self.active_archetype_component_access
-                    .extend(&system_data.archetype_component_access);
-                self.active_resource_access
-                    .extend(&system_data.resource_access);
+                    .extend(&system_metadata.archetype_component_access);
             }
         }
         #[cfg(test)]
@@ -322,24 +272,21 @@ impl ParallelExecutor {
     /// Unmarks the system give index as running, caches indices of its dependants
     /// in the `dependants_scratch`.
     fn process_finished_system(&mut self, index: usize) {
-        if self.non_send[index] {
+        let system_data = &self.system_metadata[index];
+        if !system_data.is_send {
             self.non_send_running = false;
         }
         self.running.set(index, false);
-        self.dependants_scratch
-            .extend(&self.system_metadata[index].dependants);
+        self.dependants_scratch.extend(&system_data.dependants);
     }
 
     /// Discards active access information and builds it again using currently
     /// running systems' access information.
     fn rebuild_active_access(&mut self) {
         self.active_archetype_component_access.clear();
-        self.active_resource_access.clear();
         for index in self.running.ones() {
             self.active_archetype_component_access
                 .extend(&self.system_metadata[index].archetype_component_access);
-            self.active_resource_access
-                .extend(&self.system_metadata[index].resource_access);
         }
     }
 
@@ -374,14 +321,17 @@ enum SchedulingEvent {
 #[cfg(test)]
 mod tests {
     use super::SchedulingEvent::{self, *};
-    use crate::{prelude::*, SingleThreadedExecutor};
+    use crate::{
+        schedule::{SingleThreadedExecutor, Stage, SystemStage},
+        system::{IntoSystem, NonSend, Query, Res, ResMut},
+        world::World,
+    };
     use async_channel::Receiver;
-    use std::thread::{self, ThreadId};
 
-    fn receive_events(resources: &Resources) -> Vec<SchedulingEvent> {
+    fn receive_events(world: &World) -> Vec<SchedulingEvent> {
         let mut events = Vec::new();
-        while let Ok(event) = resources
-            .get::<Receiver<SchedulingEvent>>()
+        while let Ok(event) = world
+            .get_resource::<Receiver<SchedulingEvent>>()
             .unwrap()
             .try_recv()
         {
@@ -393,16 +343,15 @@ mod tests {
     #[test]
     fn trivial() {
         let mut world = World::new();
-        let mut resources = Resources::default();
         fn wants_for_nothing() {}
         let mut stage = SystemStage::parallel()
             .with_system(wants_for_nothing.system())
             .with_system(wants_for_nothing.system())
             .with_system(wants_for_nothing.system());
-        stage.run(&mut world, &mut resources);
-        stage.run(&mut world, &mut resources);
+        stage.run(&mut world);
+        stage.run(&mut world);
         assert_eq!(
-            receive_events(&resources),
+            receive_events(&world),
             vec![StartedSystems(3), StartedSystems(3),]
         )
     }
@@ -410,78 +359,76 @@ mod tests {
     #[test]
     fn resources() {
         let mut world = World::new();
-        let mut resources = Resources::default();
-        resources.insert(0usize);
+        world.insert_resource(0usize);
         fn wants_mut(_: ResMut<usize>) {}
         fn wants_ref(_: Res<usize>) {}
         let mut stage = SystemStage::parallel()
             .with_system(wants_mut.system())
             .with_system(wants_mut.system());
-        stage.run(&mut world, &mut resources);
+        stage.run(&mut world);
         assert_eq!(
-            receive_events(&resources),
+            receive_events(&world),
             vec![StartedSystems(1), StartedSystems(1),]
         );
         let mut stage = SystemStage::parallel()
             .with_system(wants_mut.system())
             .with_system(wants_ref.system());
-        stage.run(&mut world, &mut resources);
+        stage.run(&mut world);
         assert_eq!(
-            receive_events(&resources),
+            receive_events(&world),
             vec![StartedSystems(1), StartedSystems(1),]
         );
         let mut stage = SystemStage::parallel()
             .with_system(wants_ref.system())
             .with_system(wants_ref.system());
-        stage.run(&mut world, &mut resources);
-        assert_eq!(receive_events(&resources), vec![StartedSystems(2),]);
+        stage.run(&mut world);
+        assert_eq!(receive_events(&world), vec![StartedSystems(2),]);
     }
 
     #[test]
     fn queries() {
         let mut world = World::new();
-        let mut resources = Resources::default();
-        world.spawn((0usize,));
+        world.spawn().insert(0usize);
         fn wants_mut(_: Query<&mut usize>) {}
         fn wants_ref(_: Query<&usize>) {}
         let mut stage = SystemStage::parallel()
             .with_system(wants_mut.system())
             .with_system(wants_mut.system());
-        stage.run(&mut world, &mut resources);
+        stage.run(&mut world);
         assert_eq!(
-            receive_events(&resources),
+            receive_events(&world),
             vec![StartedSystems(1), StartedSystems(1),]
         );
         let mut stage = SystemStage::parallel()
             .with_system(wants_mut.system())
             .with_system(wants_ref.system());
-        stage.run(&mut world, &mut resources);
+        stage.run(&mut world);
         assert_eq!(
-            receive_events(&resources),
+            receive_events(&world),
             vec![StartedSystems(1), StartedSystems(1),]
         );
         let mut stage = SystemStage::parallel()
             .with_system(wants_ref.system())
             .with_system(wants_ref.system());
-        stage.run(&mut world, &mut resources);
-        assert_eq!(receive_events(&resources), vec![StartedSystems(2),]);
+        stage.run(&mut world);
+        assert_eq!(receive_events(&world), vec![StartedSystems(2),]);
         let mut world = World::new();
-        world.spawn((0usize, 0u32, 0f32));
+        world.spawn().insert_bundle((0usize, 0u32, 0f32));
         fn wants_mut_usize(_: Query<(&mut usize, &f32)>) {}
         fn wants_mut_u32(_: Query<(&mut u32, &f32)>) {}
         let mut stage = SystemStage::parallel()
             .with_system(wants_mut_usize.system())
             .with_system(wants_mut_u32.system());
-        stage.run(&mut world, &mut resources);
-        assert_eq!(receive_events(&resources), vec![StartedSystems(2),]);
+        stage.run(&mut world);
+        assert_eq!(receive_events(&world), vec![StartedSystems(2),]);
     }
 
     #[test]
     fn non_send_resource() {
+        use std::thread;
         let mut world = World::new();
-        let mut resources = Resources::default();
-        resources.insert_non_send(thread::current().id());
-        fn non_send(thread_id: NonSend<ThreadId>) {
+        world.insert_non_send(thread::current().id());
+        fn non_send(thread_id: NonSend<thread::ThreadId>) {
             assert_eq!(thread::current().id(), *thread_id);
         }
         fn empty() {}
@@ -492,9 +439,9 @@ mod tests {
             .with_system(empty.system())
             .with_system(non_send.system())
             .with_system(non_send.system());
-        stage.run(&mut world, &mut resources);
+        stage.run(&mut world);
         assert_eq!(
-            receive_events(&resources),
+            receive_events(&world),
             vec![
                 StartedSystems(3),
                 StartedSystems(1),
@@ -503,6 +450,6 @@ mod tests {
             ]
         );
         stage.set_executor(Box::new(SingleThreadedExecutor::default()));
-        stage.run(&mut world, &mut resources);
+        stage.run(&mut world);
     }
 }
diff --git a/crates/bevy_ecs/src/schedule/label.rs b/crates/bevy_ecs/src/schedule/label.rs
index 725c3f80977b5..3223f5614772f 100644
--- a/crates/bevy_ecs/src/schedule/label.rs
+++ b/crates/bevy_ecs/src/schedule/label.rs
@@ -1,3 +1,5 @@
+pub use bevy_ecs_macros::{AmbiguitySetLabel, StageLabel, SystemLabel};
+
 use std::{
     any::Any,
     borrow::Cow,
diff --git a/crates/bevy_ecs/src/schedule/mod.rs b/crates/bevy_ecs/src/schedule/mod.rs
index 712e2787ceb91..4339b5446492e 100644
--- a/crates/bevy_ecs/src/schedule/mod.rs
+++ b/crates/bevy_ecs/src/schedule/mod.rs
@@ -2,7 +2,6 @@ mod executor;
 mod executor_parallel;
 mod label;
 mod stage;
-//mod stageless;
 mod state;
 mod system_container;
 mod system_descriptor;
@@ -18,10 +17,14 @@ pub use system_descriptor::*;
 pub use system_set::*;
 
 use crate::{
-    ArchetypeComponent, BoxedSystem, IntoSystem, Resources, System, SystemId, TypeAccess, World,
+    archetype::{Archetype, ArchetypeComponentId},
+    component::ComponentId,
+    query::Access,
+    system::{BoxedSystem, IntoSystem, System, SystemId},
+    world::World,
 };
 use bevy_utils::HashMap;
-use std::{any::TypeId, borrow::Cow};
+use std::borrow::Cow;
 
 #[derive(Default)]
 pub struct Schedule {
@@ -187,7 +190,7 @@ impl Schedule {
             .and_then(|stage| stage.downcast_mut::<T>())
     }
 
-    pub fn run_once(&mut self, world: &mut World, resources: &mut Resources) {
+    pub fn run_once(&mut self, world: &mut World) {
         for label in self.stage_order.iter() {
             #[cfg(feature = "trace")]
             let stage_span =
@@ -195,22 +198,22 @@ impl Schedule {
             #[cfg(feature = "trace")]
             let _stage_guard = stage_span.enter();
             let stage = self.stages.get_mut(label).unwrap();
-            stage.run(world, resources);
+            stage.run(world);
         }
     }
 }
 
 impl Stage for Schedule {
-    fn run(&mut self, world: &mut World, resources: &mut Resources) {
+    fn run(&mut self, world: &mut World) {
         loop {
-            match self.run_criteria.should_run(world, resources) {
+            match self.run_criteria.should_run(world) {
                 ShouldRun::No => return,
                 ShouldRun::Yes => {
-                    self.run_once(world, resources);
+                    self.run_once(world);
                     return;
                 }
                 ShouldRun::YesAndCheckAgain => {
-                    self.run_once(world, resources);
+                    self.run_once(world);
                 }
                 ShouldRun::NoAndCheckAgain => {
                     panic!("`NoAndCheckAgain` would loop infinitely in this situation.")
@@ -220,11 +223,6 @@ impl Stage for Schedule {
     }
 }
 
-pub fn clear_trackers_system(world: &mut World, resources: &mut Resources) {
-    world.clear_trackers();
-    resources.clear_trackers();
-}
-
 #[derive(Debug, Clone, Copy, PartialEq, Eq)]
 pub enum ShouldRun {
     /// Yes, the system should run.
@@ -257,16 +255,15 @@ impl RunCriteria {
         self.initialized = false;
     }
 
-    pub fn should_run(&mut self, world: &mut World, resources: &mut Resources) -> ShouldRun {
+    pub fn should_run(&mut self, world: &mut World) -> ShouldRun {
         if let Some(ref mut run_criteria) = self.criteria_system {
             if !self.initialized {
-                run_criteria.initialize(world, resources);
+                run_criteria.initialize(world);
                 self.initialized = true;
             }
-            let should_run = run_criteria.run((), world, resources);
-            run_criteria.apply_buffers(world, resources);
-            // don't run when no result is returned or false is returned
-            should_run.unwrap_or(ShouldRun::No)
+            let should_run = run_criteria.run((), world);
+            run_criteria.apply_buffers(world);
+            should_run
         } else {
             ShouldRun::Yes
         }
@@ -276,9 +273,8 @@ impl RunCriteria {
 pub struct RunOnce {
     ran: bool,
     system_id: SystemId,
-    archetype_component_access: TypeAccess<ArchetypeComponent>,
-    component_access: TypeAccess<TypeId>,
-    resource_access: TypeAccess<TypeId>,
+    archetype_component_access: Access<ArchetypeComponentId>,
+    component_access: Access<ComponentId>,
 }
 
 impl Default for RunOnce {
@@ -288,7 +284,6 @@ impl Default for RunOnce {
             system_id: SystemId::new(),
             archetype_component_access: Default::default(),
             component_access: Default::default(),
-            resource_access: Default::default(),
         }
     }
 }
@@ -305,39 +300,30 @@ impl System for RunOnce {
         self.system_id
     }
 
-    fn update_access(&mut self, _world: &World) {}
+    fn new_archetype(&mut self, _archetype: &Archetype) {}
 
-    fn archetype_component_access(&self) -> &TypeAccess<ArchetypeComponent> {
+    fn archetype_component_access(&self) -> &Access<ArchetypeComponentId> {
         &self.archetype_component_access
     }
 
-    fn component_access(&self) -> &TypeAccess<TypeId> {
+    fn component_access(&self) -> &Access<ComponentId> {
         &self.component_access
     }
 
-    fn resource_access(&self) -> &TypeAccess<TypeId> {
-        &self.resource_access
-    }
-
-    fn is_non_send(&self) -> bool {
-        false
+    fn is_send(&self) -> bool {
+        true
     }
 
-    unsafe fn run_unsafe(
-        &mut self,
-        _input: Self::In,
-        _world: &World,
-        _resources: &Resources,
-    ) -> Option<Self::Out> {
-        Some(if self.ran {
+    unsafe fn run_unsafe(&mut self, _input: Self::In, _world: &World) -> Self::Out {
+        if self.ran {
             ShouldRun::No
         } else {
             self.ran = true;
             ShouldRun::Yes
-        })
+        }
     }
 
-    fn apply_buffers(&mut self, _world: &mut World, _resources: &mut Resources) {}
+    fn apply_buffers(&mut self, _world: &mut World) {}
 
-    fn initialize(&mut self, _world: &mut World, _resources: &mut Resources) {}
+    fn initialize(&mut self, _world: &mut World) {}
 }
diff --git a/crates/bevy_ecs/src/schedule/stage.rs b/crates/bevy_ecs/src/schedule/stage.rs
index c81382636825c..7a601438bd0bf 100644
--- a/crates/bevy_ecs/src/schedule/stage.rs
+++ b/crates/bevy_ecs/src/schedule/stage.rs
@@ -1,22 +1,21 @@
+use crate::{
+    schedule::{
+        BoxedSystemLabel, ExclusiveSystemContainer, InsertionPoint, ParallelExecutor,
+        ParallelSystemContainer, ParallelSystemExecutor, RunCriteria, ShouldRun,
+        SingleThreadedExecutor, SystemContainer, SystemDescriptor, SystemLabel, SystemSet,
+    },
+    system::System,
+    world::{World, WorldId},
+};
 use bevy_utils::{tracing::info, HashMap, HashSet};
 use downcast_rs::{impl_downcast, Downcast};
 use fixedbitset::FixedBitSet;
 use std::borrow::Cow;
 
-use super::{
-    ExclusiveSystemContainer, ParallelExecutor, ParallelSystemContainer, ParallelSystemExecutor,
-    SingleThreadedExecutor, SystemContainer,
-};
-use crate::{
-    BoxedSystemLabel, InsertionPoint, Resources, RunCriteria,
-    ShouldRun::{self, *},
-    System, SystemDescriptor, SystemLabel, SystemSet, World,
-};
-
 pub trait Stage: Downcast + Send + Sync {
     /// Runs the stage; this happens once per update.
     /// Implementors must initialize all of their state and systems before running the first time.
-    fn run(&mut self, world: &mut World, resources: &mut Resources);
+    fn run(&mut self, world: &mut World);
 }
 
 impl_downcast!(Stage);
@@ -49,6 +48,8 @@ struct VirtualSystemSet {
 /// Stores and executes systems. Execution order is not defined unless explicitly specified;
 /// see `SystemDescriptor` documentation.
 pub struct SystemStage {
+    /// The WorldId this stage was last run on.
+    world_id: Option<WorldId>,
     /// Instance of a scheduling algorithm for running the systems.
     executor: Box<dyn ParallelSystemExecutor>,
     /// Groups of systems; each set has its own run criterion.
@@ -83,6 +84,7 @@ impl SystemStage {
             should_run: ShouldRun::Yes,
         };
         SystemStage {
+            world_id: None,
             executor,
             system_sets: vec![set],
             exclusive_at_start: Default::default(),
@@ -194,26 +196,22 @@ impl SystemStage {
         self
     }
 
-    fn initialize_systems(&mut self, world: &mut World, resources: &mut Resources) {
+    fn initialize_systems(&mut self, world: &mut World) {
         for index in self.uninitialized_at_start.drain(..) {
             self.exclusive_at_start[index]
                 .system_mut()
-                .initialize(world, resources);
+                .initialize(world);
         }
         for index in self.uninitialized_before_commands.drain(..) {
             self.exclusive_before_commands[index]
                 .system_mut()
-                .initialize(world, resources);
+                .initialize(world);
         }
         for index in self.uninitialized_at_end.drain(..) {
-            self.exclusive_at_end[index]
-                .system_mut()
-                .initialize(world, resources);
+            self.exclusive_at_end[index].system_mut().initialize(world);
         }
         for index in self.uninitialized_parallel.drain(..) {
-            self.parallel[index]
-                .system_mut()
-                .initialize(world, resources);
+            self.parallel[index].system_mut().initialize(world);
         }
     }
 
@@ -502,6 +500,7 @@ fn find_ambiguities(systems: &[impl SystemContainer]) -> Vec<(usize, usize)> {
             dependencies.insert(dependency);
             all_dependants[dependency].insert(index);
         }
+
         all_dependants.push(FixedBitSet::with_capacity(systems.len()));
         all_dependencies.push(dependencies);
     }
@@ -546,38 +545,47 @@ fn find_ambiguities(systems: &[impl SystemContainer]) -> Vec<(usize, usize)> {
 }
 
 impl Stage for SystemStage {
-    fn run(&mut self, world: &mut World, resources: &mut Resources) {
+    fn run(&mut self, world: &mut World) {
+        if let Some(world_id) = self.world_id {
+            assert!(
+                world.id() == world_id,
+                "Cannot run SystemStage on two different Worlds"
+            );
+        } else {
+            self.world_id = Some(world.id());
+        }
         // Evaluate sets' run criteria, initialize sets as needed, detect if any sets were changed.
         let mut has_work = false;
         for system_set in self.system_sets.iter_mut() {
-            let result = system_set.run_criteria.should_run(world, resources);
+            let result = system_set.run_criteria.should_run(world);
             match result {
-                Yes | YesAndCheckAgain => has_work = true,
-                No | NoAndCheckAgain => (),
+                ShouldRun::Yes | ShouldRun::YesAndCheckAgain => has_work = true,
+                ShouldRun::No | ShouldRun::NoAndCheckAgain => (),
             }
             system_set.should_run = result;
         }
 
         if self.systems_modified {
-            self.initialize_systems(world, resources);
+            self.initialize_systems(world);
             self.rebuild_orders_and_dependencies();
             self.systems_modified = false;
-            self.executor.rebuild_cached_data(&mut self.parallel, world);
+            self.executor.rebuild_cached_data(&self.parallel);
             self.executor_modified = false;
-            if resources.contains::<ReportExecutionOrderAmbiguities>() {
+            if world.contains_resource::<ReportExecutionOrderAmbiguities>() {
                 self.report_ambiguities();
             }
         } else if self.executor_modified {
-            self.executor.rebuild_cached_data(&mut self.parallel, world);
+            self.executor.rebuild_cached_data(&self.parallel);
             self.executor_modified = false;
         }
 
         while has_work {
             // Run systems that want to be at the start of stage.
             for container in &mut self.exclusive_at_start {
-                if let Yes | YesAndCheckAgain = self.system_sets[container.system_set()].should_run
+                if let ShouldRun::Yes | ShouldRun::YesAndCheckAgain =
+                    self.system_sets[container.system_set()].should_run
                 {
-                    container.system_mut().run(world, resources);
+                    container.system_mut().run(world);
                 }
             }
 
@@ -585,33 +593,34 @@ impl Stage for SystemStage {
             // TODO: hard dependencies, nested sets, whatever... should be evaluated here.
             for container in &mut self.parallel {
                 match self.system_sets[container.system_set()].should_run {
-                    Yes | YesAndCheckAgain => container.should_run = true,
-                    No | NoAndCheckAgain => container.should_run = false,
+                    ShouldRun::Yes | ShouldRun::YesAndCheckAgain => container.should_run = true,
+                    ShouldRun::No | ShouldRun::NoAndCheckAgain => container.should_run = false,
                 }
             }
-            self.executor
-                .run_systems(&mut self.parallel, world, resources);
+            self.executor.run_systems(&mut self.parallel, world);
 
             // Run systems that want to be between parallel systems and their command buffers.
             for container in &mut self.exclusive_before_commands {
-                if let Yes | YesAndCheckAgain = self.system_sets[container.system_set()].should_run
+                if let ShouldRun::Yes | ShouldRun::YesAndCheckAgain =
+                    self.system_sets[container.system_set()].should_run
                 {
-                    container.system_mut().run(world, resources);
+                    container.system_mut().run(world);
                 }
             }
 
             // Apply parallel systems' buffers.
             for container in &mut self.parallel {
                 if container.should_run {
-                    container.system_mut().apply_buffers(world, resources);
+                    container.system_mut().apply_buffers(world);
                 }
             }
 
             // Run systems that want to be at the end of stage.
             for container in &mut self.exclusive_at_end {
-                if let Yes | YesAndCheckAgain = self.system_sets[container.system_set()].should_run
+                if let ShouldRun::Yes | ShouldRun::YesAndCheckAgain =
+                    self.system_sets[container.system_set()].should_run
                 {
-                    container.system_mut().run(world, resources);
+                    container.system_mut().run(world);
                 }
             }
 
@@ -619,13 +628,13 @@ impl Stage for SystemStage {
             has_work = false;
             for system_set in self.system_sets.iter_mut() {
                 match system_set.should_run {
-                    No => (),
-                    Yes => system_set.should_run = No,
-                    YesAndCheckAgain | NoAndCheckAgain => {
-                        let new_result = system_set.run_criteria.should_run(world, resources);
+                    ShouldRun::No => (),
+                    ShouldRun::Yes => system_set.should_run = ShouldRun::No,
+                    ShouldRun::YesAndCheckAgain | ShouldRun::NoAndCheckAgain => {
+                        let new_result = system_set.run_criteria.should_run(world);
                         match new_result {
-                            Yes | YesAndCheckAgain => has_work = true,
-                            No | NoAndCheckAgain => (),
+                            ShouldRun::Yes | ShouldRun::YesAndCheckAgain => has_work = true,
+                            ShouldRun::No | ShouldRun::NoAndCheckAgain => (),
                         }
                         system_set.should_run = new_result;
                     }
@@ -637,10 +646,17 @@ impl Stage for SystemStage {
 
 #[cfg(test)]
 mod tests {
-    use crate::{prelude::*, BoxedSystemLabel, SingleThreadedExecutor};
-
-    fn make_exclusive(tag: usize) -> impl FnMut(&mut Resources) {
-        move |resources| resources.get_mut::<Vec<usize>>().unwrap().push(tag)
+    use crate::{
+        schedule::{
+            BoxedSystemLabel, ExclusiveSystemDescriptorCoercion, ParallelSystemDescriptorCoercion,
+            ShouldRun, SingleThreadedExecutor, Stage, SystemSet, SystemStage,
+        },
+        system::{IntoExclusiveSystem, IntoSystem, Query, ResMut},
+        world::World,
+    };
+
+    fn make_exclusive(tag: usize) -> impl FnMut(&mut World) {
+        move |world| world.get_resource_mut::<Vec<usize>>().unwrap().push(tag)
     }
 
     // This is silly. https://github.com/bevyengine/bevy/issues/1029
@@ -666,50 +682,57 @@ mod tests {
     #[test]
     fn insertion_points() {
         let mut world = World::new();
-        let mut resources = Resources::default();
-
-        resources.insert(Vec::<usize>::new());
+        world.insert_resource(Vec::<usize>::new());
         let mut stage = SystemStage::parallel()
             .with_system(make_exclusive(0).exclusive_system().at_start())
             .with_system(make_parallel!(1).system())
             .with_system(make_exclusive(2).exclusive_system().before_commands())
             .with_system(make_exclusive(3).exclusive_system().at_end());
-        stage.run(&mut world, &mut resources);
-        assert_eq!(*resources.get::<Vec<usize>>().unwrap(), vec![0, 1, 2, 3]);
+        stage.run(&mut world);
+        assert_eq!(
+            *world.get_resource_mut::<Vec<usize>>().unwrap(),
+            vec![0, 1, 2, 3]
+        );
         stage.set_executor(Box::new(SingleThreadedExecutor::default()));
-        stage.run(&mut world, &mut resources);
+        stage.run(&mut world);
         assert_eq!(
-            *resources.get::<Vec<usize>>().unwrap(),
+            *world.get_resource::<Vec<usize>>().unwrap(),
             vec![0, 1, 2, 3, 0, 1, 2, 3]
         );
 
-        resources.get_mut::<Vec<usize>>().unwrap().clear();
+        world.get_resource_mut::<Vec<usize>>().unwrap().clear();
         let mut stage = SystemStage::parallel()
             .with_system(make_exclusive(2).exclusive_system().before_commands())
             .with_system(make_exclusive(3).exclusive_system().at_end())
             .with_system(make_parallel!(1).system())
             .with_system(make_exclusive(0).exclusive_system().at_start());
-        stage.run(&mut world, &mut resources);
-        assert_eq!(*resources.get::<Vec<usize>>().unwrap(), vec![0, 1, 2, 3]);
+        stage.run(&mut world);
+        assert_eq!(
+            *world.get_resource::<Vec<usize>>().unwrap(),
+            vec![0, 1, 2, 3]
+        );
         stage.set_executor(Box::new(SingleThreadedExecutor::default()));
-        stage.run(&mut world, &mut resources);
+        stage.run(&mut world);
         assert_eq!(
-            *resources.get::<Vec<usize>>().unwrap(),
+            *world.get_resource::<Vec<usize>>().unwrap(),
             vec![0, 1, 2, 3, 0, 1, 2, 3]
         );
 
-        resources.get_mut::<Vec<usize>>().unwrap().clear();
+        world.get_resource_mut::<Vec<usize>>().unwrap().clear();
         let mut stage = SystemStage::parallel()
             .with_system(make_parallel!(2).exclusive_system().before_commands())
             .with_system(make_parallel!(3).exclusive_system().at_end())
             .with_system(make_parallel!(1).system())
             .with_system(make_parallel!(0).exclusive_system().at_start());
-        stage.run(&mut world, &mut resources);
-        assert_eq!(*resources.get::<Vec<usize>>().unwrap(), vec![0, 1, 2, 3]);
+        stage.run(&mut world);
+        assert_eq!(
+            *world.get_resource::<Vec<usize>>().unwrap(),
+            vec![0, 1, 2, 3]
+        );
         stage.set_executor(Box::new(SingleThreadedExecutor::default()));
-        stage.run(&mut world, &mut resources);
+        stage.run(&mut world);
         assert_eq!(
-            *resources.get::<Vec<usize>>().unwrap(),
+            *world.get_resource::<Vec<usize>>().unwrap(),
             vec![0, 1, 2, 3, 0, 1, 2, 3]
         );
     }
@@ -718,12 +741,11 @@ mod tests {
     #[should_panic(expected = "No exclusive system with label \"empty\" at start of stage.")]
     fn exclusive_unknown_label() {
         let mut world = World::new();
-        let mut resources = Resources::default();
-        resources.insert(Vec::<usize>::new());
+        world.insert_resource(Vec::<usize>::new());
         let mut stage = SystemStage::parallel()
             .with_system(empty.exclusive_system().at_end().label("empty"))
             .with_system(empty.exclusive_system().after("empty"));
-        stage.run(&mut world, &mut resources);
+        stage.run(&mut world);
     }
 
     #[test]
@@ -732,32 +754,30 @@ mod tests {
     )]
     fn exclusive_duplicate_label() {
         let mut world = World::new();
-        let mut resources = Resources::default();
-        resources.insert(Vec::<usize>::new());
+        world.insert_resource(Vec::<usize>::new());
         let mut stage = SystemStage::parallel()
             .with_system(empty.exclusive_system().at_end().label("empty"))
             .with_system(empty.exclusive_system().before_commands().label("empty"));
-        stage.run(&mut world, &mut resources);
+        stage.run(&mut world);
         let mut stage = SystemStage::parallel()
             .with_system(empty.exclusive_system().label("empty"))
             .with_system(empty.exclusive_system().label("empty"));
-        stage.run(&mut world, &mut resources);
+        stage.run(&mut world);
     }
 
     #[test]
     fn exclusive_after() {
         let mut world = World::new();
-        let mut resources = Resources::default();
-        resources.insert(Vec::<usize>::new());
+        world.insert_resource(Vec::<usize>::new());
         let mut stage = SystemStage::parallel()
             .with_system(make_exclusive(1).exclusive_system().label("1").after("0"))
             .with_system(make_exclusive(2).exclusive_system().after("1"))
             .with_system(make_exclusive(0).exclusive_system().label("0"));
-        stage.run(&mut world, &mut resources);
+        stage.run(&mut world);
         stage.set_executor(Box::new(SingleThreadedExecutor::default()));
-        stage.run(&mut world, &mut resources);
+        stage.run(&mut world);
         assert_eq!(
-            *resources.get::<Vec<usize>>().unwrap(),
+            *world.get_resource::<Vec<usize>>().unwrap(),
             vec![0, 1, 2, 0, 1, 2]
         );
     }
@@ -765,17 +785,16 @@ mod tests {
     #[test]
     fn exclusive_before() {
         let mut world = World::new();
-        let mut resources = Resources::default();
-        resources.insert(Vec::<usize>::new());
+        world.insert_resource(Vec::<usize>::new());
         let mut stage = SystemStage::parallel()
             .with_system(make_exclusive(1).exclusive_system().label("1").before("2"))
             .with_system(make_exclusive(2).exclusive_system().label("2"))
             .with_system(make_exclusive(0).exclusive_system().before("1"));
-        stage.run(&mut world, &mut resources);
+        stage.run(&mut world);
         stage.set_executor(Box::new(SingleThreadedExecutor::default()));
-        stage.run(&mut world, &mut resources);
+        stage.run(&mut world);
         assert_eq!(
-            *resources.get::<Vec<usize>>().unwrap(),
+            *world.get_resource::<Vec<usize>>().unwrap(),
             vec![0, 1, 2, 0, 1, 2]
         );
     }
@@ -783,19 +802,18 @@ mod tests {
     #[test]
     fn exclusive_mixed() {
         let mut world = World::new();
-        let mut resources = Resources::default();
-        resources.insert(Vec::<usize>::new());
+        world.insert_resource(Vec::<usize>::new());
         let mut stage = SystemStage::parallel()
             .with_system(make_exclusive(2).exclusive_system().label("2"))
             .with_system(make_exclusive(1).exclusive_system().after("0").before("2"))
             .with_system(make_exclusive(0).exclusive_system().label("0"))
             .with_system(make_exclusive(4).exclusive_system().label("4"))
             .with_system(make_exclusive(3).exclusive_system().after("2").before("4"));
-        stage.run(&mut world, &mut resources);
+        stage.run(&mut world);
         stage.set_executor(Box::new(SingleThreadedExecutor::default()));
-        stage.run(&mut world, &mut resources);
+        stage.run(&mut world);
         assert_eq!(
-            *resources.get::<Vec<usize>>().unwrap(),
+            *world.get_resource::<Vec<usize>>().unwrap(),
             vec![0, 1, 2, 3, 4, 0, 1, 2, 3, 4]
         );
     }
@@ -803,8 +821,7 @@ mod tests {
     #[test]
     fn exclusive_redundant_constraints() {
         let mut world = World::new();
-        let mut resources = Resources::default();
-        resources.insert(Vec::<usize>::new());
+        world.insert_resource(Vec::<usize>::new());
         let mut stage = SystemStage::parallel()
             .with_system(
                 make_exclusive(2)
@@ -831,11 +848,11 @@ mod tests {
                     .after("2")
                     .before("4"),
             );
-        stage.run(&mut world, &mut resources);
+        stage.run(&mut world);
         stage.set_executor(Box::new(SingleThreadedExecutor::default()));
-        stage.run(&mut world, &mut resources);
+        stage.run(&mut world);
         assert_eq!(
-            *resources.get::<Vec<usize>>().unwrap(),
+            *world.get_resource::<Vec<usize>>().unwrap(),
             vec![0, 1, 2, 3, 4, 0, 1, 2, 3, 4]
         );
     }
@@ -843,8 +860,7 @@ mod tests {
     #[test]
     fn exclusive_mixed_across_sets() {
         let mut world = World::new();
-        let mut resources = Resources::default();
-        resources.insert(Vec::<usize>::new());
+        world.insert_resource(Vec::<usize>::new());
         let mut stage = SystemStage::parallel()
             .with_system(make_exclusive(2).exclusive_system().label("2"))
             .with_system_set(
@@ -854,11 +870,11 @@ mod tests {
                     .with_system(make_exclusive(3).exclusive_system().after("2").before("4")),
             )
             .with_system(make_exclusive(1).exclusive_system().after("0").before("2"));
-        stage.run(&mut world, &mut resources);
+        stage.run(&mut world);
         stage.set_executor(Box::new(SingleThreadedExecutor::default()));
-        stage.run(&mut world, &mut resources);
+        stage.run(&mut world);
         assert_eq!(
-            *resources.get::<Vec<usize>>().unwrap(),
+            *world.get_resource::<Vec<usize>>().unwrap(),
             vec![0, 1, 2, 3, 4, 0, 1, 2, 3, 4]
         );
     }
@@ -866,9 +882,8 @@ mod tests {
     #[test]
     fn exclusive_run_criteria() {
         let mut world = World::new();
-        let mut resources = Resources::default();
-        resources.insert(Vec::<usize>::new());
-        resources.insert(false);
+        world.insert_resource(Vec::<usize>::new());
+        world.insert_resource(false);
         let mut stage = SystemStage::parallel()
             .with_system(make_exclusive(0).exclusive_system().before("1"))
             .with_system_set(
@@ -877,14 +892,14 @@ mod tests {
                     .with_system(make_exclusive(1).exclusive_system().label("1")),
             )
             .with_system(make_exclusive(2).exclusive_system().after("1"));
-        stage.run(&mut world, &mut resources);
-        stage.run(&mut world, &mut resources);
-        *resources.get_mut::<bool>().unwrap() = false;
+        stage.run(&mut world);
+        stage.run(&mut world);
+        *world.get_resource_mut::<bool>().unwrap() = false;
         stage.set_executor(Box::new(SingleThreadedExecutor::default()));
-        stage.run(&mut world, &mut resources);
-        stage.run(&mut world, &mut resources);
+        stage.run(&mut world);
+        stage.run(&mut world);
         assert_eq!(
-            *resources.get::<Vec<usize>>().unwrap(),
+            *world.get_resource::<Vec<usize>>().unwrap(),
             vec![0, 1, 2, 0, 2, 0, 1, 2, 0, 2]
         );
     }
@@ -893,76 +908,70 @@ mod tests {
     #[should_panic]
     fn exclusive_cycle_1() {
         let mut world = World::new();
-        let mut resources = Resources::default();
-        resources.insert(Vec::<usize>::new());
+        world.insert_resource(Vec::<usize>::new());
         let mut stage = SystemStage::parallel()
             .with_system(make_exclusive(0).exclusive_system().label("0").after("0"));
-        stage.run(&mut world, &mut resources);
+        stage.run(&mut world);
     }
 
     #[test]
     #[should_panic]
     fn exclusive_cycle_2() {
         let mut world = World::new();
-        let mut resources = Resources::default();
-        resources.insert(Vec::<usize>::new());
+        world.insert_resource(Vec::<usize>::new());
         let mut stage = SystemStage::parallel()
             .with_system(make_exclusive(0).exclusive_system().label("0").after("1"))
             .with_system(make_exclusive(1).exclusive_system().label("1").after("0"));
-        stage.run(&mut world, &mut resources);
+        stage.run(&mut world);
     }
 
     #[test]
     #[should_panic]
     fn exclusive_cycle_3() {
         let mut world = World::new();
-        let mut resources = Resources::default();
-        resources.insert(Vec::<usize>::new());
+        world.insert_resource(Vec::<usize>::new());
         let mut stage = SystemStage::parallel()
             .with_system(make_exclusive(0).exclusive_system().label("0"))
             .with_system(make_exclusive(1).exclusive_system().after("0").before("2"))
             .with_system(make_exclusive(2).exclusive_system().label("2").before("0"));
-        stage.run(&mut world, &mut resources);
+        stage.run(&mut world);
     }
 
     #[test]
     #[should_panic(expected = "No parallel system with label \"empty\" in stage.")]
     fn parallel_unknown_label() {
         let mut world = World::new();
-        let mut resources = Resources::default();
-        resources.insert(Vec::<usize>::new());
+        world.insert_resource(Vec::<usize>::new());
         let mut stage = SystemStage::parallel()
             .with_system(empty.system())
             .with_system(empty.system().after("empty"));
-        stage.run(&mut world, &mut resources);
+        stage.run(&mut world);
     }
 
     #[test]
     #[should_panic(expected = "Label \"empty\" already used by a parallel system.")]
     fn parallel_duplicate_label() {
         let mut world = World::new();
-        let mut resources = Resources::default();
-        resources.insert(Vec::<usize>::new());
+        world.insert_resource(Vec::<usize>::new());
         let mut stage = SystemStage::parallel()
             .with_system(empty.system().label("empty"))
             .with_system(empty.system().label("empty"));
-        stage.run(&mut world, &mut resources);
+        stage.run(&mut world);
     }
 
     #[test]
     fn parallel_after() {
         let mut world = World::new();
-        let mut resources = Resources::default();
-        resources.insert(Vec::<usize>::new());
+        world.insert_resource(Vec::<usize>::new());
         let mut stage = SystemStage::parallel()
             .with_system(make_parallel!(1).system().after("0").label("1"))
             .with_system(make_parallel!(2).system().after("1"))
             .with_system(make_parallel!(0).system().label("0"));
-        stage.run(&mut world, &mut resources);
+        stage.run(&mut world);
         stage.set_executor(Box::new(SingleThreadedExecutor::default()));
-        stage.run(&mut world, &mut resources);
+        stage.run(&mut world);
         assert_eq!(
-            *resources.get::<Vec<usize>>().unwrap(),
+            *world.get_resource::<Vec<usize>>().unwrap(),
             vec![0, 1, 2, 0, 1, 2]
         );
     }
@@ -970,17 +979,16 @@ mod tests {
     #[test]
     fn parallel_before() {
         let mut world = World::new();
-        let mut resources = Resources::default();
-        resources.insert(Vec::<usize>::new());
+        world.insert_resource(Vec::<usize>::new());
         let mut stage = SystemStage::parallel()
             .with_system(make_parallel!(1).system().label("1").before("2"))
             .with_system(make_parallel!(2).system().label("2"))
             .with_system(make_parallel!(0).system().before("1"));
-        stage.run(&mut world, &mut resources);
+        stage.run(&mut world);
         stage.set_executor(Box::new(SingleThreadedExecutor::default()));
-        stage.run(&mut world, &mut resources);
+        stage.run(&mut world);
         assert_eq!(
-            *resources.get::<Vec<usize>>().unwrap(),
+            *world.get_resource::<Vec<usize>>().unwrap(),
             vec![0, 1, 2, 0, 1, 2]
         );
     }
@@ -988,19 +996,18 @@ mod tests {
     #[test]
     fn parallel_mixed() {
         let mut world = World::new();
-        let mut resources = Resources::default();
-        resources.insert(Vec::<usize>::new());
+        world.insert_resource(Vec::<usize>::new());
         let mut stage = SystemStage::parallel()
             .with_system(make_parallel!(2).system().label("2"))
             .with_system(make_parallel!(1).system().after("0").before("2"))
             .with_system(make_parallel!(0).system().label("0"))
             .with_system(make_parallel!(4).system().label("4"))
             .with_system(make_parallel!(3).system().after("2").before("4"));
-        stage.run(&mut world, &mut resources);
+        stage.run(&mut world);
         stage.set_executor(Box::new(SingleThreadedExecutor::default()));
-        stage.run(&mut world, &mut resources);
+        stage.run(&mut world);
         assert_eq!(
-            *resources.get::<Vec<usize>>().unwrap(),
+            *world.get_resource::<Vec<usize>>().unwrap(),
             vec![0, 1, 2, 3, 4, 0, 1, 2, 3, 4]
         );
     }
@@ -1008,8 +1015,7 @@ mod tests {
     #[test]
     fn parallel_redundant_constraints() {
         let mut world = World::new();
-        let mut resources = Resources::default();
-        resources.insert(Vec::<usize>::new());
+        world.insert_resource(Vec::<usize>::new());
         let mut stage = SystemStage::parallel()
             .with_system(
                 make_parallel!(2)
@@ -1030,14 +1036,14 @@ mod tests {
             .with_system(make_parallel!(0).system().label("0").before("1"))
             .with_system(make_parallel!(4).system().label("4").after("3"))
             .with_system(make_parallel!(3).system().label("3").after("2").before("4"));
-        stage.run(&mut world, &mut resources);
+        stage.run(&mut world);
         for container in stage.parallel.iter() {
             assert!(container.dependencies().len() <= 1);
         }
         stage.set_executor(Box::new(SingleThreadedExecutor::default()));
-        stage.run(&mut world, &mut resources);
+        stage.run(&mut world);
         assert_eq!(
-            *resources.get::<Vec<usize>>().unwrap(),
+            *world.get_resource::<Vec<usize>>().unwrap(),
             vec![0, 1, 2, 3, 4, 0, 1, 2, 3, 4]
         );
     }
@@ -1045,8 +1051,7 @@ mod tests {
     #[test]
     fn parallel_mixed_across_sets() {
         let mut world = World::new();
-        let mut resources = Resources::default();
-        resources.insert(Vec::<usize>::new());
+        world.insert_resource(Vec::<usize>::new());
         let mut stage = SystemStage::parallel()
             .with_system(make_parallel!(2).system().label("2"))
             .with_system_set(
@@ -1056,11 +1061,11 @@ mod tests {
                     .with_system(make_parallel!(3).system().after("2").before("4")),
             )
             .with_system(make_parallel!(1).system().after("0").before("2"));
-        stage.run(&mut world, &mut resources);
+        stage.run(&mut world);
         stage.set_executor(Box::new(SingleThreadedExecutor::default()));
-        stage.run(&mut world, &mut resources);
+        stage.run(&mut world);
         assert_eq!(
-            *resources.get::<Vec<usize>>().unwrap(),
+            *world.get_resource::<Vec<usize>>().unwrap(),
             vec![0, 1, 2, 3, 4, 0, 1, 2, 3, 4]
         );
     }
@@ -1068,9 +1073,8 @@ mod tests {
     #[test]
     fn parallel_run_criteria() {
         let mut world = World::new();
-        let mut resources = Resources::default();
-        resources.insert(Vec::<usize>::new());
-        resources.insert(false);
+        world.insert_resource(Vec::<usize>::new());
+        world.insert_resource(false);
         let mut stage = SystemStage::parallel()
             .with_system(make_parallel!(0).system().before("1"))
             .with_system_set(
@@ -1079,14 +1083,14 @@ mod tests {
                     .with_system(make_parallel!(1).system().label("1")),
             )
             .with_system(make_parallel!(2).system().after("1"));
-        stage.run(&mut world, &mut resources);
-        stage.run(&mut world, &mut resources);
-        *resources.get_mut::<bool>().unwrap() = false;
+        stage.run(&mut world);
+        stage.run(&mut world);
+        *world.get_resource_mut::<bool>().unwrap() = false;
         stage.set_executor(Box::new(SingleThreadedExecutor::default()));
-        stage.run(&mut world, &mut resources);
-        stage.run(&mut world, &mut resources);
+        stage.run(&mut world);
+        stage.run(&mut world);
         assert_eq!(
-            *resources.get::<Vec<usize>>().unwrap(),
+            *world.get_resource::<Vec<usize>>().unwrap(),
             vec![0, 1, 2, 0, 2, 0, 1, 2, 0, 2]
         );
     }
@@ -1095,36 +1099,34 @@ mod tests {
     #[should_panic]
     fn parallel_cycle_1() {
         let mut world = World::new();
-        let mut resources = Resources::default();
-        resources.insert(Vec::<usize>::new());
+        world.insert_resource(Vec::<usize>::new());
         let mut stage =
             SystemStage::parallel().with_system(make_parallel!(0).system().label("0").after("0"));
-        stage.run(&mut world, &mut resources);
+        stage.run(&mut world);
     }
 
     #[test]
     #[should_panic]
     fn parallel_cycle_2() {
         let mut world = World::new();
-        let mut resources = Resources::default();
-        resources.insert(Vec::<usize>::new());
+        world.insert_resource(Vec::<usize>::new());
         let mut stage = SystemStage::parallel()
             .with_system(make_parallel!(0).system().label("0").after("1"))
             .with_system(make_parallel!(1).system().label("1").after("0"));
-        stage.run(&mut world, &mut resources);
+        stage.run(&mut world);
     }
 
     #[test]
     #[should_panic]
     fn parallel_cycle_3() {
         let mut world = World::new();
-        let mut resources = Resources::default();
-        resources.insert(Vec::<usize>::new());
+
+        world.insert_resource(Vec::<usize>::new());
         let mut stage = SystemStage::parallel()
             .with_system(make_parallel!(0).system().label("0"))
             .with_system(make_parallel!(1).system().after("0").before("2"))
             .with_system(make_parallel!(2).system().label("2").before("0"));
-        stage.run(&mut world, &mut resources);
+        stage.run(&mut world);
     }
 
     #[test]
@@ -1150,7 +1152,6 @@ mod tests {
         fn component(_: Query<&mut f32>) {}
 
         let mut world = World::new();
-        let mut resources = Resources::default();
 
         let mut stage = SystemStage::parallel()
             .with_system(empty.system().label("0"))
@@ -1158,7 +1159,7 @@ mod tests {
             .with_system(empty.system().label("2"))
             .with_system(empty.system().label("3").after("2").before("4"))
             .with_system(empty.system().label("4"));
-        stage.initialize_systems(&mut world, &mut resources);
+        stage.initialize_systems(&mut world);
         stage.rebuild_orders_and_dependencies();
         assert_eq!(find_ambiguities(&stage.parallel).len(), 0);
 
@@ -1168,7 +1169,7 @@ mod tests {
             .with_system(empty.system().label("2"))
             .with_system(empty.system().label("3").after("2").before("4"))
             .with_system(component.system().label("4"));
-        stage.initialize_systems(&mut world, &mut resources);
+        stage.initialize_systems(&mut world);
         stage.rebuild_orders_and_dependencies();
         let ambiguities = find_ambiguities_labels(&stage.parallel);
         assert!(
@@ -1183,7 +1184,7 @@ mod tests {
             .with_system(empty.system().label("2"))
             .with_system(empty.system().label("3").after("2").before("4"))
             .with_system(resource.system().label("4"));
-        stage.initialize_systems(&mut world, &mut resources);
+        stage.initialize_systems(&mut world);
         stage.rebuild_orders_and_dependencies();
         let ambiguities = find_ambiguities_labels(&stage.parallel);
         assert!(
@@ -1198,7 +1199,7 @@ mod tests {
             .with_system(empty.system().label("2"))
             .with_system(empty.system().label("3").after("2").before("4"))
             .with_system(component.system().label("4"));
-        stage.initialize_systems(&mut world, &mut resources);
+        stage.initialize_systems(&mut world);
         stage.rebuild_orders_and_dependencies();
         assert_eq!(find_ambiguities(&stage.parallel).len(), 0);
 
@@ -1208,7 +1209,7 @@ mod tests {
             .with_system(empty.system().label("2"))
             .with_system(component.system().label("3").after("2").before("4"))
             .with_system(resource.system().label("4"));
-        stage.initialize_systems(&mut world, &mut resources);
+        stage.initialize_systems(&mut world);
         stage.rebuild_orders_and_dependencies();
         let ambiguities = find_ambiguities_labels(&stage.parallel);
         assert!(
@@ -1233,7 +1234,7 @@ mod tests {
             .with_system(empty.system().label("2"))
             .with_system(component.system().label("3").after("2").before("4"))
             .with_system(resource.system().label("4").in_ambiguity_set("a"));
-        stage.initialize_systems(&mut world, &mut resources);
+        stage.initialize_systems(&mut world);
         stage.rebuild_orders_and_dependencies();
         let ambiguities = find_ambiguities_labels(&stage.parallel);
         assert!(
@@ -1246,7 +1247,7 @@ mod tests {
             .with_system(component.system().label("0").before("2"))
             .with_system(component.system().label("1").before("2"))
             .with_system(component.system().label("2"));
-        stage.initialize_systems(&mut world, &mut resources);
+        stage.initialize_systems(&mut world);
         stage.rebuild_orders_and_dependencies();
         let ambiguities = find_ambiguities_labels(&stage.parallel);
         assert!(
@@ -1259,7 +1260,7 @@ mod tests {
             .with_system(component.system().label("0"))
             .with_system(component.system().label("1").after("0"))
             .with_system(component.system().label("2").after("0"));
-        stage.initialize_systems(&mut world, &mut resources);
+        stage.initialize_systems(&mut world);
         stage.rebuild_orders_and_dependencies();
         let ambiguities = find_ambiguities_labels(&stage.parallel);
         assert!(
@@ -1273,7 +1274,7 @@ mod tests {
             .with_system(component.system().label("1"))
             .with_system(component.system().label("2"))
             .with_system(component.system().label("3").after("1").after("2"));
-        stage.initialize_systems(&mut world, &mut resources);
+        stage.initialize_systems(&mut world);
         stage.rebuild_orders_and_dependencies();
         let ambiguities = find_ambiguities_labels(&stage.parallel);
         assert!(
@@ -1287,7 +1288,7 @@ mod tests {
             .with_system(component.system().label("1").in_ambiguity_set("a"))
             .with_system(component.system().label("2").in_ambiguity_set("a"))
             .with_system(component.system().label("3").after("1").after("2"));
-        stage.initialize_systems(&mut world, &mut resources);
+        stage.initialize_systems(&mut world);
         stage.rebuild_orders_and_dependencies();
         let ambiguities = find_ambiguities_labels(&stage.parallel);
         assert_eq!(ambiguities.len(), 0);
@@ -1297,7 +1298,7 @@ mod tests {
             .with_system(component.system().label("1").in_ambiguity_set("a"))
             .with_system(component.system().label("2").in_ambiguity_set("b"))
             .with_system(component.system().label("3").after("1").after("2"));
-        stage.initialize_systems(&mut world, &mut resources);
+        stage.initialize_systems(&mut world);
         stage.rebuild_orders_and_dependencies();
         let ambiguities = find_ambiguities_labels(&stage.parallel);
         assert!(
@@ -1329,7 +1330,7 @@ mod tests {
                     .after("3")
                     .after("4"),
             );
-        stage.initialize_systems(&mut world, &mut resources);
+        stage.initialize_systems(&mut world);
         stage.rebuild_orders_and_dependencies();
         let ambiguities = find_ambiguities_labels(&stage.parallel);
         assert!(
@@ -1381,7 +1382,7 @@ mod tests {
                     .after("3")
                     .after("4"),
             );
-        stage.initialize_systems(&mut world, &mut resources);
+        stage.initialize_systems(&mut world);
         stage.rebuild_orders_and_dependencies();
         let ambiguities = find_ambiguities_labels(&stage.parallel);
         assert_eq!(ambiguities.len(), 0);
@@ -1415,7 +1416,7 @@ mod tests {
                     .after("3")
                     .after("4"),
             );
-        stage.initialize_systems(&mut world, &mut resources);
+        stage.initialize_systems(&mut world);
         stage.rebuild_orders_and_dependencies();
         let ambiguities = find_ambiguities_labels(&stage.parallel);
         assert!(
@@ -1437,7 +1438,7 @@ mod tests {
             .with_system(empty.exclusive_system().label("5").after("4"))
             .with_system(empty.exclusive_system().label("6").after("5"))
             .with_system(empty.exclusive_system().label("7").after("6"));
-        stage.initialize_systems(&mut world, &mut resources);
+        stage.initialize_systems(&mut world);
         stage.rebuild_orders_and_dependencies();
         assert_eq!(find_ambiguities(&stage.exclusive_at_start).len(), 0);
 
@@ -1449,7 +1450,7 @@ mod tests {
             .with_system(empty.exclusive_system().label("4").after("3").before("5"))
             .with_system(empty.exclusive_system().label("5"))
             .with_system(empty.exclusive_system().label("6").after("2").after("5"));
-        stage.initialize_systems(&mut world, &mut resources);
+        stage.initialize_systems(&mut world);
         stage.rebuild_orders_and_dependencies();
         let ambiguities = find_ambiguities_labels(&stage.exclusive_at_start);
         assert!(
@@ -1486,7 +1487,7 @@ mod tests {
             .with_system(empty.exclusive_system().label("4").after("3").before("5"))
             .with_system(empty.exclusive_system().label("5").in_ambiguity_set("a"))
             .with_system(empty.exclusive_system().label("6").after("2").after("5"));
-        stage.initialize_systems(&mut world, &mut resources);
+        stage.initialize_systems(&mut world);
         stage.rebuild_orders_and_dependencies();
         let ambiguities = find_ambiguities_labels(&stage.exclusive_at_start);
         assert!(
@@ -1512,9 +1513,19 @@ mod tests {
             .with_system(empty.exclusive_system().label("1").in_ambiguity_set("a"))
             .with_system(empty.exclusive_system().label("2").in_ambiguity_set("a"))
             .with_system(empty.exclusive_system().label("3").in_ambiguity_set("a"));
-        stage.initialize_systems(&mut world, &mut resources);
+        stage.initialize_systems(&mut world);
         stage.rebuild_orders_and_dependencies();
         let ambiguities = find_ambiguities_labels(&stage.exclusive_at_start);
         assert_eq!(ambiguities.len(), 0);
     }
+
+    #[test]
+    #[should_panic]
+    fn multiple_worlds_same_stage() {
+        let mut world_a = World::default();
+        let mut world_b = World::default();
+        let mut stage = SystemStage::parallel();
+        stage.run(&mut world_a);
+        stage.run(&mut world_b);
+    }
 }
diff --git a/crates/bevy_ecs/src/schedule/state.rs b/crates/bevy_ecs/src/schedule/state.rs
index d992894ec0990..0ffbb84069140 100644
--- a/crates/bevy_ecs/src/schedule/state.rs
+++ b/crates/bevy_ecs/src/schedule/state.rs
@@ -1,4 +1,8 @@
-use crate::{Resource, Resources, Stage, SystemDescriptor, SystemStage, World};
+use crate::{
+    component::Component,
+    schedule::{Stage, SystemDescriptor, SystemStage},
+    world::World,
+};
 use bevy_utils::HashMap;
 use std::{mem::Discriminant, ops::Deref};
 use thiserror::Error;
@@ -137,12 +141,12 @@ impl<T> StateStage<T> {
 }
 
 #[allow(clippy::mem_discriminant_non_enum)]
-impl<T: Resource + Clone> Stage for StateStage<T> {
-    fn run(&mut self, world: &mut World, resources: &mut Resources) {
+impl<T: Component + Clone> Stage for StateStage<T> {
+    fn run(&mut self, world: &mut World) {
         let current_stage = loop {
             let (next_stage, current_stage) = {
-                let mut state = resources
-                    .get_mut::<State<T>>()
+                let mut state = world
+                    .get_resource_mut::<State<T>>()
                     .expect("Missing state resource");
                 let result = (
                     state.next.as_ref().map(|next| std::mem::discriminant(next)),
@@ -158,12 +162,12 @@ impl<T: Resource + Clone> Stage for StateStage<T> {
             if let Some(next_stage) = next_stage {
                 if next_stage != current_stage {
                     if let Some(current_state_stages) = self.stages.get_mut(&current_stage) {
-                        current_state_stages.exit.run(world, resources);
+                        current_state_stages.exit.run(world);
                     }
                 }
 
                 if let Some(next_state_stages) = self.stages.get_mut(&next_stage) {
-                    next_state_stages.enter.run(world, resources);
+                    next_state_stages.enter.run(world);
                 }
             } else {
                 break current_stage;
@@ -171,7 +175,7 @@ impl<T: Resource + Clone> Stage for StateStage<T> {
         };
 
         if let Some(current_state_stages) = self.stages.get_mut(&current_stage) {
-            current_state_stages.update.run(world, resources);
+            current_state_stages.update.run(world);
         }
     }
 }
diff --git a/crates/bevy_ecs/src/schedule/system_container.rs b/crates/bevy_ecs/src/schedule/system_container.rs
index 1335639b5db04..28f313904deee 100644
--- a/crates/bevy_ecs/src/schedule/system_container.rs
+++ b/crates/bevy_ecs/src/schedule/system_container.rs
@@ -1,9 +1,11 @@
-use std::{borrow::Cow, ptr::NonNull};
-
 use crate::{
-    BoxedAmbiguitySetLabel, BoxedSystemLabel, ExclusiveSystem, ExclusiveSystemDescriptor,
-    ParallelSystemDescriptor, System,
+    schedule::{
+        BoxedAmbiguitySetLabel, BoxedSystemLabel, ExclusiveSystemDescriptor,
+        ParallelSystemDescriptor,
+    },
+    system::{ExclusiveSystem, System},
 };
+use std::{borrow::Cow, ptr::NonNull};
 
 pub(super) trait SystemContainer {
     fn display_name(&self) -> Cow<'static, str>;
@@ -139,10 +141,6 @@ impl SystemContainer for ParallelSystemContainer {
         self.system()
             .component_access()
             .is_compatible(other.system().component_access())
-            && self
-                .system()
-                .resource_access()
-                .is_compatible(other.system().resource_access())
     }
 }
 
diff --git a/crates/bevy_ecs/src/schedule/system_descriptor.rs b/crates/bevy_ecs/src/schedule/system_descriptor.rs
index 205033737982b..ec1c3c508fa3c 100644
--- a/crates/bevy_ecs/src/schedule/system_descriptor.rs
+++ b/crates/bevy_ecs/src/schedule/system_descriptor.rs
@@ -1,6 +1,6 @@
 use crate::{
-    AmbiguitySetLabel, BoxedAmbiguitySetLabel, BoxedSystem, BoxedSystemLabel, ExclusiveSystem,
-    ExclusiveSystemCoerced, ExclusiveSystemFn, System, SystemLabel,
+    schedule::{AmbiguitySetLabel, BoxedAmbiguitySetLabel, BoxedSystemLabel, SystemLabel},
+    system::{BoxedSystem, ExclusiveSystem, ExclusiveSystemCoerced, ExclusiveSystemFn, System},
 };
 
 /// Encapsulates a system and information on when it run in a `SystemStage`.
diff --git a/crates/bevy_ecs/src/schedule/system_set.rs b/crates/bevy_ecs/src/schedule/system_set.rs
index 5a4005e58b3b0..1b1f5827d3aac 100644
--- a/crates/bevy_ecs/src/schedule/system_set.rs
+++ b/crates/bevy_ecs/src/schedule/system_set.rs
@@ -1,4 +1,7 @@
-use crate::{RunCriteria, ShouldRun, System, SystemDescriptor};
+use crate::{
+    schedule::{RunCriteria, ShouldRun, SystemDescriptor},
+    system::System,
+};
 
 /// Describes a group of systems sharing one run criterion.
 pub struct SystemSet {
diff --git a/crates/bevy_ecs/src/storage/blob_vec.rs b/crates/bevy_ecs/src/storage/blob_vec.rs
new file mode 100644
index 0000000000000..56e1026e1300d
--- /dev/null
+++ b/crates/bevy_ecs/src/storage/blob_vec.rs
@@ -0,0 +1,376 @@
+use std::{
+    alloc::{handle_alloc_error, Layout},
+    cell::UnsafeCell,
+    ptr::NonNull,
+};
+
+#[derive(Debug)]
+pub struct BlobVec {
+    item_layout: Layout,
+    capacity: usize,
+    len: usize,
+    data: UnsafeCell<NonNull<u8>>,
+    swap_scratch: UnsafeCell<NonNull<u8>>,
+    drop: unsafe fn(*mut u8),
+}
+
+impl BlobVec {
+    pub fn new(item_layout: Layout, drop: unsafe fn(*mut u8), capacity: usize) -> BlobVec {
+        if item_layout.size() == 0 {
+            BlobVec {
+                swap_scratch: UnsafeCell::new(NonNull::dangling()),
+                data: UnsafeCell::new(NonNull::dangling()),
+                capacity: usize::MAX,
+                len: 0,
+                item_layout,
+                drop,
+            }
+        } else {
+            let swap_scratch = NonNull::new(unsafe { std::alloc::alloc(item_layout) })
+                .unwrap_or_else(|| std::alloc::handle_alloc_error(item_layout));
+            let mut blob_vec = BlobVec {
+                swap_scratch: UnsafeCell::new(swap_scratch),
+                data: UnsafeCell::new(NonNull::dangling()),
+                capacity: 0,
+                len: 0,
+                item_layout,
+                drop,
+            };
+            blob_vec.reserve(capacity);
+            blob_vec
+        }
+    }
+
+    #[inline]
+    pub fn len(&self) -> usize {
+        self.len
+    }
+
+    #[inline]
+    pub fn is_empty(&self) -> bool {
+        self.len == 0
+    }
+
+    #[inline]
+    pub fn capacity(&self) -> usize {
+        self.capacity
+    }
+
+    pub fn reserve(&mut self, amount: usize) {
+        let available_space = self.capacity - self.len;
+        if available_space < amount {
+            self.grow(amount - available_space);
+        }
+    }
+
+    fn grow(&mut self, increment: usize) {
+        debug_assert!(self.item_layout.size() != 0);
+
+        let new_capacity = self.capacity + increment;
+        let new_layout =
+            array_layout(&self.item_layout, new_capacity).expect("array layout should be valid");
+        unsafe {
+            let new_data = if self.capacity == 0 {
+                std::alloc::alloc(new_layout)
+            } else {
+                std::alloc::realloc(
+                    self.get_ptr().as_ptr(),
+                    array_layout(&self.item_layout, self.capacity)
+                        .expect("array layout should be valid"),
+                    new_layout.size(),
+                )
+            };
+
+            self.data = UnsafeCell::new(
+                NonNull::new(new_data).unwrap_or_else(|| handle_alloc_error(new_layout)),
+            );
+        }
+        self.capacity = new_capacity;
+    }
+
+    /// # Safety
+    /// `index` must be in bounds
+    /// Allows aliased mutable access to `index`'s data. Caller must ensure this does not happen
+    #[inline]
+    pub unsafe fn set_unchecked(&self, index: usize, value: *mut u8) {
+        debug_assert!(index < self.len());
+        let ptr = self.get_unchecked(index);
+        std::ptr::copy_nonoverlapping(value, ptr, self.item_layout.size());
+    }
+
+    /// increases the length by one (and grows the vec if needed) with uninitialized memory and returns the index
+    /// # Safety
+    /// the newly allocated space must be immediately populated with a valid value
+    #[inline]
+    pub unsafe fn push_uninit(&mut self) -> usize {
+        self.reserve(1);
+        let index = self.len;
+        self.len += 1;
+        index
+    }
+
+    /// # Safety
+    /// len must be <= capacity. if length is decreased, "out of bounds" items must be dropped. Newly added items must be
+    /// immediately populated with valid values and length must be increased. For better unwind safety, call [BlobVec::set_len]
+    /// _after_ populating a new value.
+    pub unsafe fn set_len(&mut self, len: usize) {
+        debug_assert!(len <= self.capacity());
+        self.len = len;
+    }
+
+    /// Performs a "swap remove" at the given `index`, which removes the item at `index` and moves the last item
+    /// in the [BlobVec] to `index` (if `index` is not the last item). It is the caller's responsibility to
+    /// drop the returned pointer, if that is desirable.
+    /// # Safety
+    /// It is the caller's responsibility to ensure that `index` is < self.len()
+    /// Callers should _only_ access the returned pointer immediately after calling this function.
+    #[inline]
+    pub unsafe fn swap_remove_and_forget_unchecked(&mut self, index: usize) -> *mut u8 {
+        debug_assert!(index < self.len());
+        let last = self.len - 1;
+        let swap_scratch = (*self.swap_scratch.get()).as_ptr();
+        std::ptr::copy_nonoverlapping(
+            self.get_unchecked(index),
+            swap_scratch,
+            self.item_layout.size(),
+        );
+        std::ptr::copy(
+            self.get_unchecked(last),
+            self.get_unchecked(index),
+            self.item_layout.size(),
+        );
+        self.len -= 1;
+        swap_scratch
+    }
+
+    /// # Safety
+    /// index must be in-bounds
+    #[inline]
+    pub unsafe fn swap_remove_and_drop_unchecked(&mut self, index: usize) {
+        debug_assert!(index < self.len());
+        let value = self.swap_remove_and_forget_unchecked(index);
+        (self.drop)(value)
+    }
+
+    /// # Safety
+    /// It is the caller's responsibility to ensure that `index` is < self.len()
+    #[inline]
+    pub unsafe fn get_unchecked(&self, index: usize) -> *mut u8 {
+        debug_assert!(index < self.len());
+        self.get_ptr().as_ptr().add(index * self.item_layout.size())
+    }
+
+    /// Gets a pointer to the start of the vec
+    /// # Safety
+    /// must ensure rust mutability rules are not violated
+    #[inline]
+    pub unsafe fn get_ptr(&self) -> NonNull<u8> {
+        *self.data.get()
+    }
+
+    pub fn clear(&mut self) {
+        let len = self.len;
+        // We set len to 0 _before_ dropping elements for unwind safety. This ensures we don't accidentally
+        // drop elements twice in the event of a drop impl panicking.
+        self.len = 0;
+        for i in 0..len {
+            unsafe {
+                // NOTE: this doesn't use self.get_unchecked(i) because the debug_assert on index will
+                // panic here due to self.len being set to 0
+                let ptr = self.get_ptr().as_ptr().add(i * self.item_layout.size());
+                (self.drop)(ptr);
+            }
+        }
+    }
+}
+
+impl Drop for BlobVec {
+    fn drop(&mut self) {
+        self.clear();
+        if self.item_layout.size() > 0 {
+            unsafe {
+                std::alloc::dealloc(
+                    self.get_ptr().as_ptr(),
+                    array_layout(&self.item_layout, self.capacity)
+                        .expect("array layout should be valid"),
+                );
+                std::alloc::dealloc((*self.swap_scratch.get()).as_ptr(), self.item_layout);
+            }
+        }
+    }
+}
+
+/// From https://doc.rust-lang.org/beta/src/core/alloc/layout.rs.html
+fn array_layout(layout: &Layout, n: usize) -> Option<Layout> {
+    let (array_layout, offset) = repeat_layout(layout, n)?;
+    debug_assert_eq!(layout.size(), offset);
+    Some(array_layout)
+}
+
+// TODO: replace with Layout::repeat if/when it stabilizes
+/// From https://doc.rust-lang.org/beta/src/core/alloc/layout.rs.html
+fn repeat_layout(layout: &Layout, n: usize) -> Option<(Layout, usize)> {
+    // This cannot overflow. Quoting from the invariant of Layout:
+    // > `size`, when rounded up to the nearest multiple of `align`,
+    // > must not overflow (i.e., the rounded value must be less than
+    // > `usize::MAX`)
+    let padded_size = layout.size() + padding_needed_for(layout, layout.align());
+    let alloc_size = padded_size.checked_mul(n)?;
+
+    // SAFETY: self.align is already known to be valid and alloc_size has been
+    // padded already.
+    unsafe {
+        Some((
+            Layout::from_size_align_unchecked(alloc_size, layout.align()),
+            padded_size,
+        ))
+    }
+}
+
+/// From https://doc.rust-lang.org/beta/src/core/alloc/layout.rs.html
+const fn padding_needed_for(layout: &Layout, align: usize) -> usize {
+    let len = layout.size();
+
+    // Rounded up value is:
+    //   len_rounded_up = (len + align - 1) & !(align - 1);
+    // and then we return the padding difference: `len_rounded_up - len`.
+    //
+    // We use modular arithmetic throughout:
+    //
+    // 1. align is guaranteed to be > 0, so align - 1 is always
+    //    valid.
+    //
+    // 2. `len + align - 1` can overflow by at most `align - 1`,
+    //    so the &-mask with `!(align - 1)` will ensure that in the
+    //    case of overflow, `len_rounded_up` will itself be 0.
+    //    Thus the returned padding, when added to `len`, yields 0,
+    //    which trivially satisfies the alignment `align`.
+    //
+    // (Of course, attempts to allocate blocks of memory whose
+    // size and padding overflow in the above manner should cause
+    // the allocator to yield an error anyway.)
+
+    let len_rounded_up = len.wrapping_add(align).wrapping_sub(1) & !align.wrapping_sub(1);
+    len_rounded_up.wrapping_sub(len)
+}
+
+#[cfg(test)]
+mod tests {
+    use super::BlobVec;
+    use crate::component::TypeInfo;
+    use std::{alloc::Layout, cell::RefCell, rc::Rc};
+
+    /// # Safety:
+    /// `blob_vec` must have a layout that matches Layout::new::<T>()
+    unsafe fn push<T>(blob_vec: &mut BlobVec, mut value: T) {
+        let index = blob_vec.push_uninit();
+        blob_vec.set_unchecked(index, (&mut value as *mut T).cast::<u8>());
+        std::mem::forget(value);
+    }
+
+    /// # Safety:
+    /// `blob_vec` must have a layout that matches Layout::new::<T>()
+    unsafe fn swap_remove<T>(blob_vec: &mut BlobVec, index: usize) -> T {
+        assert!(index < blob_vec.len());
+        let value = blob_vec.swap_remove_and_forget_unchecked(index);
+        value.cast::<T>().read()
+    }
+
+    /// # Safety:
+    /// `blob_vec` must have a layout that matches Layout::new::<T>(), it most store a valid T value at
+    /// the given `index`
+    unsafe fn get_mut<T>(blob_vec: &mut BlobVec, index: usize) -> &mut T {
+        assert!(index < blob_vec.len());
+        &mut *blob_vec.get_unchecked(index).cast::<T>()
+    }
+
+    #[test]
+    fn resize_test() {
+        let item_layout = Layout::new::<usize>();
+        let drop = TypeInfo::drop_ptr::<usize>;
+        let mut blob_vec = BlobVec::new(item_layout, drop, 64);
+        unsafe {
+            for i in 0..1_000 {
+                push(&mut blob_vec, i as usize);
+            }
+        }
+
+        assert_eq!(blob_vec.len(), 1_000);
+        assert_eq!(blob_vec.capacity(), 1_000);
+    }
+
+    #[derive(Debug, Eq, PartialEq, Clone)]
+    struct Foo {
+        a: u8,
+        b: String,
+        drop_counter: Rc<RefCell<usize>>,
+    }
+
+    impl Drop for Foo {
+        fn drop(&mut self) {
+            *self.drop_counter.borrow_mut() += 1;
+        }
+    }
+
+    #[test]
+    fn blob_vec() {
+        let drop_counter = Rc::new(RefCell::new(0));
+        {
+            let item_layout = Layout::new::<Foo>();
+            let drop = TypeInfo::drop_ptr::<Foo>;
+            let mut blob_vec = BlobVec::new(item_layout, drop, 2);
+            assert_eq!(blob_vec.capacity(), 2);
+            unsafe {
+                let foo1 = Foo {
+                    a: 42,
+                    b: "abc".to_string(),
+                    drop_counter: drop_counter.clone(),
+                };
+                push(&mut blob_vec, foo1.clone());
+                assert_eq!(blob_vec.len(), 1);
+                assert_eq!(get_mut::<Foo>(&mut blob_vec, 0), &foo1);
+
+                let mut foo2 = Foo {
+                    a: 7,
+                    b: "xyz".to_string(),
+                    drop_counter: drop_counter.clone(),
+                };
+                push::<Foo>(&mut blob_vec, foo2.clone());
+                assert_eq!(blob_vec.len(), 2);
+                assert_eq!(blob_vec.capacity(), 2);
+                assert_eq!(get_mut::<Foo>(&mut blob_vec, 0), &foo1);
+                assert_eq!(get_mut::<Foo>(&mut blob_vec, 1), &foo2);
+
+                get_mut::<Foo>(&mut blob_vec, 1).a += 1;
+                assert_eq!(get_mut::<Foo>(&mut blob_vec, 1).a, 8);
+
+                let foo3 = Foo {
+                    a: 16,
+                    b: "123".to_string(),
+                    drop_counter: drop_counter.clone(),
+                };
+
+                push(&mut blob_vec, foo3.clone());
+                assert_eq!(blob_vec.len(), 3);
+                assert_eq!(blob_vec.capacity(), 3);
+
+                let last_index = blob_vec.len() - 1;
+                let value = swap_remove::<Foo>(&mut blob_vec, last_index);
+                assert_eq!(foo3, value);
+
+                assert_eq!(blob_vec.len(), 2);
+                assert_eq!(blob_vec.capacity(), 3);
+
+                let value = swap_remove::<Foo>(&mut blob_vec, 0);
+                assert_eq!(foo1, value);
+                assert_eq!(blob_vec.len(), 1);
+                assert_eq!(blob_vec.capacity(), 3);
+
+                foo2.a = 8;
+                assert_eq!(get_mut::<Foo>(&mut blob_vec, 0), &foo2);
+            }
+        }
+
+        assert_eq!(*drop_counter.borrow(), 6);
+    }
+}
diff --git a/crates/bevy_ecs/src/storage/mod.rs b/crates/bevy_ecs/src/storage/mod.rs
new file mode 100644
index 0000000000000..5c93815f4d7ce
--- /dev/null
+++ b/crates/bevy_ecs/src/storage/mod.rs
@@ -0,0 +1,13 @@
+mod blob_vec;
+mod sparse_set;
+mod table;
+
+pub use blob_vec::*;
+pub use sparse_set::*;
+pub use table::*;
+
+#[derive(Default)]
+pub struct Storages {
+    pub sparse_sets: SparseSets,
+    pub tables: Tables,
+}
diff --git a/crates/bevy_ecs/src/storage/sparse_set.rs b/crates/bevy_ecs/src/storage/sparse_set.rs
new file mode 100644
index 0000000000000..cf4ea2b3d40ec
--- /dev/null
+++ b/crates/bevy_ecs/src/storage/sparse_set.rs
@@ -0,0 +1,507 @@
+use crate::{
+    component::{ComponentFlags, ComponentId, ComponentInfo},
+    entity::Entity,
+    storage::BlobVec,
+};
+use std::{cell::UnsafeCell, marker::PhantomData};
+
+#[derive(Debug)]
+pub struct SparseArray<I, V = I> {
+    values: Vec<Option<V>>,
+    marker: PhantomData<I>,
+}
+
+impl<I: SparseSetIndex, V> Default for SparseArray<I, V> {
+    fn default() -> Self {
+        Self::new()
+    }
+}
+
+impl<I, V> SparseArray<I, V> {
+    #[inline]
+    pub const fn new() -> Self {
+        Self {
+            values: Vec::new(),
+            marker: PhantomData,
+        }
+    }
+}
+
+impl<I: SparseSetIndex, V> SparseArray<I, V> {
+    pub fn with_capacity(capacity: usize) -> Self {
+        Self {
+            values: Vec::with_capacity(capacity),
+            marker: PhantomData,
+        }
+    }
+
+    #[inline]
+    pub fn insert(&mut self, index: I, value: V) {
+        let index = index.sparse_set_index();
+        if index >= self.values.len() {
+            self.values.resize_with(index + 1, || None);
+        }
+        self.values[index] = Some(value);
+    }
+
+    #[inline]
+    pub fn contains(&self, index: I) -> bool {
+        let index = index.sparse_set_index();
+        self.values.get(index).map(|v| v.is_some()).unwrap_or(false)
+    }
+
+    #[inline]
+    pub fn get(&self, index: I) -> Option<&V> {
+        let index = index.sparse_set_index();
+        self.values.get(index).map(|v| v.as_ref()).unwrap_or(None)
+    }
+
+    #[inline]
+    pub fn get_mut(&mut self, index: I) -> Option<&mut V> {
+        let index = index.sparse_set_index();
+        self.values
+            .get_mut(index)
+            .map(|v| v.as_mut())
+            .unwrap_or(None)
+    }
+
+    #[inline]
+    pub fn remove(&mut self, index: I) -> Option<V> {
+        let index = index.sparse_set_index();
+        self.values.get_mut(index).and_then(|value| value.take())
+    }
+
+    #[inline]
+    pub fn get_or_insert_with(&mut self, index: I, func: impl FnOnce() -> V) -> &mut V {
+        let index = index.sparse_set_index();
+        if index < self.values.len() {
+            return self.values[index].get_or_insert_with(func);
+        }
+        self.values.resize_with(index + 1, || None);
+        let value = &mut self.values[index];
+        *value = Some(func());
+        value.as_mut().unwrap()
+    }
+}
+
+#[derive(Debug)]
+pub struct ComponentSparseSet {
+    dense: BlobVec,
+    flags: UnsafeCell<Vec<ComponentFlags>>,
+    entities: Vec<Entity>,
+    sparse: SparseArray<Entity, usize>,
+}
+
+impl ComponentSparseSet {
+    pub fn new(component_info: &ComponentInfo, capacity: usize) -> Self {
+        Self {
+            dense: BlobVec::new(component_info.layout(), component_info.drop(), capacity),
+            flags: UnsafeCell::new(Vec::with_capacity(capacity)),
+            entities: Vec::with_capacity(capacity),
+            sparse: Default::default(),
+        }
+    }
+
+    #[inline]
+    pub fn len(&self) -> usize {
+        self.dense.len()
+    }
+
+    #[inline]
+    pub fn is_empty(&self) -> bool {
+        self.dense.len() == 0
+    }
+
+    /// Inserts the `entity` key and component `value` pair into this sparse set.
+    /// The caller is responsible for ensuring the value is not dropped. This collection will drop the value when needed.
+    /// # Safety
+    /// The `value` pointer must point to a valid address that matches the `Layout` inside the `ComponentInfo` given
+    /// when constructing this sparse set.
+    pub unsafe fn insert(&mut self, entity: Entity, value: *mut u8, flags: ComponentFlags) {
+        let dense = &mut self.dense;
+        let entities = &mut self.entities;
+        let flag_list = self.flags.get_mut();
+        let dense_index = *self.sparse.get_or_insert_with(entity, move || {
+            flag_list.push(ComponentFlags::empty());
+            entities.push(entity);
+            dense.push_uninit()
+        });
+        // SAFE: dense_index exists thanks to the call above
+        self.dense.set_unchecked(dense_index, value);
+        (*self.flags.get())
+            .get_unchecked_mut(dense_index)
+            .insert(flags);
+    }
+
+    #[inline]
+    pub fn contains(&self, entity: Entity) -> bool {
+        self.sparse.contains(entity)
+    }
+
+    /// # Safety
+    /// ensure the same entity is not accessed twice at the same time
+    #[inline]
+    pub fn get(&self, entity: Entity) -> Option<*mut u8> {
+        self.sparse.get(entity).map(|dense_index| {
+            // SAFE: if the sparse index points to something in the dense vec, it exists
+            unsafe { self.dense.get_unchecked(*dense_index) }
+        })
+    }
+
+    /// # Safety
+    /// ensure the same entity is not accessed twice at the same time
+    #[inline]
+    pub unsafe fn get_with_flags(&self, entity: Entity) -> Option<(*mut u8, *mut ComponentFlags)> {
+        let flags = &mut *self.flags.get();
+        self.sparse.get(entity).map(move |dense_index| {
+            let dense_index = *dense_index;
+            // SAFE: if the sparse index points to something in the dense vec, it exists
+            (
+                self.dense.get_unchecked(dense_index),
+                flags.get_unchecked_mut(dense_index) as *mut ComponentFlags,
+            )
+        })
+    }
+
+    /// # Safety
+    /// ensure the same entity is not accessed twice at the same time
+    #[inline]
+    pub unsafe fn get_flags(&self, entity: Entity) -> Option<&mut ComponentFlags> {
+        let flags = &mut *self.flags.get();
+        self.sparse.get(entity).map(move |dense_index| {
+            let dense_index = *dense_index;
+            // SAFE: if the sparse index points to something in the dense vec, it exists
+            flags.get_unchecked_mut(dense_index)
+        })
+    }
+
+    /// Removes the `entity` from this sparse set and returns a pointer to the associated value (if it exists).
+    /// It is the caller's responsibility to drop the returned ptr (if Some is returned).
+    pub fn remove_and_forget(&mut self, entity: Entity) -> Option<*mut u8> {
+        self.sparse.remove(entity).map(|dense_index| {
+            // SAFE: unique access to flags
+            unsafe {
+                (*self.flags.get()).swap_remove(dense_index);
+            }
+            self.entities.swap_remove(dense_index);
+            let is_last = dense_index == self.dense.len() - 1;
+            // SAFE: dense_index was just removed from `sparse`, which ensures that it is valid
+            let value = unsafe { self.dense.swap_remove_and_forget_unchecked(dense_index) };
+            if !is_last {
+                let swapped_entity = self.entities[dense_index];
+                *self.sparse.get_mut(swapped_entity).unwrap() = dense_index;
+            }
+            value
+        })
+    }
+
+    pub fn remove(&mut self, entity: Entity) -> bool {
+        if let Some(dense_index) = self.sparse.remove(entity) {
+            self.flags.get_mut().swap_remove(dense_index);
+            self.entities.swap_remove(dense_index);
+            let is_last = dense_index == self.dense.len() - 1;
+            // SAFE: if the sparse index points to something in the dense vec, it exists
+            unsafe { self.dense.swap_remove_and_drop_unchecked(dense_index) }
+            if !is_last {
+                let swapped_entity = self.entities[dense_index];
+                *self.sparse.get_mut(swapped_entity).unwrap() = dense_index;
+            }
+            true
+        } else {
+            false
+        }
+    }
+
+    pub(crate) fn clear_flags(&mut self) {
+        let flags = self.flags.get_mut().iter_mut();
+        for component_flags in flags {
+            *component_flags = ComponentFlags::empty();
+        }
+    }
+}
+
+#[derive(Debug)]
+pub struct SparseSet<I, V: 'static> {
+    dense: Vec<V>,
+    indices: Vec<I>,
+    sparse: SparseArray<I, usize>,
+}
+
+impl<I: SparseSetIndex, V> Default for SparseSet<I, V> {
+    fn default() -> Self {
+        Self::new()
+    }
+}
+impl<I, V> SparseSet<I, V> {
+    pub const fn new() -> Self {
+        Self {
+            dense: Vec::new(),
+            indices: Vec::new(),
+            sparse: SparseArray::new(),
+        }
+    }
+}
+
+impl<I: SparseSetIndex, V> SparseSet<I, V> {
+    pub fn with_capacity(capacity: usize) -> Self {
+        Self {
+            dense: Vec::with_capacity(capacity),
+            indices: Vec::with_capacity(capacity),
+            sparse: Default::default(),
+        }
+    }
+
+    #[inline]
+    pub fn capacity(&self) -> usize {
+        self.dense.capacity()
+    }
+
+    pub fn insert(&mut self, index: I, value: V) {
+        if let Some(dense_index) = self.sparse.get(index.clone()).cloned() {
+            // SAFE: dense indices stored in self.sparse always exist
+            unsafe {
+                *self.dense.get_unchecked_mut(dense_index) = value;
+            }
+        } else {
+            self.sparse.insert(index.clone(), self.dense.len());
+            self.indices.push(index);
+            self.dense.push(value);
+        }
+
+        // PERF: switch to this. it's faster but it has an invalid memory access on table_add_remove_many
+        // let dense = &mut self.dense;
+        // let indices = &mut self.indices;
+        // let dense_index = *self.sparse.get_or_insert_with(index.clone(), move || {
+        //     if dense.len() == dense.capacity() {
+        //         dense.reserve(64);
+        //         indices.reserve(64);
+        //     }
+        //     let len = dense.len();
+        //     // SAFE: we set the index immediately
+        //     unsafe {
+        //         dense.set_len(len + 1);
+        //         indices.set_len(len + 1);
+        //     }
+        //     len
+        // });
+        // // SAFE: index either already existed or was just allocated
+        // unsafe {
+        //     *self.dense.get_unchecked_mut(dense_index) = value;
+        //     *self.indices.get_unchecked_mut(dense_index) = index;
+        // }
+    }
+
+    pub fn get_or_insert_with(&mut self, index: I, func: impl FnOnce() -> V) -> &mut V {
+        if let Some(dense_index) = self.sparse.get(index.clone()).cloned() {
+            // SAFE: dense indices stored in self.sparse always exist
+            unsafe { self.dense.get_unchecked_mut(dense_index) }
+        } else {
+            let value = func();
+            let dense_index = self.dense.len();
+            self.sparse.insert(index.clone(), dense_index);
+            self.indices.push(index);
+            self.dense.push(value);
+            // SAFE: dense index was just populated above
+            unsafe { self.dense.get_unchecked_mut(dense_index) }
+        }
+    }
+
+    #[inline]
+    pub fn len(&self) -> usize {
+        self.dense.len()
+    }
+
+    #[inline]
+    pub fn is_empty(&self) -> bool {
+        self.dense.len() == 0
+    }
+
+    #[inline]
+    pub fn contains(&self, index: I) -> bool {
+        self.sparse.contains(index)
+    }
+
+    pub fn get(&self, index: I) -> Option<&V> {
+        self.sparse.get(index).map(|dense_index| {
+            // SAFE: if the sparse index points to something in the dense vec, it exists
+            unsafe { self.dense.get_unchecked(*dense_index) }
+        })
+    }
+
+    pub fn get_mut(&mut self, index: I) -> Option<&mut V> {
+        let dense = &mut self.dense;
+        self.sparse.get(index).map(move |dense_index| {
+            // SAFE: if the sparse index points to something in the dense vec, it exists
+            unsafe { dense.get_unchecked_mut(*dense_index) }
+        })
+    }
+
+    pub fn remove(&mut self, index: I) -> Option<V> {
+        self.sparse.remove(index).map(|dense_index| {
+            let is_last = dense_index == self.dense.len() - 1;
+            let value = self.dense.swap_remove(dense_index);
+            self.indices.swap_remove(dense_index);
+            if !is_last {
+                let swapped_index = self.indices[dense_index].clone();
+                *self.sparse.get_mut(swapped_index).unwrap() = dense_index;
+            }
+            value
+        })
+    }
+
+    pub fn indices(&self) -> impl Iterator<Item = I> + '_ {
+        self.indices.iter().cloned()
+    }
+
+    pub fn values(&self) -> impl Iterator<Item = &V> {
+        self.dense.iter()
+    }
+
+    pub fn values_mut(&mut self) -> impl Iterator<Item = &mut V> {
+        self.dense.iter_mut()
+    }
+}
+
+pub trait SparseSetIndex: Clone {
+    fn sparse_set_index(&self) -> usize;
+    fn get_sparse_set_index(value: usize) -> Self;
+}
+
+impl SparseSetIndex for u8 {
+    fn sparse_set_index(&self) -> usize {
+        *self as usize
+    }
+
+    fn get_sparse_set_index(value: usize) -> Self {
+        value as u8
+    }
+}
+
+impl SparseSetIndex for u16 {
+    fn sparse_set_index(&self) -> usize {
+        *self as usize
+    }
+
+    fn get_sparse_set_index(value: usize) -> Self {
+        value as u16
+    }
+}
+
+impl SparseSetIndex for u32 {
+    fn sparse_set_index(&self) -> usize {
+        *self as usize
+    }
+
+    fn get_sparse_set_index(value: usize) -> Self {
+        value as u32
+    }
+}
+
+impl SparseSetIndex for u64 {
+    fn sparse_set_index(&self) -> usize {
+        *self as usize
+    }
+
+    fn get_sparse_set_index(value: usize) -> Self {
+        value as u64
+    }
+}
+
+impl SparseSetIndex for usize {
+    fn sparse_set_index(&self) -> usize {
+        *self
+    }
+
+    fn get_sparse_set_index(value: usize) -> Self {
+        value
+    }
+}
+
+#[derive(Default)]
+pub struct SparseSets {
+    sets: SparseSet<ComponentId, ComponentSparseSet>,
+}
+
+impl SparseSets {
+    pub fn get_or_insert(&mut self, component_info: &ComponentInfo) -> &mut ComponentSparseSet {
+        if !self.sets.contains(component_info.id()) {
+            self.sets.insert(
+                component_info.id(),
+                ComponentSparseSet::new(component_info, 64),
+            );
+        }
+
+        self.sets.get_mut(component_info.id()).unwrap()
+    }
+
+    pub fn get(&self, component_id: ComponentId) -> Option<&ComponentSparseSet> {
+        self.sets.get(component_id)
+    }
+
+    pub fn get_mut(&mut self, component_id: ComponentId) -> Option<&mut ComponentSparseSet> {
+        self.sets.get_mut(component_id)
+    }
+
+    pub(crate) fn clear_flags(&mut self) {
+        for set in self.sets.values_mut() {
+            set.clear_flags();
+        }
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use crate::{entity::Entity, storage::SparseSet};
+
+    #[derive(Debug, Eq, PartialEq)]
+    struct Foo(usize);
+
+    #[test]
+    fn sparse_set() {
+        let mut set = SparseSet::<Entity, Foo>::default();
+        let e0 = Entity::new(0);
+        let e1 = Entity::new(1);
+        let e2 = Entity::new(2);
+        let e3 = Entity::new(3);
+        let e4 = Entity::new(4);
+
+        set.insert(e1, Foo(1));
+        set.insert(e2, Foo(2));
+        set.insert(e3, Foo(3));
+
+        assert_eq!(set.get(e0), None);
+        assert_eq!(set.get(e1), Some(&Foo(1)));
+        assert_eq!(set.get(e2), Some(&Foo(2)));
+        assert_eq!(set.get(e3), Some(&Foo(3)));
+        assert_eq!(set.get(e4), None);
+
+        {
+            let iter_results = set.values().collect::<Vec<_>>();
+            assert_eq!(iter_results, vec![&Foo(1), &Foo(2), &Foo(3)])
+        }
+
+        assert_eq!(set.remove(e2), Some(Foo(2)));
+        assert_eq!(set.remove(e2), None);
+
+        assert_eq!(set.get(e0), None);
+        assert_eq!(set.get(e1), Some(&Foo(1)));
+        assert_eq!(set.get(e2), None);
+        assert_eq!(set.get(e3), Some(&Foo(3)));
+        assert_eq!(set.get(e4), None);
+
+        assert_eq!(set.remove(e1), Some(Foo(1)));
+
+        assert_eq!(set.get(e0), None);
+        assert_eq!(set.get(e1), None);
+        assert_eq!(set.get(e2), None);
+        assert_eq!(set.get(e3), Some(&Foo(3)));
+        assert_eq!(set.get(e4), None);
+
+        set.insert(e1, Foo(10));
+
+        assert_eq!(set.get(e1), Some(&Foo(10)));
+
+        *set.get_mut(e1).unwrap() = Foo(11);
+        assert_eq!(set.get(e1), Some(&Foo(11)));
+    }
+}
diff --git a/crates/bevy_ecs/src/storage/table.rs b/crates/bevy_ecs/src/storage/table.rs
new file mode 100644
index 0000000000000..45449ed58a1f0
--- /dev/null
+++ b/crates/bevy_ecs/src/storage/table.rs
@@ -0,0 +1,500 @@
+use crate::{
+    archetype::ArchetypeId,
+    component::{ComponentFlags, ComponentId, ComponentInfo, Components},
+    entity::Entity,
+    storage::{BlobVec, SparseSet},
+};
+use bevy_utils::{AHasher, HashMap};
+use std::{
+    cell::UnsafeCell,
+    hash::{Hash, Hasher},
+    ptr::NonNull,
+};
+
+#[derive(Debug, Clone, Copy, PartialEq, Eq)]
+pub struct TableId(usize);
+
+impl TableId {
+    #[inline]
+    pub fn new(index: usize) -> Self {
+        TableId(index)
+    }
+
+    #[inline]
+    pub fn index(self) -> usize {
+        self.0
+    }
+
+    #[inline]
+    pub const fn empty() -> TableId {
+        TableId(0)
+    }
+}
+
+pub struct Column {
+    pub(crate) component_id: ComponentId,
+    pub(crate) data: BlobVec,
+    pub(crate) flags: UnsafeCell<Vec<ComponentFlags>>,
+}
+
+impl Column {
+    #[inline]
+    pub fn with_capacity(component_info: &ComponentInfo, capacity: usize) -> Self {
+        Column {
+            component_id: component_info.id(),
+            data: BlobVec::new(component_info.layout(), component_info.drop(), capacity),
+            flags: UnsafeCell::new(Vec::with_capacity(capacity)),
+        }
+    }
+
+    /// # Safety
+    /// Assumes data has already been allocated for the given row/column.
+    /// Allows aliased mutable accesses to the data at the given `row`. Caller must ensure that this does not happen.
+    #[inline]
+    pub unsafe fn set_unchecked(&self, row: usize, data: *mut u8) {
+        self.data.set_unchecked(row, data);
+    }
+
+    #[inline]
+    pub fn len(&self) -> usize {
+        self.data.len()
+    }
+
+    #[inline]
+    pub fn is_empty(&self) -> bool {
+        self.data.is_empty()
+    }
+
+    /// # Safety
+    /// Assumes data has already been allocated for the given row/column.
+    /// Allows aliased mutable accesses to the row's ComponentFlags. Caller must ensure that this does not happen.
+    #[inline]
+    #[allow(clippy::mut_from_ref)]
+    pub unsafe fn get_flags_unchecked_mut(&self, row: usize) -> &mut ComponentFlags {
+        debug_assert!(row < self.len());
+        (*self.flags.get()).get_unchecked_mut(row)
+    }
+
+    #[inline]
+    pub(crate) unsafe fn swap_remove_unchecked(&mut self, row: usize) {
+        self.data.swap_remove_and_drop_unchecked(row);
+        (*self.flags.get()).swap_remove(row);
+    }
+
+    #[inline]
+    pub(crate) unsafe fn swap_remove_and_forget_unchecked(
+        &mut self,
+        row: usize,
+    ) -> (*mut u8, ComponentFlags) {
+        let data = self.data.swap_remove_and_forget_unchecked(row);
+        let flags = (*self.flags.get()).swap_remove(row);
+        (data, flags)
+    }
+
+    /// # Safety
+    /// allocated value must be immediately set at the returned row
+    pub(crate) unsafe fn push_uninit(&mut self) -> usize {
+        let row = self.data.push_uninit();
+        (*self.flags.get()).push(ComponentFlags::empty());
+        row
+    }
+
+    #[inline]
+    pub(crate) fn reserve(&mut self, additional: usize) {
+        self.data.reserve(additional);
+        // SAFE: unique access to self
+        unsafe {
+            let flags = &mut (*self.flags.get());
+            flags.reserve(additional);
+        }
+    }
+
+    /// # Safety
+    /// must ensure rust mutability rules are not violated
+    #[inline]
+    pub unsafe fn get_ptr(&self) -> NonNull<u8> {
+        self.data.get_ptr()
+    }
+
+    /// # Safety
+    /// must ensure rust mutability rules are not violated
+    #[inline]
+    pub unsafe fn get_flags_mut_ptr(&self) -> *mut ComponentFlags {
+        (*self.flags.get()).as_mut_ptr()
+    }
+
+    /// # Safety
+    /// must ensure rust mutability rules are not violated
+    #[inline]
+    pub unsafe fn get_unchecked(&self, row: usize) -> *mut u8 {
+        debug_assert!(row < self.data.len());
+        self.data.get_unchecked(row)
+    }
+
+    /// # Safety
+    /// must ensure rust mutability rules are not violated
+    #[inline]
+    pub unsafe fn get_flags_unchecked(&self, row: usize) -> *mut ComponentFlags {
+        debug_assert!(row < (*self.flags.get()).len());
+        self.get_flags_mut_ptr().add(row)
+    }
+
+    #[inline]
+    pub(crate) fn clear_flags(&mut self) {
+        let flags = unsafe { (*self.flags.get()).iter_mut() };
+        for component_flags in flags {
+            *component_flags = ComponentFlags::empty();
+        }
+    }
+}
+
+pub struct Table {
+    columns: SparseSet<ComponentId, Column>,
+    entities: Vec<Entity>,
+    archetypes: Vec<ArchetypeId>,
+    grow_amount: usize,
+    capacity: usize,
+}
+
+impl Table {
+    pub const fn new(grow_amount: usize) -> Table {
+        Self {
+            columns: SparseSet::new(),
+            entities: Vec::new(),
+            archetypes: Vec::new(),
+            grow_amount,
+            capacity: 0,
+        }
+    }
+
+    pub fn with_capacity(capacity: usize, column_capacity: usize, grow_amount: usize) -> Table {
+        Self {
+            columns: SparseSet::with_capacity(column_capacity),
+            entities: Vec::with_capacity(capacity),
+            archetypes: Vec::new(),
+            grow_amount,
+            capacity,
+        }
+    }
+
+    #[inline]
+    pub fn entities(&self) -> &[Entity] {
+        &self.entities
+    }
+
+    pub fn add_archetype(&mut self, archetype_id: ArchetypeId) {
+        self.archetypes.push(archetype_id);
+    }
+
+    pub fn add_column(&mut self, component_info: &ComponentInfo) {
+        self.columns.insert(
+            component_info.id(),
+            Column::with_capacity(component_info, self.capacity()),
+        )
+    }
+
+    /// Removes the entity at the given row and returns the entity swapped in to replace it (if an entity was swapped in)
+    /// # Safety
+    /// `row` must be in-bounds
+    pub unsafe fn swap_remove_unchecked(&mut self, row: usize) -> Option<Entity> {
+        for column in self.columns.values_mut() {
+            column.swap_remove_unchecked(row);
+        }
+        let is_last = row == self.entities.len() - 1;
+        self.entities.swap_remove(row);
+        if is_last {
+            None
+        } else {
+            Some(self.entities[row])
+        }
+    }
+
+    /// Moves the `row` column values to `new_table`, for the columns shared between both tables. Returns the index of the
+    /// new row in `new_table` and the entity in this table swapped in to replace it (if an entity was swapped in).
+    /// missing columns will be "forgotten". It is the caller's responsibility to drop them
+    /// # Safety
+    /// Row must be in-bounds
+    pub unsafe fn move_to_and_forget_missing_unchecked(
+        &mut self,
+        row: usize,
+        new_table: &mut Table,
+    ) -> TableMoveResult {
+        debug_assert!(row < self.len());
+        let is_last = row == self.entities.len() - 1;
+        let new_row = new_table.allocate(self.entities.swap_remove(row));
+        for column in self.columns.values_mut() {
+            let (data, flags) = column.swap_remove_and_forget_unchecked(row);
+            if let Some(new_column) = new_table.get_column_mut(column.component_id) {
+                new_column.set_unchecked(new_row, data);
+                *new_column.get_flags_unchecked_mut(new_row) = flags;
+            }
+        }
+        TableMoveResult {
+            new_row,
+            swapped_entity: if is_last {
+                None
+            } else {
+                Some(self.entities[row])
+            },
+        }
+    }
+
+    /// Moves the `row` column values to `new_table`, for the columns shared between both tables. Returns the index of the
+    /// new row in `new_table` and the entity in this table swapped in to replace it (if an entity was swapped in).
+    /// # Safety
+    /// row must be in-bounds
+    pub unsafe fn move_to_and_drop_missing_unchecked(
+        &mut self,
+        row: usize,
+        new_table: &mut Table,
+    ) -> TableMoveResult {
+        debug_assert!(row < self.len());
+        let is_last = row == self.entities.len() - 1;
+        let new_row = new_table.allocate(self.entities.swap_remove(row));
+        for column in self.columns.values_mut() {
+            if let Some(new_column) = new_table.get_column_mut(column.component_id) {
+                let (data, flags) = column.swap_remove_and_forget_unchecked(row);
+                new_column.set_unchecked(new_row, data);
+                *new_column.get_flags_unchecked_mut(new_row) = flags;
+            } else {
+                column.swap_remove_unchecked(row);
+            }
+        }
+        TableMoveResult {
+            new_row,
+            swapped_entity: if is_last {
+                None
+            } else {
+                Some(self.entities[row])
+            },
+        }
+    }
+
+    /// Moves the `row` column values to `new_table`, for the columns shared between both tables. Returns the index of the
+    /// new row in `new_table` and the entity in this table swapped in to replace it (if an entity was swapped in).
+    /// # Safety
+    /// `row` must be in-bounds. `new_table` must contain every component this table has
+    pub unsafe fn move_to_superset_unchecked(
+        &mut self,
+        row: usize,
+        new_table: &mut Table,
+    ) -> TableMoveResult {
+        debug_assert!(row < self.len());
+        let is_last = row == self.entities.len() - 1;
+        let new_row = new_table.allocate(self.entities.swap_remove(row));
+        for column in self.columns.values_mut() {
+            let new_column = new_table.get_column_mut(column.component_id).unwrap();
+            let (data, flags) = column.swap_remove_and_forget_unchecked(row);
+            new_column.set_unchecked(new_row, data);
+            *new_column.get_flags_unchecked_mut(new_row) = flags;
+        }
+        TableMoveResult {
+            new_row,
+            swapped_entity: if is_last {
+                None
+            } else {
+                Some(self.entities[row])
+            },
+        }
+    }
+
+    #[inline]
+    pub fn get_column(&self, component_id: ComponentId) -> Option<&Column> {
+        self.columns.get(component_id)
+    }
+
+    #[inline]
+    pub fn get_column_mut(&mut self, component_id: ComponentId) -> Option<&mut Column> {
+        self.columns.get_mut(component_id)
+    }
+
+    #[inline]
+    pub fn has_column(&self, component_id: ComponentId) -> bool {
+        self.columns.contains(component_id)
+    }
+
+    pub fn reserve(&mut self, amount: usize) {
+        let available_space = self.capacity - self.len();
+        if available_space < amount {
+            let reserve_amount = (amount - available_space).max(self.grow_amount);
+            for column in self.columns.values_mut() {
+                column.reserve(reserve_amount);
+            }
+            self.entities.reserve(reserve_amount);
+            self.capacity += reserve_amount;
+        }
+    }
+
+    /// Allocates space for a new entity
+    /// # Safety
+    /// the allocated row must be written to immediately with valid values in each column
+    pub unsafe fn allocate(&mut self, entity: Entity) -> usize {
+        self.reserve(1);
+        let index = self.entities.len();
+        self.entities.push(entity);
+        for column in self.columns.values_mut() {
+            column.data.set_len(self.entities.len());
+            (*column.flags.get()).push(ComponentFlags::empty());
+        }
+        index
+    }
+
+    #[inline]
+    pub fn capacity(&self) -> usize {
+        self.capacity
+    }
+
+    #[inline]
+    pub fn len(&self) -> usize {
+        self.entities.len()
+    }
+
+    #[inline]
+    pub fn is_empty(&self) -> bool {
+        self.entities.is_empty()
+    }
+
+    pub(crate) fn clear_flags(&mut self) {
+        for column in self.columns.values_mut() {
+            column.clear_flags();
+        }
+    }
+
+    pub fn iter(&self) -> impl Iterator<Item = &Column> {
+        self.columns.values()
+    }
+}
+
+pub struct Tables {
+    tables: Vec<Table>,
+    table_ids: HashMap<u64, TableId>,
+}
+
+impl Default for Tables {
+    fn default() -> Self {
+        let empty_table = Table::with_capacity(0, 0, 64);
+        Tables {
+            tables: vec![empty_table],
+            table_ids: HashMap::default(),
+        }
+    }
+}
+
+pub struct TableMoveResult {
+    pub swapped_entity: Option<Entity>,
+    pub new_row: usize,
+}
+
+impl Tables {
+    #[inline]
+    pub fn len(&self) -> usize {
+        self.tables.len()
+    }
+
+    #[inline]
+    pub fn is_empty(&self) -> bool {
+        self.tables.is_empty()
+    }
+
+    #[inline]
+    pub fn get_mut(&mut self, id: TableId) -> Option<&mut Table> {
+        self.tables.get_mut(id.index())
+    }
+
+    #[inline]
+    pub fn get(&self, id: TableId) -> Option<&Table> {
+        self.tables.get(id.index())
+    }
+
+    /// # Safety
+    /// `id` must be a valid table
+    #[inline]
+    pub unsafe fn get_unchecked_mut(&mut self, id: TableId) -> &mut Table {
+        debug_assert!(id.index() < self.tables.len());
+        self.tables.get_unchecked_mut(id.index())
+    }
+
+    /// # Safety
+    /// `id` must be a valid table
+    #[inline]
+    pub unsafe fn get_unchecked(&self, id: TableId) -> &Table {
+        debug_assert!(id.index() < self.tables.len());
+        self.tables.get_unchecked(id.index())
+    }
+
+    #[inline]
+    pub(crate) fn get_2_mut(&mut self, a: TableId, b: TableId) -> (&mut Table, &mut Table) {
+        if a.index() > b.index() {
+            let (b_slice, a_slice) = self.tables.split_at_mut(a.index());
+            (&mut a_slice[0], &mut b_slice[b.index()])
+        } else {
+            let (a_slice, b_slice) = self.tables.split_at_mut(b.index());
+            (&mut a_slice[a.index()], &mut b_slice[0])
+        }
+    }
+
+    /// # Safety
+    /// `component_ids` must contain components that exist in `components`
+    pub unsafe fn get_id_or_insert(
+        &mut self,
+        component_ids: &[ComponentId],
+        components: &Components,
+    ) -> TableId {
+        let mut hasher = AHasher::default();
+        component_ids.hash(&mut hasher);
+        let hash = hasher.finish();
+        let tables = &mut self.tables;
+        *self.table_ids.entry(hash).or_insert_with(move || {
+            let mut table = Table::with_capacity(0, component_ids.len(), 64);
+            for component_id in component_ids.iter() {
+                table.add_column(components.get_info_unchecked(*component_id));
+            }
+            tables.push(table);
+            TableId(tables.len() - 1)
+        })
+    }
+
+    pub fn iter(&self) -> std::slice::Iter<'_, Table> {
+        self.tables.iter()
+    }
+
+    pub(crate) fn clear_flags(&mut self) {
+        for table in self.tables.iter_mut() {
+            table.clear_flags();
+        }
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use crate::{
+        component::{Components, TypeInfo},
+        entity::Entity,
+        storage::Table,
+    };
+
+    #[test]
+    fn table() {
+        let mut components = Components::default();
+        let type_info = TypeInfo::of::<usize>();
+        let component_id = components.get_or_insert_with(type_info.type_id(), || type_info);
+        let columns = &[component_id];
+        let mut table = Table::with_capacity(0, columns.len(), 64);
+        table.add_column(components.get_info(component_id).unwrap());
+        let entities = (0..200).map(Entity::new).collect::<Vec<_>>();
+        for (row, entity) in entities.iter().cloned().enumerate() {
+            unsafe {
+                table.allocate(entity);
+                let mut value = row;
+                let value_ptr = ((&mut value) as *mut usize).cast::<u8>();
+                table
+                    .get_column(component_id)
+                    .unwrap()
+                    .set_unchecked(row, value_ptr);
+            };
+        }
+
+        assert_eq!(table.capacity(), 256);
+        assert_eq!(table.len(), 200);
+    }
+}
diff --git a/crates/bevy_ecs/src/system/commands.rs b/crates/bevy_ecs/src/system/commands.rs
index b2112c78c90ac..8b60b9ada15e3 100644
--- a/crates/bevy_ecs/src/system/commands.rs
+++ b/crates/bevy_ecs/src/system/commands.rs
@@ -1,211 +1,62 @@
-use super::SystemId;
 use crate::{
-    resource::{Resource, Resources},
-    Bundle, Component, ComponentError, DynamicBundle, Entity, EntityReserver, World,
+    bundle::Bundle,
+    component::Component,
+    entity::{Entities, Entity},
+    world::World,
 };
-use bevy_utils::tracing::{debug, warn};
+use bevy_utils::tracing::debug;
 use std::marker::PhantomData;
 
 /// A [World] mutation
-pub trait Command: Send + Sync {
-    fn write(self: Box<Self>, world: &mut World, resources: &mut Resources);
+pub trait Command: Send + Sync + 'static {
+    fn write(self: Box<Self>, world: &mut World);
 }
 
-#[derive(Debug)]
-pub(crate) struct Spawn<T>
-where
-    T: DynamicBundle + Send + Sync + 'static,
-{
-    bundle: T,
-}
-
-impl<T> Command for Spawn<T>
-where
-    T: DynamicBundle + Send + Sync + 'static,
-{
-    fn write(self: Box<Self>, world: &mut World, _resources: &mut Resources) {
-        world.spawn(self.bundle);
-    }
-}
-
-pub(crate) struct SpawnBatch<I>
-where
-    I: IntoIterator,
-    I::Item: Bundle,
-{
-    bundles_iter: I,
-}
-
-impl<I> Command for SpawnBatch<I>
-where
-    I: IntoIterator + Send + Sync,
-    I::Item: Bundle,
-{
-    fn write(self: Box<Self>, world: &mut World, _resources: &mut Resources) {
-        world.spawn_batch(self.bundles_iter);
-    }
-}
-
-#[derive(Debug)]
-pub(crate) struct Despawn {
-    entity: Entity,
+#[derive(Default)]
+pub struct CommandQueue {
+    commands: Vec<Box<dyn Command>>,
 }
 
-impl Command for Despawn {
-    fn write(self: Box<Self>, world: &mut World, _resources: &mut Resources) {
-        if let Err(e) = world.despawn(self.entity) {
-            debug!("Failed to despawn entity {:?}: {}", self.entity, e);
+impl CommandQueue {
+    pub fn apply(&mut self, world: &mut World) {
+        world.flush();
+        for command in self.commands.drain(..) {
+            command.write(world);
         }
     }
-}
-
-pub struct Insert<T>
-where
-    T: DynamicBundle + Send + Sync + 'static,
-{
-    entity: Entity,
-    bundle: T,
-}
-
-impl<T> Command for Insert<T>
-where
-    T: DynamicBundle + Send + Sync + 'static,
-{
-    fn write(self: Box<Self>, world: &mut World, _resources: &mut Resources) {
-        world.insert(self.entity, self.bundle).unwrap();
-    }
-}
-
-#[derive(Debug)]
-pub(crate) struct InsertOne<T>
-where
-    T: Component,
-{
-    entity: Entity,
-    component: T,
-}
 
-impl<T> Command for InsertOne<T>
-where
-    T: Component,
-{
-    fn write(self: Box<Self>, world: &mut World, _resources: &mut Resources) {
-        world.insert(self.entity, (self.component,)).unwrap();
-    }
-}
-
-#[derive(Debug)]
-pub(crate) struct RemoveOne<T>
-where
-    T: Component,
-{
-    entity: Entity,
-    phantom: PhantomData<T>,
-}
-
-impl<T> Command for RemoveOne<T>
-where
-    T: Component,
-{
-    fn write(self: Box<Self>, world: &mut World, _resources: &mut Resources) {
-        if world.get::<T>(self.entity).is_ok() {
-            world.remove_one::<T>(self.entity).unwrap();
-        }
+    #[inline]
+    pub fn push(&mut self, command: Box<dyn Command>) {
+        self.commands.push(command);
     }
 }
 
-#[derive(Debug)]
-pub(crate) struct Remove<T>
-where
-    T: Bundle + Send + Sync + 'static,
-{
-    entity: Entity,
-    phantom: PhantomData<T>,
+/// A list of commands that will be run to modify a `World`
+pub struct Commands<'a> {
+    queue: &'a mut CommandQueue,
+    entities: &'a Entities,
+    current_entity: Option<Entity>,
 }
 
-impl<T> Command for Remove<T>
-where
-    T: Bundle + Send + Sync + 'static,
-{
-    fn write(self: Box<Self>, world: &mut World, _resources: &mut Resources) {
-        match world.remove::<T>(self.entity) {
-            Ok(_) => (),
-            Err(ComponentError::MissingComponent(e)) => {
-                warn!(
-                    "Failed to remove components {:?} with error: {}. Falling back to inefficient one-by-one component removing.",
-                    std::any::type_name::<T>(),
-                    e
-                );
-                if let Err(e) = world.remove_one_by_one::<T>(self.entity) {
-                    debug!(
-                        "Failed to remove components {:?} with error: {}",
-                        std::any::type_name::<T>(),
-                        e
-                    );
-                }
-            }
-            Err(e) => {
-                debug!(
-                    "Failed to remove components {:?} with error: {}",
-                    std::any::type_name::<T>(),
-                    e
-                );
-            }
+impl<'a> Commands<'a> {
+    pub fn new(queue: &'a mut CommandQueue, world: &'a World) -> Self {
+        Self {
+            queue,
+            entities: world.entities(),
+            current_entity: None,
         }
     }
-}
-
-pub struct InsertResource<T: Resource> {
-    resource: T,
-}
-
-impl<T: Resource> Command for InsertResource<T> {
-    fn write(self: Box<Self>, _world: &mut World, resources: &mut Resources) {
-        resources.insert(self.resource);
-    }
-}
-
-pub struct RemoveResource<T: Resource> {
-    phantom: PhantomData<T>,
-}
-
-impl<T: Resource> Command for RemoveResource<T> {
-    fn write(self: Box<Self>, _world: &mut World, resources: &mut Resources) {
-        resources.remove::<T>();
-    }
-}
-
-#[derive(Debug)]
-pub(crate) struct InsertLocalResource<T: Resource> {
-    resource: T,
-    system_id: SystemId,
-}
-
-impl<T: Resource> Command for InsertLocalResource<T> {
-    fn write(self: Box<Self>, _world: &mut World, resources: &mut Resources) {
-        resources.insert_local(self.system_id, self.resource);
-    }
-}
-
-/// A list of commands that will be run to populate a `World` and `Resources`.
-#[derive(Default)]
-pub struct Commands {
-    commands: Vec<Box<dyn Command>>,
-    current_entity: Option<Entity>,
-    entity_reserver: Option<EntityReserver>,
-}
 
-impl Commands {
     /// Creates a new entity with the components contained in `bundle`.
     ///
-    /// Note that `bundle` is a [DynamicBundle], which is a collection of components. [DynamicBundle] is automatically implemented for tuples of components. You can also create your own bundle types by deriving [`derive@Bundle`]. If you would like to spawn an entity with a single component, consider wrapping the component in a tuple (which [DynamicBundle] is implemented for).
+    /// Note that `bundle` is a [Bundle], which is a collection of components. [Bundle] is automatically implemented for tuples of components. You can also create your own bundle types by deriving [`derive@Bundle`]. If you would like to spawn an entity with a single component, consider wrapping the component in a tuple (which [Bundle] is implemented for).
     ///
     /// See [`Self::set_current_entity`], [`Self::insert`].
     ///
     /// # Example
     ///
     /// ```
-    /// # use bevy_ecs::prelude::*;
+    /// use bevy_ecs::prelude::*;
     ///
     /// struct Component1;
     /// struct Component2;
@@ -216,7 +67,7 @@ impl Commands {
     ///     b: Component2,
     /// }
     ///
-    /// fn example_system(commands: &mut Commands) {
+    /// fn example_system(mut commands: Commands) {
     ///     // Create a new entity with a component bundle.
     ///     commands.spawn(ExampleBundle {
     ///         a: Component1,
@@ -228,17 +79,12 @@ impl Commands {
     ///     // Create a new entity with two components.
     ///     commands.spawn((Component1, Component2));
     /// }
-    ///
     /// # example_system.system();
     /// ```
-    pub fn spawn(&mut self, bundle: impl DynamicBundle + Send + Sync + 'static) -> &mut Self {
-        let entity = self
-            .entity_reserver
-            .as_ref()
-            .expect("Entity reserver has not been set.")
-            .reserve_entity();
+    pub fn spawn(&mut self, bundle: impl Bundle) -> &mut Self {
+        let entity = self.entities.reserve_entity();
         self.set_current_entity(entity);
-        self.insert(entity, bundle);
+        self.insert_bundle(entity, bundle);
         self
     }
 
@@ -258,63 +104,46 @@ impl Commands {
 
     /// Inserts a bundle of components into `entity`.
     ///
-    /// See [`World::insert`].
-    pub fn insert(
-        &mut self,
-        entity: Entity,
-        bundle: impl DynamicBundle + Send + Sync + 'static,
-    ) -> &mut Self {
-        self.add_command(Insert { entity, bundle })
+    /// See [crate::world::EntityMut::insert_bundle].
+    pub fn insert_bundle(&mut self, entity: Entity, bundle: impl Bundle) -> &mut Self {
+        self.add_command(InsertBundle { entity, bundle })
     }
 
     /// Inserts a single component into `entity`.
     ///
-    /// See [`World::insert_one`].
-    pub fn insert_one(&mut self, entity: Entity, component: impl Component) -> &mut Self {
-        self.add_command(InsertOne { entity, component })
-    }
-
-    pub fn insert_resource<T: Resource>(&mut self, resource: T) -> &mut Self {
-        self.add_command(InsertResource { resource })
-    }
-
-    /// Insert a resource that is local to a specific system.
-    ///
-    /// See [`crate::System::id`].
-    pub fn insert_local_resource<T: Resource>(
-        &mut self,
-        system_id: SystemId,
-        resource: T,
-    ) -> &mut Self {
-        self.add_command(InsertLocalResource {
-            system_id,
-            resource,
-        })
+    /// See [crate::world::EntityMut::insert].
+    pub fn insert(&mut self, entity: Entity, component: impl Component) -> &mut Self {
+        self.add_command(Insert { entity, component })
     }
 
-    /// See [`World::remove_one`].
-    pub fn remove_one<T>(&mut self, entity: Entity) -> &mut Self
+    /// See [crate::world::EntityMut::remove].
+    pub fn remove<T>(&mut self, entity: Entity) -> &mut Self
     where
         T: Component,
     {
-        self.add_command(RemoveOne::<T> {
+        self.add_command(Remove::<T> {
             entity,
             phantom: PhantomData,
         })
     }
 
-    /// See [`World::remove`].
-    pub fn remove<T>(&mut self, entity: Entity) -> &mut Self
+    /// See [World::insert_resource].
+    pub fn insert_resource<T: Component>(&mut self, resource: T) -> &mut Self {
+        self.add_command(InsertResource { resource })
+    }
+
+    /// See [crate::world::EntityMut::remove_bundle].
+    pub fn remove_bundle<T>(&mut self, entity: Entity) -> &mut Self
     where
-        T: Bundle + Send + Sync + 'static,
+        T: Bundle,
     {
-        self.add_command(Remove::<T> {
+        self.add_command(RemoveBundle::<T> {
             entity,
             phantom: PhantomData,
         })
     }
 
-    pub fn remove_resource<T: Resource>(&mut self) -> &mut Self {
+    pub fn remove_resource<T: Component>(&mut self) -> &mut Self {
         self.add_command(RemoveResource::<T> {
             phantom: PhantomData,
         })
@@ -323,9 +152,9 @@ impl Commands {
     /// Adds a bundle of components to the current entity.
     ///
     /// See [`Self::with`], [`Self::current_entity`].
-    pub fn with_bundle(&mut self, bundle: impl DynamicBundle + Send + Sync + 'static) -> &mut Self {
+    pub fn with_bundle(&mut self, bundle: impl Bundle) -> &mut Self {
         let current_entity =  self.current_entity.expect("Cannot add bundle because the 'current entity' is not set. You should spawn an entity first.");
-        self.commands.push(Box::new(Insert {
+        self.queue.push(Box::new(InsertBundle {
             entity: current_entity,
             bundle,
         }));
@@ -345,12 +174,12 @@ impl Commands {
     /// `with` can be chained with [`Self::spawn`].
     ///
     /// ```
-    /// # use bevy_ecs::prelude::*;
+    /// use bevy_ecs::prelude::*;
     ///
     /// struct Component1;
     /// struct Component2;
     ///
-    /// fn example_system(commands: &mut Commands) {
+    /// fn example_system(mut commands: Commands) {
     ///     // Create a new entity with a `Component1` and `Component2`.
     ///     commands.spawn((Component1,)).with(Component2);
     ///
@@ -367,12 +196,11 @@ impl Commands {
     ///         b: Component2,
     ///     });
     /// }
-    ///
     /// # example_system.system();
     /// ```
     pub fn with(&mut self, component: impl Component) -> &mut Self {
         let current_entity =  self.current_entity.expect("Cannot add component because the 'current entity' is not set. You should spawn an entity first.");
-        self.commands.push(Box::new(InsertOne {
+        self.queue.push(Box::new(Insert {
             entity: current_entity,
             component,
         }));
@@ -380,24 +208,17 @@ impl Commands {
     }
 
     /// Adds a command directly to the command list. Prefer this to [`Self::add_command_boxed`] if the type of `command` is statically known.
-    pub fn add_command<C: Command + 'static>(&mut self, command: C) -> &mut Self {
-        self.commands.push(Box::new(command));
+    pub fn add_command<C: Command>(&mut self, command: C) -> &mut Self {
+        self.queue.push(Box::new(command));
         self
     }
 
     /// See [`Self::add_command`].
     pub fn add_command_boxed(&mut self, command: Box<dyn Command>) -> &mut Self {
-        self.commands.push(command);
+        self.queue.push(command);
         self
     }
 
-    /// Runs all the stored commands on `world` and `resources`. The command buffer is emptied as a part of this call.
-    pub fn apply(&mut self, world: &mut World, resources: &mut Resources) {
-        for command in self.commands.drain(..) {
-            command.write(world, resources);
-        }
-    }
-
     /// Returns the current entity, set by [`Self::spawn`] or with [`Self::set_current_entity`].
     pub fn current_entity(&self) -> Option<Entity> {
         self.current_entity
@@ -418,40 +239,169 @@ impl Commands {
         f(current_entity);
         self
     }
+}
+
+#[derive(Debug)]
+pub(crate) struct Spawn<T> {
+    bundle: T,
+}
 
-    pub fn set_entity_reserver(&mut self, entity_reserver: EntityReserver) {
-        self.entity_reserver = Some(entity_reserver);
+impl<T> Command for Spawn<T>
+where
+    T: Bundle,
+{
+    fn write(self: Box<Self>, world: &mut World) {
+        world.spawn().insert_bundle(self.bundle);
+    }
+}
+
+pub(crate) struct SpawnBatch<I>
+where
+    I: IntoIterator,
+    I::Item: Bundle,
+{
+    bundles_iter: I,
+}
+
+impl<I> Command for SpawnBatch<I>
+where
+    I: IntoIterator + Send + Sync + 'static,
+    I::Item: Bundle,
+{
+    fn write(self: Box<Self>, world: &mut World) {
+        world.spawn_batch(self.bundles_iter);
+    }
+}
+
+#[derive(Debug)]
+pub(crate) struct Despawn {
+    entity: Entity,
+}
+
+impl Command for Despawn {
+    fn write(self: Box<Self>, world: &mut World) {
+        if !world.despawn(self.entity) {
+            debug!("Failed to despawn non-existent entity {:?}", self.entity);
+        }
+    }
+}
+
+pub struct InsertBundle<T> {
+    entity: Entity,
+    bundle: T,
+}
+
+impl<T> Command for InsertBundle<T>
+where
+    T: Bundle + 'static,
+{
+    fn write(self: Box<Self>, world: &mut World) {
+        world.entity_mut(self.entity).insert_bundle(self.bundle);
+    }
+}
+
+#[derive(Debug)]
+pub(crate) struct Insert<T> {
+    entity: Entity,
+    component: T,
+}
+
+impl<T> Command for Insert<T>
+where
+    T: Component,
+{
+    fn write(self: Box<Self>, world: &mut World) {
+        world.entity_mut(self.entity).insert(self.component);
+    }
+}
+
+#[derive(Debug)]
+pub(crate) struct Remove<T> {
+    entity: Entity,
+    phantom: PhantomData<T>,
+}
+
+impl<T> Command for Remove<T>
+where
+    T: Component,
+{
+    fn write(self: Box<Self>, world: &mut World) {
+        if let Some(mut entity_mut) = world.get_entity_mut(self.entity) {
+            entity_mut.remove::<T>();
+        }
+    }
+}
+
+#[derive(Debug)]
+pub(crate) struct RemoveBundle<T> {
+    entity: Entity,
+    phantom: PhantomData<T>,
+}
+
+impl<T> Command for RemoveBundle<T>
+where
+    T: Bundle,
+{
+    fn write(self: Box<Self>, world: &mut World) {
+        if let Some(mut entity_mut) = world.get_entity_mut(self.entity) {
+            // remove intersection to gracefully handle components that were removed before running this command
+            entity_mut.remove_bundle_intersection::<T>();
+        }
+    }
+}
+
+pub struct InsertResource<T: Component> {
+    resource: T,
+}
+
+impl<T: Component> Command for InsertResource<T> {
+    fn write(self: Box<Self>, world: &mut World) {
+        world.insert_resource(self.resource);
+    }
+}
+
+pub struct RemoveResource<T: Component> {
+    phantom: PhantomData<T>,
+}
+
+impl<T: Component> Command for RemoveResource<T> {
+    fn write(self: Box<Self>, world: &mut World) {
+        world.remove_resource::<T>();
     }
 }
 
 #[cfg(test)]
 #[allow(clippy::float_cmp, clippy::approx_constant)]
 mod tests {
-    use crate::{resource::Resources, Commands, World};
-    use core::any::TypeId;
+    use crate::{
+        system::{CommandQueue, Commands},
+        world::World,
+    };
 
     #[test]
-    fn command_buffer() {
+    fn commands() {
         let mut world = World::default();
-        let mut resources = Resources::default();
-        let mut command_buffer = Commands::default();
-        command_buffer.set_entity_reserver(world.get_entity_reserver());
-        command_buffer.spawn((1u32, 2u64));
-        let entity = command_buffer.current_entity().unwrap();
-        command_buffer.insert_resource(3.14f32);
-        command_buffer.apply(&mut world, &mut resources);
+        let mut command_queue = CommandQueue::default();
+        let entity = Commands::new(&mut command_queue, &world)
+            .spawn((1u32, 2u64))
+            .current_entity()
+            .unwrap();
+        command_queue.apply(&mut world);
+        assert!(world.entities().len() == 1);
         let results = world
             .query::<(&u32, &u64)>()
+            .iter(&world)
             .map(|(a, b)| (*a, *b))
             .collect::<Vec<_>>();
         assert_eq!(results, vec![(1u32, 2u64)]);
-        assert_eq!(*resources.get::<f32>().unwrap(), 3.14f32);
         // test entity despawn
-        command_buffer.despawn(entity);
-        command_buffer.despawn(entity); // double despawn shouldn't panic
-        command_buffer.apply(&mut world, &mut resources);
+        Commands::new(&mut command_queue, &world)
+            .despawn(entity)
+            .despawn(entity); // double despawn shouldn't panic
+        command_queue.apply(&mut world);
         let results2 = world
             .query::<(&u32, &u64)>()
+            .iter(&world)
             .map(|(a, b)| (*a, *b))
             .collect::<Vec<_>>();
         assert_eq!(results2, vec![]);
@@ -460,58 +410,59 @@ mod tests {
     #[test]
     fn remove_components() {
         let mut world = World::default();
-        let mut resources = Resources::default();
-        let mut command_buffer = Commands::default();
-        command_buffer.set_entity_reserver(world.get_entity_reserver());
-        command_buffer.spawn((1u32, 2u64));
-        let entity = command_buffer.current_entity().unwrap();
-        command_buffer.apply(&mut world, &mut resources);
+        let mut command_queue = CommandQueue::default();
+        let entity = Commands::new(&mut command_queue, &world)
+            .spawn((1u32, 2u64))
+            .current_entity()
+            .unwrap();
+        command_queue.apply(&mut world);
         let results_before = world
             .query::<(&u32, &u64)>()
+            .iter(&world)
             .map(|(a, b)| (*a, *b))
             .collect::<Vec<_>>();
         assert_eq!(results_before, vec![(1u32, 2u64)]);
 
         // test component removal
-        command_buffer.remove_one::<u32>(entity);
-        command_buffer.remove::<(u32, u64)>(entity);
-        command_buffer.apply(&mut world, &mut resources);
+        Commands::new(&mut command_queue, &world)
+            .remove::<u32>(entity)
+            .remove_bundle::<(u32, u64)>(entity);
+        command_queue.apply(&mut world);
         let results_after = world
             .query::<(&u32, &u64)>()
+            .iter(&world)
             .map(|(a, b)| (*a, *b))
             .collect::<Vec<_>>();
         assert_eq!(results_after, vec![]);
-        let results_after_u64 = world.query::<&u64>().copied().collect::<Vec<_>>();
+        let results_after_u64 = world
+            .query::<&u64>()
+            .iter(&world)
+            .copied()
+            .collect::<Vec<_>>();
         assert_eq!(results_after_u64, vec![]);
     }
 
     #[test]
     fn remove_resources() {
         let mut world = World::default();
-        let mut resources = Resources::default();
-        let mut command_buffer = Commands::default();
-        command_buffer.insert_resource(123);
-        command_buffer.insert_resource(456.0);
-        command_buffer.apply(&mut world, &mut resources);
-        assert_eq!(
-            resources.resource_data.contains_key(&TypeId::of::<i32>()),
-            true
-        );
-        assert_eq!(
-            resources.resource_data.contains_key(&TypeId::of::<f64>()),
-            true
-        );
-
-        // test resource removal
-        command_buffer.remove_resource::<i32>();
-        command_buffer.apply(&mut world, &mut resources);
-        assert_eq!(
-            resources.resource_data.contains_key(&TypeId::of::<i32>()),
-            false
-        );
-        assert_eq!(
-            resources.resource_data.contains_key(&TypeId::of::<f64>()),
-            true
-        );
+        let mut queue = CommandQueue::default();
+        {
+            let mut commands = Commands::new(&mut queue, &world);
+            commands.insert_resource(123);
+            commands.insert_resource(456.0);
+        }
+
+        queue.apply(&mut world);
+        assert!(world.contains_resource::<i32>());
+        assert!(world.contains_resource::<f64>());
+
+        {
+            let mut commands = Commands::new(&mut queue, &world);
+            // test resource removal
+            commands.remove_resource::<i32>();
+        }
+        queue.apply(&mut world);
+        assert!(!world.contains_resource::<i32>());
+        assert!(world.contains_resource::<f64>());
     }
 }
diff --git a/crates/bevy_ecs/src/system/exclusive_system.rs b/crates/bevy_ecs/src/system/exclusive_system.rs
index 4d2428ed176fb..9f67d6c56d528 100644
--- a/crates/bevy_ecs/src/system/exclusive_system.rs
+++ b/crates/bevy_ecs/src/system/exclusive_system.rs
@@ -1,5 +1,7 @@
-pub use super::Query;
-use crate::{resource::Resources, system::SystemId, BoxedSystem, IntoSystem, System, World};
+use crate::{
+    system::{BoxedSystem, IntoSystem, System, SystemId},
+    world::World,
+};
 use std::borrow::Cow;
 
 pub trait ExclusiveSystem: Send + Sync + 'static {
@@ -7,13 +9,13 @@ pub trait ExclusiveSystem: Send + Sync + 'static {
 
     fn id(&self) -> SystemId;
 
-    fn run(&mut self, world: &mut World, resources: &mut Resources);
+    fn run(&mut self, world: &mut World);
 
-    fn initialize(&mut self, world: &mut World, resources: &mut Resources);
+    fn initialize(&mut self, world: &mut World);
 }
 
 pub struct ExclusiveSystemFn {
-    func: Box<dyn FnMut(&mut World, &mut Resources) + Send + Sync + 'static>,
+    func: Box<dyn FnMut(&mut World) + Send + Sync + 'static>,
     name: Cow<'static, str>,
     id: SystemId,
 }
@@ -27,63 +29,24 @@ impl ExclusiveSystem for ExclusiveSystemFn {
         self.id
     }
 
-    fn run(&mut self, world: &mut World, resources: &mut Resources) {
-        (self.func)(world, resources);
+    fn run(&mut self, world: &mut World) {
+        (self.func)(world);
     }
 
-    fn initialize(&mut self, _: &mut World, _: &mut Resources) {}
+    fn initialize(&mut self, _: &mut World) {}
 }
 
 pub trait IntoExclusiveSystem<Params, SystemType> {
     fn exclusive_system(self) -> SystemType;
 }
 
-impl<F> IntoExclusiveSystem<(&mut World, &mut Resources), ExclusiveSystemFn> for F
-where
-    F: FnMut(&mut World, &mut Resources) + Send + Sync + 'static,
-{
-    fn exclusive_system(self) -> ExclusiveSystemFn {
-        ExclusiveSystemFn {
-            func: Box::new(self),
-            name: core::any::type_name::<F>().into(),
-            id: SystemId::new(),
-        }
-    }
-}
-
-impl<F> IntoExclusiveSystem<(&mut Resources, &mut World), ExclusiveSystemFn> for F
-where
-    F: FnMut(&mut Resources, &mut World) + Send + Sync + 'static,
-{
-    fn exclusive_system(mut self) -> ExclusiveSystemFn {
-        ExclusiveSystemFn {
-            func: Box::new(move |world, resources| self(resources, world)),
-            name: core::any::type_name::<F>().into(),
-            id: SystemId::new(),
-        }
-    }
-}
-
 impl<F> IntoExclusiveSystem<&mut World, ExclusiveSystemFn> for F
 where
     F: FnMut(&mut World) + Send + Sync + 'static,
 {
-    fn exclusive_system(mut self) -> ExclusiveSystemFn {
-        ExclusiveSystemFn {
-            func: Box::new(move |world, _| self(world)),
-            name: core::any::type_name::<F>().into(),
-            id: SystemId::new(),
-        }
-    }
-}
-
-impl<F> IntoExclusiveSystem<&mut Resources, ExclusiveSystemFn> for F
-where
-    F: FnMut(&mut Resources) + Send + Sync + 'static,
-{
-    fn exclusive_system(mut self) -> ExclusiveSystemFn {
+    fn exclusive_system(self) -> ExclusiveSystemFn {
         ExclusiveSystemFn {
-            func: Box::new(move |_, resources| self(resources)),
+            func: Box::new(self),
             name: core::any::type_name::<F>().into(),
             id: SystemId::new(),
         }
@@ -103,13 +66,13 @@ impl ExclusiveSystem for ExclusiveSystemCoerced {
         self.system.id()
     }
 
-    fn run(&mut self, world: &mut World, resources: &mut Resources) {
-        self.system.run((), world, resources);
-        self.system.apply_buffers(world, resources);
+    fn run(&mut self, world: &mut World) {
+        self.system.run((), world);
+        self.system.apply_buffers(world);
     }
 
-    fn initialize(&mut self, world: &mut World, resources: &mut Resources) {
-        self.system.initialize(world, resources);
+    fn initialize(&mut self, world: &mut World) {
+        self.system.initialize(world);
     }
 }
 
@@ -125,37 +88,42 @@ where
     }
 }
 
-#[test]
-fn parallel_with_commands_as_exclusive() {
+#[cfg(test)]
+mod tests {
     use crate::{
-        Commands, Entity, IntoExclusiveSystem, IntoSystem, ResMut, Resources, Stage, SystemStage,
-        With, World,
+        entity::Entity,
+        query::With,
+        schedule::{Stage, SystemStage},
+        system::{Commands, IntoExclusiveSystem, IntoSystem, Query, ResMut},
+        world::World,
     };
-    let mut world = World::new();
-    let mut resources = Resources::default();
-
-    fn removal(
-        commands: &mut Commands,
-        query: Query<Entity, With<f32>>,
-        mut counter: ResMut<usize>,
-    ) {
-        for entity in query.iter() {
-            *counter += 1;
-            commands.remove_one::<f32>(entity);
+    #[test]
+    fn parallel_with_commands_as_exclusive() {
+        let mut world = World::new();
+
+        fn removal(
+            mut commands: Commands,
+            query: Query<Entity, With<f32>>,
+            mut counter: ResMut<usize>,
+        ) {
+            for entity in query.iter() {
+                *counter += 1;
+                commands.remove::<f32>(entity);
+            }
         }
-    }
 
-    let mut stage = SystemStage::parallel().with_system(removal.system());
-    world.spawn((0.0f32,));
-    resources.insert(0usize);
-    stage.run(&mut world, &mut resources);
-    stage.run(&mut world, &mut resources);
-    assert_eq!(*resources.get::<usize>().unwrap(), 1);
-
-    let mut stage = SystemStage::parallel().with_system(removal.exclusive_system());
-    world.spawn((0.0f32,));
-    resources.insert(0usize);
-    stage.run(&mut world, &mut resources);
-    stage.run(&mut world, &mut resources);
-    assert_eq!(*resources.get::<usize>().unwrap(), 1);
+        let mut stage = SystemStage::parallel().with_system(removal.system());
+        world.spawn().insert(0.0f32);
+        world.insert_resource(0usize);
+        stage.run(&mut world);
+        stage.run(&mut world);
+        assert_eq!(*world.get_resource::<usize>().unwrap(), 1);
+
+        let mut stage = SystemStage::parallel().with_system(removal.exclusive_system());
+        world.spawn().insert(0.0f32);
+        world.insert_resource(0usize);
+        stage.run(&mut world);
+        stage.run(&mut world);
+        assert_eq!(*world.get_resource::<usize>().unwrap(), 1);
+    }
 }
diff --git a/crates/bevy_ecs/src/system/into_system.rs b/crates/bevy_ecs/src/system/into_system.rs
index ff7b95550c818..3317fe8a99265 100644
--- a/crates/bevy_ecs/src/system/into_system.rs
+++ b/crates/bevy_ecs/src/system/into_system.rs
@@ -1,599 +1,211 @@
-use super::system_param::FetchSystemParam;
 use crate::{
-    ArchetypeComponent, Commands, QueryAccess, Resources, System, SystemId, SystemParam,
-    TypeAccess, World,
+    archetype::{Archetype, ArchetypeComponentId},
+    component::ComponentId,
+    query::{Access, FilteredAccessSet},
+    system::{System, SystemId, SystemParam, SystemParamFetch, SystemParamState},
+    world::World,
 };
-use parking_lot::Mutex;
-use std::{any::TypeId, borrow::Cow, cell::UnsafeCell, sync::Arc};
+use bevy_ecs_macros::all_tuples;
+use std::{borrow::Cow, marker::PhantomData};
 
 pub struct SystemState {
     pub(crate) id: SystemId,
     pub(crate) name: Cow<'static, str>,
-    pub(crate) archetype_component_access: TypeAccess<ArchetypeComponent>,
-    pub(crate) component_access: TypeAccess<TypeId>,
-    pub(crate) resource_access: TypeAccess<TypeId>,
-    pub(crate) is_non_send: bool,
-    pub(crate) local_resource_access: TypeAccess<TypeId>,
-    pub(crate) query_archetype_component_accesses: Vec<TypeAccess<ArchetypeComponent>>,
-    pub(crate) query_accesses: Vec<Vec<QueryAccess>>,
-    pub(crate) query_type_names: Vec<&'static str>,
-    pub(crate) commands: UnsafeCell<Commands>,
-    pub(crate) arc_commands: Option<Arc<Mutex<Commands>>>,
-    pub(crate) current_query_index: UnsafeCell<usize>,
+    pub(crate) component_access_set: FilteredAccessSet<ComponentId>,
+    pub(crate) archetype_component_access: Access<ArchetypeComponentId>,
+    // NOTE: this must be kept private. making a SystemState non-send is irreversible to prevent SystemParams from overriding each other
+    is_send: bool,
 }
 
-// SAFE: UnsafeCell<Commands> and UnsafeCell<usize> only accessed from the thread they are scheduled on
-unsafe impl Sync for SystemState {}
-
 impl SystemState {
-    pub fn reset_indices(&mut self) {
-        // SAFE: done with unique mutable access to Self
-        unsafe {
-            *self.current_query_index.get() = 0;
-        }
-    }
-
-    pub fn update(&mut self, world: &World) {
-        self.archetype_component_access.clear();
-        let mut conflict_index = None;
-        let mut conflict_name = None;
-        for (i, (query_accesses, component_access)) in self
-            .query_accesses
-            .iter()
-            .zip(self.query_archetype_component_accesses.iter_mut())
-            .enumerate()
-        {
-            component_access.clear();
-            for query_access in query_accesses.iter() {
-                query_access.get_world_archetype_access(world, Some(component_access));
-            }
-            if !component_access.is_compatible(&self.archetype_component_access) {
-                conflict_index = Some(i);
-                conflict_name = component_access
-                    .get_conflict(&self.archetype_component_access)
-                    .and_then(|archetype_component| {
-                        query_accesses
-                            .iter()
-                            .filter_map(|query_access| {
-                                query_access.get_type_name(archetype_component.component)
-                            })
-                            .next()
-                    });
-                break;
-            }
-            self.archetype_component_access.extend(component_access);
-        }
-        if let Some(conflict_index) = conflict_index {
-            let mut conflicts_with_index = None;
-            for prior_index in 0..conflict_index {
-                if !self.query_archetype_component_accesses[conflict_index]
-                    .is_compatible(&self.query_archetype_component_accesses[prior_index])
-                {
-                    conflicts_with_index = Some(prior_index);
-                }
-            }
-            panic!("System {} has conflicting queries. {} conflicts with the component access [{}] in this prior query: {}.",
-                self.name,
-                self.query_type_names[conflict_index],
-                conflict_name.unwrap_or("Unknown"),
-                conflicts_with_index.map(|index| self.query_type_names[index]).unwrap_or("Unknown"));
+    fn new<T>() -> Self {
+        Self {
+            name: std::any::type_name::<T>().into(),
+            archetype_component_access: Access::default(),
+            component_access_set: FilteredAccessSet::default(),
+            is_send: true,
+            id: SystemId::new(),
         }
     }
-}
-
-pub struct FuncSystem<Out> {
-    func:
-        Box<dyn FnMut(&mut SystemState, &World, &Resources) -> Option<Out> + Send + Sync + 'static>,
-    init_func: Box<dyn FnMut(&mut SystemState, &World, &mut Resources) + Send + Sync + 'static>,
-    state: SystemState,
-}
-
-impl<Out: 'static> System for FuncSystem<Out> {
-    type In = ();
-    type Out = Out;
-
-    fn name(&self) -> std::borrow::Cow<'static, str> {
-        self.state.name.clone()
-    }
-
-    fn id(&self) -> SystemId {
-        self.state.id
-    }
 
-    fn update_access(&mut self, world: &World) {
-        self.state.update(world);
+    #[inline]
+    pub fn is_send(&self) -> bool {
+        self.is_send
     }
 
-    fn archetype_component_access(&self) -> &TypeAccess<ArchetypeComponent> {
-        &self.state.archetype_component_access
+    #[inline]
+    pub fn set_non_send(&mut self) {
+        self.is_send = false;
     }
+}
 
-    fn component_access(&self) -> &TypeAccess<TypeId> {
-        &self.state.component_access
-    }
+pub trait IntoSystem<Params, SystemType: System> {
+    fn system(self) -> SystemType;
+}
 
-    fn resource_access(&self) -> &TypeAccess<std::any::TypeId> {
-        &self.state.resource_access
+// Systems implicitly implement IntoSystem
+impl<Sys: System> IntoSystem<(), Sys> for Sys {
+    fn system(self) -> Sys {
+        self
     }
+}
 
-    fn is_non_send(&self) -> bool {
-        self.state.is_non_send
-    }
+pub struct In<In>(pub In);
+pub struct InputMarker;
+
+pub struct FunctionSystem<In, Out, Param, Marker, F>
+where
+    Param: SystemParam,
+{
+    func: F,
+    param_state: Option<Param::Fetch>,
+    system_state: SystemState,
+    config: Option<<Param::Fetch as SystemParamState>::Config>,
+    // NOTE: PhantomData<fn()-> T> gives this safe Send/Sync impls
+    marker: PhantomData<fn() -> (In, Out, Marker)>,
+}
 
-    unsafe fn run_unsafe(
-        &mut self,
-        _input: Self::In,
-        world: &World,
-        resources: &Resources,
-    ) -> Option<Out> {
-        (self.func)(&mut self.state, world, resources)
+impl<In, Out, Param: SystemParam, Marker, F> FunctionSystem<In, Out, Param, Marker, F> {
+    pub fn config(
+        mut self,
+        f: impl FnOnce(&mut <Param::Fetch as SystemParamState>::Config),
+    ) -> Self {
+        f(self.config.as_mut().unwrap());
+        self
     }
+}
 
-    fn apply_buffers(&mut self, world: &mut World, resources: &mut Resources) {
-        // SAFE: this is called with unique access to SystemState
-        unsafe {
-            (&mut *self.state.commands.get()).apply(world, resources);
+impl<In, Out, Param, Marker, F> IntoSystem<Param, FunctionSystem<In, Out, Param, Marker, F>> for F
+where
+    In: 'static,
+    Out: 'static,
+    Param: SystemParam + 'static,
+    Marker: 'static,
+    F: SystemParamFunction<In, Out, Param, Marker> + Send + Sync + 'static,
+{
+    fn system(self) -> FunctionSystem<In, Out, Param, Marker, F> {
+        FunctionSystem {
+            func: self,
+            param_state: None,
+            config: Some(Default::default()),
+            system_state: SystemState::new::<F>(),
+            marker: PhantomData,
         }
-        if let Some(ref commands) = self.state.arc_commands {
-            let mut commands = commands.lock();
-            commands.apply(world, resources);
-        }
-    }
-
-    fn initialize(&mut self, world: &mut World, resources: &mut Resources) {
-        (self.init_func)(&mut self.state, world, resources);
     }
 }
 
-pub struct InputFuncSystem<In, Out> {
-    func: Box<
-        dyn FnMut(In, &mut SystemState, &World, &Resources) -> Option<Out> + Send + Sync + 'static,
-    >,
-    init_func: Box<dyn FnMut(&mut SystemState, &World, &mut Resources) + Send + Sync + 'static>,
-    state: SystemState,
-}
-
-impl<In: 'static, Out: 'static> System for InputFuncSystem<In, Out> {
+impl<In, Out, Param, Marker, F> System for FunctionSystem<In, Out, Param, Marker, F>
+where
+    In: 'static,
+    Out: 'static,
+    Param: SystemParam + 'static,
+    Marker: 'static,
+    F: SystemParamFunction<In, Out, Param, Marker> + Send + Sync + 'static,
+{
     type In = In;
     type Out = Out;
 
-    fn name(&self) -> std::borrow::Cow<'static, str> {
-        self.state.name.clone()
+    #[inline]
+    fn name(&self) -> Cow<'static, str> {
+        self.system_state.name.clone()
     }
 
+    #[inline]
     fn id(&self) -> SystemId {
-        self.state.id
-    }
-
-    fn update_access(&mut self, world: &World) {
-        self.state.update(world);
+        self.system_state.id
     }
 
-    fn archetype_component_access(&self) -> &TypeAccess<ArchetypeComponent> {
-        &self.state.archetype_component_access
+    #[inline]
+    fn new_archetype(&mut self, archetype: &Archetype) {
+        let param_state = self.param_state.as_mut().unwrap();
+        param_state.new_archetype(archetype, &mut self.system_state);
     }
 
-    fn component_access(&self) -> &TypeAccess<TypeId> {
-        &self.state.component_access
+    #[inline]
+    fn component_access(&self) -> &Access<ComponentId> {
+        &self.system_state.component_access_set.combined_access()
     }
 
-    fn resource_access(&self) -> &TypeAccess<std::any::TypeId> {
-        &self.state.resource_access
+    #[inline]
+    fn archetype_component_access(&self) -> &Access<ArchetypeComponentId> {
+        &self.system_state.archetype_component_access
     }
 
-    fn is_non_send(&self) -> bool {
-        self.state.is_non_send
+    #[inline]
+    fn is_send(&self) -> bool {
+        self.system_state.is_send
     }
 
-    unsafe fn run_unsafe(
-        &mut self,
-        input: In,
-        world: &World,
-        resources: &Resources,
-    ) -> Option<Out> {
-        (self.func)(input, &mut self.state, world, resources)
+    #[inline]
+    unsafe fn run_unsafe(&mut self, input: Self::In, world: &World) -> Self::Out {
+        self.func.run(
+            input,
+            self.param_state.as_mut().unwrap(),
+            &self.system_state,
+            world,
+        )
     }
 
-    fn apply_buffers(&mut self, world: &mut World, resources: &mut Resources) {
-        // SAFE: this is called with unique access to SystemState
-        unsafe {
-            (&mut *self.state.commands.get()).apply(world, resources);
-        }
-        if let Some(ref commands) = self.state.arc_commands {
-            let mut commands = commands.lock();
-            commands.apply(world, resources);
-        }
+    #[inline]
+    fn apply_buffers(&mut self, world: &mut World) {
+        let param_state = self.param_state.as_mut().unwrap();
+        param_state.apply(world);
     }
 
-    fn initialize(&mut self, world: &mut World, resources: &mut Resources) {
-        (self.init_func)(&mut self.state, world, resources);
+    #[inline]
+    fn initialize(&mut self, world: &mut World) {
+        self.param_state = Some(<Param::Fetch as SystemParamState>::init(
+            world,
+            &mut self.system_state,
+            self.config.take().unwrap(),
+        ));
     }
 }
 
-pub trait IntoSystem<Params, SystemType> {
-    fn system(self) -> SystemType;
-}
-
-// Systems implicitly implement IntoSystem
-impl<Sys: System> IntoSystem<(), Sys> for Sys {
-    fn system(self) -> Sys {
-        self
-    }
+pub trait SystemParamFunction<In, Out, Param: SystemParam, Marker>: Send + Sync + 'static {
+    fn run(
+        &mut self,
+        input: In,
+        state: &mut Param::Fetch,
+        system_state: &SystemState,
+        world: &World,
+    ) -> Out;
 }
-pub struct In<In>(pub In);
 
-macro_rules! impl_into_system {
+macro_rules! impl_system_function {
     ($($param: ident),*) => {
-        impl<Func, Out, $($param: SystemParam),*> IntoSystem<($($param,)*), FuncSystem<Out>> for Func
+        #[allow(non_snake_case)]
+        impl<Out, Func, $($param: SystemParam),*> SystemParamFunction<(), Out, ($($param,)*), ()> for Func
         where
             Func:
                 FnMut($($param),*) -> Out +
-                FnMut($(<<$param as SystemParam>::Fetch as FetchSystemParam>::Item),*) -> Out +
-                Send + Sync + 'static, Out: 'static
+                FnMut($(<<$param as SystemParam>::Fetch as SystemParamFetch>::Item),*) -> Out + Send + Sync + 'static, Out: 'static
         {
-            #[allow(unused_variables)]
-            #[allow(unused_unsafe)]
-            #[allow(non_snake_case)]
-            fn system(mut self) -> FuncSystem<Out> {
-                FuncSystem {
-                    state: SystemState {
-                        name: std::any::type_name::<Self>().into(),
-                        archetype_component_access: TypeAccess::default(),
-                        component_access: TypeAccess::default(),
-                        resource_access: TypeAccess::default(),
-                        is_non_send: false,
-                        local_resource_access: TypeAccess::default(),
-                        id: SystemId::new(),
-                        commands: Default::default(),
-                        arc_commands: Default::default(),
-                        current_query_index: Default::default(),
-                        query_archetype_component_accesses: Vec::new(),
-                        query_accesses: Vec::new(),
-                        query_type_names: Vec::new(),
-                    },
-                    func: Box::new(move |state, world, resources| {
-                        state.reset_indices();
-                        // let mut input = Some(input);
-                        unsafe {
-                            if let Some(($($param,)*)) = <<($($param,)*) as SystemParam>::Fetch as FetchSystemParam>::get_param(state, world, resources) {
-                                Some(self($($param),*))
-                            } else {
-                                None
-                            }
-                        }
-                    }),
-                    init_func: Box::new(|state, world, resources| {
-                        <<($($param,)*) as SystemParam>::Fetch as FetchSystemParam>::init(state, world, resources)
-                    }),
+            #[inline]
+            fn run(&mut self, _input: (), state: &mut <($($param,)*) as SystemParam>::Fetch, system_state: &SystemState, world: &World) -> Out {
+                unsafe {
+                    let ($($param,)*) = <<($($param,)*) as SystemParam>::Fetch as SystemParamFetch>::get_param(state, system_state, world);
+                    self($($param),*)
                 }
             }
         }
-        impl<Func, Input, Out, $($param: SystemParam),*> IntoSystem<(Input, $($param,)*), InputFuncSystem<Input, Out>> for Func
+
+        #[allow(non_snake_case)]
+        impl<Input, Out, Func, $($param: SystemParam),*> SystemParamFunction<Input, Out, ($($param,)*), InputMarker> for Func
         where
             Func:
                 FnMut(In<Input>, $($param),*) -> Out +
-                FnMut(In<Input>, $(<<$param as SystemParam>::Fetch as FetchSystemParam>::Item),*) -> Out +
-                Send + Sync + 'static, Input: 'static, Out: 'static
+                FnMut(In<Input>, $(<<$param as SystemParam>::Fetch as SystemParamFetch>::Item),*) -> Out + Send + Sync + 'static, Out: 'static
         {
-            #[allow(unused_variables)]
-            #[allow(unused_unsafe)]
-            #[allow(non_snake_case)]
-            fn system(mut self) -> InputFuncSystem<Input, Out> {
-                InputFuncSystem {
-                    state: SystemState {
-                        name: std::any::type_name::<Self>().into(),
-                        archetype_component_access: TypeAccess::default(),
-                        component_access: TypeAccess::default(),
-                        resource_access: TypeAccess::default(),
-                        is_non_send: false,
-                        local_resource_access: TypeAccess::default(),
-                        id: SystemId::new(),
-                        commands: Default::default(),
-                        arc_commands: Default::default(),
-                        current_query_index: Default::default(),
-                        query_archetype_component_accesses: Vec::new(),
-                        query_accesses: Vec::new(),
-                        query_type_names: Vec::new(),
-                    },
-                    func: Box::new(move |input, state, world, resources| {
-                        state.reset_indices();
-                        // let mut input = Some(input);
-                        unsafe {
-                            if let Some(($($param,)*)) = <<($($param,)*) as SystemParam>::Fetch as FetchSystemParam>::get_param(state, world, resources) {
-                                Some(self(In(input), $($param),*))
-                            } else {
-                                None
-                            }
-                        }
-                    }),
-                    init_func: Box::new(|state, world, resources| {
-                        <<($($param,)*) as SystemParam>::Fetch as FetchSystemParam>::init(state, world, resources)
-                    }),
+            #[inline]
+            fn run(&mut self, input: Input, state: &mut <($($param,)*) as SystemParam>::Fetch, system_state: &SystemState, world: &World) -> Out {
+                unsafe {
+                    let ($($param,)*) = <<($($param,)*) as SystemParam>::Fetch as SystemParamFetch>::get_param(state, system_state, world);
+                    self(In(input), $($param),*)
                 }
             }
         }
     };
 }
 
-impl_into_system!();
-impl_into_system!(A);
-impl_into_system!(A, B);
-impl_into_system!(A, B, C);
-impl_into_system!(A, B, C, D);
-impl_into_system!(A, B, C, D, E);
-impl_into_system!(A, B, C, D, E, F);
-impl_into_system!(A, B, C, D, E, F, G);
-impl_into_system!(A, B, C, D, E, F, G, H);
-impl_into_system!(A, B, C, D, E, F, G, H, I);
-impl_into_system!(A, B, C, D, E, F, G, H, I, J);
-impl_into_system!(A, B, C, D, E, F, G, H, I, J, K);
-impl_into_system!(A, B, C, D, E, F, G, H, I, J, K, L);
-impl_into_system!(A, B, C, D, E, F, G, H, I, J, K, L, M);
-impl_into_system!(A, B, C, D, E, F, G, H, I, J, K, L, M, N);
-impl_into_system!(A, B, C, D, E, F, G, H, I, J, K, L, M, N, O);
-impl_into_system!(A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P);
-
-#[cfg(test)]
-mod tests {
-    use super::IntoSystem;
-    use crate::{
-        clear_trackers_system,
-        resource::{Res, ResMut, Resources},
-        schedule::Schedule,
-        Entity, IntoExclusiveSystem, Local, Query, QuerySet, Stage, System, SystemStage, With,
-        World,
-    };
-
-    #[derive(Debug, Eq, PartialEq, Default)]
-    struct A;
-    struct B;
-    struct C;
-    struct D;
-
-    #[test]
-    fn query_system_gets() {
-        fn query_system(
-            mut ran: ResMut<bool>,
-            entity_query: Query<Entity, With<A>>,
-            b_query: Query<&B>,
-            a_c_query: Query<(&A, &C)>,
-            d_query: Query<&D>,
-        ) {
-            let entities = entity_query.iter().collect::<Vec<Entity>>();
-            assert!(
-                b_query.get_component::<B>(entities[0]).is_err(),
-                "entity 0 should not have B"
-            );
-            assert!(
-                b_query.get_component::<B>(entities[1]).is_ok(),
-                "entity 1 should have B"
-            );
-            assert!(
-                b_query.get_component::<A>(entities[1]).is_err(),
-                "entity 1 should have A, but b_query shouldn't have access to it"
-            );
-            assert!(
-                b_query.get_component::<D>(entities[3]).is_err(),
-                "entity 3 should have D, but it shouldn't be accessible from b_query"
-            );
-            assert!(
-                b_query.get_component::<C>(entities[2]).is_err(),
-                "entity 2 has C, but it shouldn't be accessible from b_query"
-            );
-            assert!(
-                a_c_query.get_component::<C>(entities[2]).is_ok(),
-                "entity 2 has C, and it should be accessible from a_c_query"
-            );
-            assert!(
-                a_c_query.get_component::<D>(entities[3]).is_err(),
-                "entity 3 should have D, but it shouldn't be accessible from b_query"
-            );
-            assert!(
-                d_query.get_component::<D>(entities[3]).is_ok(),
-                "entity 3 should have D"
-            );
-
-            *ran = true;
-        }
-
-        let mut world = World::default();
-        let mut resources = Resources::default();
-        resources.insert(false);
-        world.spawn((A,));
-        world.spawn((A, B));
-        world.spawn((A, C));
-        world.spawn((A, D));
-
-        run_system(&mut world, &mut resources, query_system.system());
-
-        assert!(*resources.get::<bool>().unwrap(), "system ran");
-    }
-
-    #[test]
-    fn or_query_set_system() {
-        // Regression test for issue #762
-        use crate::{Added, Changed, Mutated, Or};
-        fn query_system(
-            mut ran: ResMut<bool>,
-            set: QuerySet<(
-                Query<(), Or<(Changed<A>, Changed<B>)>>,
-                Query<(), Or<(Added<A>, Added<B>)>>,
-                Query<(), Or<(Mutated<A>, Mutated<B>)>>,
-            )>,
-        ) {
-            let changed = set.q0().iter().count();
-            let added = set.q1().iter().count();
-            let mutated = set.q2().iter().count();
-
-            assert_eq!(changed, 1);
-            assert_eq!(added, 1);
-            assert_eq!(mutated, 0);
-
-            *ran = true;
-        }
-
-        let mut world = World::default();
-        let mut resources = Resources::default();
-        resources.insert(false);
-        world.spawn((A, B));
-
-        run_system(&mut world, &mut resources, query_system.system());
-
-        assert!(*resources.get::<bool>().unwrap(), "system ran");
-    }
-
-    #[test]
-    fn changed_resource_system() {
-        fn incr_e_on_flip(run_on_flip: Res<bool>, mut query: Query<&mut i32>) {
-            if !Res::changed(&run_on_flip) {
-                return;
-            }
-
-            for mut i in query.iter_mut() {
-                *i += 1;
-            }
-        }
-
-        let mut world = World::default();
-        let mut resources = Resources::default();
-        resources.insert(false);
-        let ent = world.spawn((0,));
-
-        let mut schedule = Schedule::default();
-        let mut update = SystemStage::parallel();
-        update.add_system(incr_e_on_flip.system());
-        schedule.add_stage("update", update);
-        schedule.add_stage(
-            "clear_trackers",
-            SystemStage::single(clear_trackers_system.exclusive_system()),
-        );
-
-        schedule.run(&mut world, &mut resources);
-        assert_eq!(*(world.get::<i32>(ent).unwrap()), 1);
-
-        schedule.run(&mut world, &mut resources);
-        assert_eq!(*(world.get::<i32>(ent).unwrap()), 1);
-
-        *resources.get_mut::<bool>().unwrap() = true;
-        schedule.run(&mut world, &mut resources);
-        assert_eq!(*(world.get::<i32>(ent).unwrap()), 2);
-    }
-
-    #[test]
-    #[should_panic]
-    fn conflicting_query_mut_system() {
-        fn sys(_q1: Query<&mut A>, _q2: Query<&mut A>) {}
-
-        let mut world = World::default();
-        let mut resources = Resources::default();
-        world.spawn((A,));
-
-        run_system(&mut world, &mut resources, sys.system());
-    }
-
-    #[test]
-    #[should_panic]
-    fn conflicting_query_immut_system() {
-        fn sys(_q1: Query<&A>, _q2: Query<&mut A>) {}
-
-        let mut world = World::default();
-        let mut resources = Resources::default();
-        world.spawn((A,));
-
-        run_system(&mut world, &mut resources, sys.system());
-    }
-
-    #[test]
-    fn query_set_system() {
-        fn sys(_set: QuerySet<(Query<&mut A>, Query<&B>)>) {}
-
-        let mut world = World::default();
-        let mut resources = Resources::default();
-        world.spawn((A,));
-
-        run_system(&mut world, &mut resources, sys.system());
-    }
-
-    #[test]
-    #[should_panic]
-    fn conflicting_query_with_query_set_system() {
-        fn sys(_query: Query<&mut A>, _set: QuerySet<(Query<&mut A>, Query<&B>)>) {}
-
-        let mut world = World::default();
-        let mut resources = Resources::default();
-        world.spawn((A,));
-
-        run_system(&mut world, &mut resources, sys.system());
-    }
-
-    #[test]
-    #[should_panic]
-    fn conflicting_query_sets_system() {
-        fn sys(_set_1: QuerySet<(Query<&mut A>,)>, _set_2: QuerySet<(Query<&mut A>, Query<&B>)>) {}
-
-        let mut world = World::default();
-        let mut resources = Resources::default();
-        world.spawn((A,));
-        run_system(&mut world, &mut resources, sys.system());
-    }
-
-    fn run_system<S: System<In = (), Out = ()>>(
-        world: &mut World,
-        resources: &mut Resources,
-        system: S,
-    ) {
-        let mut schedule = Schedule::default();
-        let mut update = SystemStage::parallel();
-        update.add_system(system);
-        schedule.add_stage("update", update);
-        schedule.run(world, resources);
-    }
-
-    #[derive(Default)]
-    struct BufferRes {
-        _buffer: Vec<u8>,
-    }
-
-    fn test_for_conflicting_resources<S: System<In = (), Out = ()>>(sys: S) {
-        let mut world = World::default();
-        let mut resources = Resources::default();
-        resources.insert(BufferRes::default());
-        resources.insert(A);
-        resources.insert(B);
-        run_system(&mut world, &mut resources, sys);
-    }
-
-    #[test]
-    #[should_panic]
-    fn conflicting_system_resources() {
-        fn sys(_: ResMut<BufferRes>, _: Res<BufferRes>) {}
-        test_for_conflicting_resources(sys.system())
-    }
-
-    #[test]
-    #[should_panic]
-    fn conflicting_system_resources_reverse_order() {
-        fn sys(_: Res<BufferRes>, _: ResMut<BufferRes>) {}
-        test_for_conflicting_resources(sys.system())
-    }
-
-    #[test]
-    #[should_panic]
-    fn conflicting_system_resources_multiple_mutable() {
-        fn sys(_: ResMut<BufferRes>, _: ResMut<BufferRes>) {}
-        test_for_conflicting_resources(sys.system())
-    }
-
-    #[test]
-    #[should_panic]
-    fn conflicting_system_local_resources() {
-        fn sys(_: Local<BufferRes>, _: Local<BufferRes>) {}
-        test_for_conflicting_resources(sys.system())
-    }
-
-    #[test]
-    fn nonconflicting_system_resources() {
-        fn sys(_: Local<BufferRes>, _: ResMut<BufferRes>, _: Local<A>, _: ResMut<A>) {}
-        test_for_conflicting_resources(sys.system())
-    }
-}
+all_tuples!(impl_system_function, 0, 12, F);
diff --git a/crates/bevy_ecs/src/system/mod.rs b/crates/bevy_ecs/src/system/mod.rs
index 6d38135a5b4f5..74e0311757f05 100644
--- a/crates/bevy_ecs/src/system/mod.rs
+++ b/crates/bevy_ecs/src/system/mod.rs
@@ -14,3 +14,405 @@ pub use query::*;
 pub use system::*;
 pub use system_chaining::*;
 pub use system_param::*;
+
+#[cfg(test)]
+mod tests {
+    use crate::{
+        archetype::Archetypes,
+        bundle::Bundles,
+        component::Components,
+        entity::{Entities, Entity},
+        query::{Added, Changed, Mutated, Or, With, Without},
+        schedule::{Schedule, Stage, SystemStage},
+        system::{
+            IntoExclusiveSystem, IntoSystem, Local, Query, QuerySet, RemovedComponents, Res,
+            ResMut, System,
+        },
+        world::{FromWorld, World},
+    };
+
+    #[derive(Debug, Eq, PartialEq, Default)]
+    struct A;
+    struct B;
+    struct C;
+    struct D;
+
+    #[test]
+    fn simple_system() {
+        fn sys(query: Query<&A>) {
+            for a in query.iter() {
+                println!("{:?}", a);
+            }
+        }
+
+        let mut system = sys.system();
+        let mut world = World::new();
+        world.spawn().insert(A);
+
+        system.initialize(&mut world);
+        for archetype in world.archetypes.iter() {
+            system.new_archetype(archetype);
+        }
+        system.run((), &mut world);
+    }
+
+    fn run_system<S: System<In = (), Out = ()>>(world: &mut World, system: S) {
+        let mut schedule = Schedule::default();
+        let mut update = SystemStage::parallel();
+        update.add_system(system);
+        schedule.add_stage("update", update);
+        schedule.run(world);
+    }
+
+    #[test]
+    fn query_system_gets() {
+        fn query_system(
+            mut ran: ResMut<bool>,
+            entity_query: Query<Entity, With<A>>,
+            b_query: Query<&B>,
+            a_c_query: Query<(&A, &C)>,
+            d_query: Query<&D>,
+        ) {
+            let entities = entity_query.iter().collect::<Vec<Entity>>();
+            assert!(
+                b_query.get_component::<B>(entities[0]).is_err(),
+                "entity 0 should not have B"
+            );
+            assert!(
+                b_query.get_component::<B>(entities[1]).is_ok(),
+                "entity 1 should have B"
+            );
+            assert!(
+                b_query.get_component::<A>(entities[1]).is_err(),
+                "entity 1 should have A, but b_query shouldn't have access to it"
+            );
+            assert!(
+                b_query.get_component::<D>(entities[3]).is_err(),
+                "entity 3 should have D, but it shouldn't be accessible from b_query"
+            );
+            assert!(
+                b_query.get_component::<C>(entities[2]).is_err(),
+                "entity 2 has C, but it shouldn't be accessible from b_query"
+            );
+            assert!(
+                a_c_query.get_component::<C>(entities[2]).is_ok(),
+                "entity 2 has C, and it should be accessible from a_c_query"
+            );
+            assert!(
+                a_c_query.get_component::<D>(entities[3]).is_err(),
+                "entity 3 should have D, but it shouldn't be accessible from b_query"
+            );
+            assert!(
+                d_query.get_component::<D>(entities[3]).is_ok(),
+                "entity 3 should have D"
+            );
+
+            *ran = true;
+        }
+
+        let mut world = World::default();
+        world.insert_resource(false);
+        world.spawn().insert_bundle((A,));
+        world.spawn().insert_bundle((A, B));
+        world.spawn().insert_bundle((A, C));
+        world.spawn().insert_bundle((A, D));
+
+        run_system(&mut world, query_system.system());
+
+        assert!(*world.get_resource::<bool>().unwrap(), "system ran");
+    }
+
+    #[test]
+    fn or_query_set_system() {
+        // Regression test for issue #762
+        fn query_system(
+            mut ran: ResMut<bool>,
+            set: QuerySet<(
+                Query<(), Or<(Changed<A>, Changed<B>)>>,
+                Query<(), Or<(Added<A>, Added<B>)>>,
+                Query<(), Or<(Mutated<A>, Mutated<B>)>>,
+            )>,
+        ) {
+            let changed = set.q0().iter().count();
+            let added = set.q1().iter().count();
+            let mutated = set.q2().iter().count();
+
+            assert_eq!(changed, 1);
+            assert_eq!(added, 1);
+            assert_eq!(mutated, 0);
+
+            *ran = true;
+        }
+
+        let mut world = World::default();
+        world.insert_resource(false);
+        world.spawn().insert_bundle((A, B));
+
+        run_system(&mut world, query_system.system());
+
+        assert!(*world.get_resource::<bool>().unwrap(), "system ran");
+    }
+
+    #[test]
+    fn changed_resource_system() {
+        struct Added(usize);
+        struct Changed(usize);
+        fn incr_e_on_flip(
+            value: Res<bool>,
+            mut changed: ResMut<Changed>,
+            mut added: ResMut<Added>,
+        ) {
+            if value.added() {
+                added.0 += 1;
+            }
+
+            if value.changed() {
+                changed.0 += 1;
+            }
+        }
+
+        let mut world = World::default();
+        world.insert_resource(false);
+        world.insert_resource(Added(0));
+        world.insert_resource(Changed(0));
+
+        let mut schedule = Schedule::default();
+        let mut update = SystemStage::parallel();
+        update.add_system(incr_e_on_flip.system());
+        schedule.add_stage("update", update);
+        schedule.add_stage(
+            "clear_trackers",
+            SystemStage::single(World::clear_trackers.exclusive_system()),
+        );
+
+        schedule.run(&mut world);
+        assert_eq!(world.get_resource::<Added>().unwrap().0, 1);
+        assert_eq!(world.get_resource::<Changed>().unwrap().0, 1);
+
+        schedule.run(&mut world);
+        assert_eq!(world.get_resource::<Added>().unwrap().0, 1);
+        assert_eq!(world.get_resource::<Changed>().unwrap().0, 1);
+
+        *world.get_resource_mut::<bool>().unwrap() = true;
+        schedule.run(&mut world);
+        assert_eq!(world.get_resource::<Added>().unwrap().0, 1);
+        assert_eq!(world.get_resource::<Changed>().unwrap().0, 2);
+    }
+
+    #[test]
+    #[should_panic]
+    fn conflicting_query_mut_system() {
+        fn sys(_q1: Query<&mut A>, _q2: Query<&mut A>) {}
+
+        let mut world = World::default();
+        run_system(&mut world, sys.system());
+    }
+
+    #[test]
+    fn disjoint_query_mut_system() {
+        fn sys(_q1: Query<&mut A, With<B>>, _q2: Query<&mut A, Without<B>>) {}
+
+        let mut world = World::default();
+        run_system(&mut world, sys.system());
+    }
+
+    #[test]
+    fn disjoint_query_mut_read_component_system() {
+        fn sys(_q1: Query<(&mut A, &B)>, _q2: Query<&mut A, Without<B>>) {}
+
+        let mut world = World::default();
+        run_system(&mut world, sys.system());
+    }
+
+    #[test]
+    #[should_panic]
+    fn conflicting_query_immut_system() {
+        fn sys(_q1: Query<&A>, _q2: Query<&mut A>) {}
+
+        let mut world = World::default();
+        run_system(&mut world, sys.system());
+    }
+
+    #[test]
+    fn query_set_system() {
+        fn sys(mut _set: QuerySet<(Query<&mut A>, Query<&A>)>) {}
+        let mut world = World::default();
+        run_system(&mut world, sys.system());
+    }
+
+    #[test]
+    #[should_panic]
+    fn conflicting_query_with_query_set_system() {
+        fn sys(_query: Query<&mut A>, _set: QuerySet<(Query<&mut A>, Query<&B>)>) {}
+
+        let mut world = World::default();
+        run_system(&mut world, sys.system());
+    }
+
+    #[test]
+    #[should_panic]
+    fn conflicting_query_sets_system() {
+        fn sys(_set_1: QuerySet<(Query<&mut A>,)>, _set_2: QuerySet<(Query<&mut A>, Query<&B>)>) {}
+
+        let mut world = World::default();
+        run_system(&mut world, sys.system());
+    }
+
+    #[derive(Default)]
+    struct BufferRes {
+        _buffer: Vec<u8>,
+    }
+
+    fn test_for_conflicting_resources<S: System<In = (), Out = ()>>(sys: S) {
+        let mut world = World::default();
+        world.insert_resource(BufferRes::default());
+        world.insert_resource(A);
+        world.insert_resource(B);
+        run_system(&mut world, sys.system());
+    }
+
+    #[test]
+    #[should_panic]
+    fn conflicting_system_resources() {
+        fn sys(_: ResMut<BufferRes>, _: Res<BufferRes>) {}
+        test_for_conflicting_resources(sys.system())
+    }
+
+    #[test]
+    #[should_panic]
+    fn conflicting_system_resources_reverse_order() {
+        fn sys(_: Res<BufferRes>, _: ResMut<BufferRes>) {}
+        test_for_conflicting_resources(sys.system())
+    }
+
+    #[test]
+    #[should_panic]
+    fn conflicting_system_resources_multiple_mutable() {
+        fn sys(_: ResMut<BufferRes>, _: ResMut<BufferRes>) {}
+        test_for_conflicting_resources(sys.system())
+    }
+
+    #[test]
+    fn nonconflicting_system_resources() {
+        fn sys(_: Local<BufferRes>, _: ResMut<BufferRes>, _: Local<A>, _: ResMut<A>) {}
+        test_for_conflicting_resources(sys.system())
+    }
+
+    #[test]
+    fn local_system() {
+        let mut world = World::default();
+        world.insert_resource(1u32);
+        world.insert_resource(false);
+        struct Foo {
+            value: u32,
+        }
+
+        impl FromWorld for Foo {
+            fn from_world(world: &mut World) -> Self {
+                Foo {
+                    value: *world.get_resource::<u32>().unwrap() + 1,
+                }
+            }
+        }
+
+        fn sys(local: Local<Foo>, mut modified: ResMut<bool>) {
+            assert_eq!(local.value, 2);
+            *modified = true;
+        }
+
+        run_system(&mut world, sys.system());
+
+        // ensure the system actually ran
+        assert_eq!(*world.get_resource::<bool>().unwrap(), true);
+    }
+
+    #[test]
+    fn remove_tracking() {
+        let mut world = World::new();
+        struct Despawned(Entity);
+        let a = world.spawn().insert_bundle(("abc", 123)).id();
+        world.spawn().insert_bundle(("abc", 123));
+        world.insert_resource(false);
+        world.insert_resource(Despawned(a));
+
+        world.entity_mut(a).despawn();
+
+        fn validate_removed(
+            removed_i32: RemovedComponents<i32>,
+            despawned: Res<Despawned>,
+            mut ran: ResMut<bool>,
+        ) {
+            assert_eq!(
+                removed_i32.iter().collect::<Vec<_>>(),
+                &[despawned.0],
+                "despawning results in 'removed component' state"
+            );
+
+            *ran = true;
+        }
+
+        run_system(&mut world, validate_removed.system());
+        assert_eq!(*world.get_resource::<bool>().unwrap(), true, "system ran");
+    }
+
+    #[test]
+    fn configure_system_local() {
+        let mut world = World::default();
+        world.insert_resource(false);
+        fn sys(local: Local<usize>, mut modified: ResMut<bool>) {
+            assert_eq!(*local, 42);
+            *modified = true;
+        }
+
+        run_system(
+            &mut world,
+            sys.system().config(|config| config.0 = Some(42)),
+        );
+
+        // ensure the system actually ran
+        assert_eq!(*world.get_resource::<bool>().unwrap(), true);
+    }
+    #[test]
+    fn world_collections_system() {
+        let mut world = World::default();
+        world.insert_resource(false);
+        world.spawn().insert_bundle((42, true));
+        fn sys(
+            archetypes: &Archetypes,
+            components: &Components,
+            entities: &Entities,
+            bundles: &Bundles,
+            query: Query<Entity, With<i32>>,
+            mut modified: ResMut<bool>,
+        ) {
+            assert_eq!(query.iter().count(), 1, "entity exists");
+            for entity in query.iter() {
+                let location = entities.get(entity).unwrap();
+                let archetype = archetypes.get(location.archetype_id).unwrap();
+                let archetype_components = archetype.components().collect::<Vec<_>>();
+                let bundle_id = bundles
+                    .get_id(std::any::TypeId::of::<(i32, bool)>())
+                    .expect("Bundle used to spawn entity should exist");
+                let bundle_info = bundles.get(bundle_id).unwrap();
+                let mut bundle_components = bundle_info.components().to_vec();
+                bundle_components.sort();
+                for component_id in bundle_components.iter() {
+                    assert!(
+                        components.get_info(*component_id).is_some(),
+                        "every bundle component exists in Components"
+                    );
+                }
+                assert_eq!(
+                    bundle_components, archetype_components,
+                    "entity's bundle components exactly match entity's archetype components"
+                );
+            }
+            *modified = true;
+        }
+
+        run_system(&mut world, sys.system());
+
+        // ensure the system actually ran
+        assert_eq!(*world.get_resource::<bool>().unwrap(), true);
+    }
+}
diff --git a/crates/bevy_ecs/src/system/query.rs b/crates/bevy_ecs/src/system/query.rs
new file mode 100644
index 0000000000000..a98f5cd36c63d
--- /dev/null
+++ b/crates/bevy_ecs/src/system/query.rs
@@ -0,0 +1,228 @@
+use crate::{
+    component::Component,
+    entity::Entity,
+    query::{
+        Fetch, FilterFetch, QueryEntityError, QueryIter, QueryState, ReadOnlyFetch, WorldQuery,
+    },
+    world::{Mut, World},
+};
+use bevy_tasks::TaskPool;
+use std::any::TypeId;
+use thiserror::Error;
+
+/// Provides scoped access to a World according to a given [WorldQuery] and query filter
+pub struct Query<'w, Q: WorldQuery, F: WorldQuery = ()>
+where
+    F::Fetch: FilterFetch,
+{
+    pub(crate) world: &'w World,
+    pub(crate) state: &'w QueryState<Q, F>,
+}
+
+impl<'w, Q: WorldQuery, F: WorldQuery> Query<'w, Q, F>
+where
+    F::Fetch: FilterFetch,
+{
+    /// # Safety
+    /// This will create a Query that could violate memory safety rules. Make sure that this is only called in
+    /// ways that ensure the Queries have unique mutable access.
+    #[inline]
+    pub(crate) unsafe fn new(world: &'w World, state: &'w QueryState<Q, F>) -> Self {
+        Self { world, state }
+    }
+
+    /// Iterates over the query results. This can only be called for read-only queries
+    #[inline]
+    pub fn iter(&self) -> QueryIter<'_, '_, Q, F>
+    where
+        Q::Fetch: ReadOnlyFetch,
+    {
+        // SAFE: system runs without conflicts with other systems. same-system queries have runtime borrow checks when they conflict
+        unsafe { self.state.iter_unchecked_manual(self.world) }
+    }
+
+    /// Iterates over the query results
+    #[inline]
+    pub fn iter_mut(&mut self) -> QueryIter<'_, '_, Q, F> {
+        // SAFE: system runs without conflicts with other systems. same-system queries have runtime borrow checks when they conflict
+        unsafe { self.state.iter_unchecked_manual(self.world) }
+    }
+
+    /// Iterates over the query results
+    /// # Safety
+    /// This allows aliased mutability. You must make sure this call does not result in multiple mutable references to the same component
+    #[inline]
+    pub unsafe fn iter_unsafe(&self) -> QueryIter<'_, '_, Q, F> {
+        // SEMI-SAFE: system runs without conflicts with other systems. same-system queries have runtime borrow checks when they conflict
+        self.state.iter_unchecked_manual(self.world)
+    }
+
+    /// Runs `f` on each query result. This is faster than the equivalent iter() method, but cannot be chained like a normal iterator.
+    /// This can only be called for read-only queries
+    #[inline]
+    pub fn for_each(&self, f: impl FnMut(<Q::Fetch as Fetch<'w>>::Item))
+    where
+        Q::Fetch: ReadOnlyFetch,
+    {
+        // SAFE: system runs without conflicts with other systems. same-system queries have runtime borrow checks when they conflict
+        unsafe { self.state.for_each_unchecked_manual(self.world, f) };
+    }
+
+    /// Runs `f` on each query result. This is faster than the equivalent iter() method, but cannot be chained like a normal iterator.
+    #[inline]
+    pub fn for_each_mut(&self, f: impl FnMut(<Q::Fetch as Fetch<'w>>::Item)) {
+        // SAFE: system runs without conflicts with other systems. same-system queries have runtime borrow checks when they conflict
+        unsafe { self.state.for_each_unchecked_manual(self.world, f) };
+    }
+
+    /// Runs `f` on each query result in parallel using the given task pool.
+    #[inline]
+    pub fn par_for_each(
+        &self,
+        task_pool: &TaskPool,
+        batch_size: usize,
+        f: impl Fn(<Q::Fetch as Fetch<'w>>::Item) + Send + Sync + Clone,
+    ) where
+        Q::Fetch: ReadOnlyFetch,
+    {
+        // SAFE: system runs without conflicts with other systems. same-system queries have runtime borrow checks when they conflict
+        unsafe {
+            self.state
+                .par_for_each_unchecked_manual(self.world, task_pool, batch_size, f)
+        };
+    }
+
+    /// Runs `f` on each query result in parallel using the given task pool.
+    #[inline]
+    pub fn par_for_each_mut(
+        &mut self,
+        task_pool: &TaskPool,
+        batch_size: usize,
+        f: impl Fn(<Q::Fetch as Fetch<'w>>::Item) + Send + Sync + Clone,
+    ) {
+        // SAFE: system runs without conflicts with other systems. same-system queries have runtime borrow checks when they conflict
+        unsafe {
+            self.state
+                .par_for_each_unchecked_manual(self.world, task_pool, batch_size, f)
+        };
+    }
+
+    /// Gets the query result for the given `entity`
+    #[inline]
+    pub fn get(&self, entity: Entity) -> Result<<Q::Fetch as Fetch>::Item, QueryEntityError>
+    where
+        Q::Fetch: ReadOnlyFetch,
+    {
+        // SAFE: system runs without conflicts with other systems. same-system queries have runtime borrow checks when they conflict
+        unsafe { self.state.get_unchecked_manual(self.world, entity) }
+    }
+
+    /// Gets the query result for the given `entity`
+    #[inline]
+    pub fn get_mut(
+        &mut self,
+        entity: Entity,
+    ) -> Result<<Q::Fetch as Fetch>::Item, QueryEntityError> {
+        // // SAFE: system runs without conflicts with other systems. same-system queries have runtime borrow checks when they conflict
+        unsafe { self.state.get_unchecked_manual(self.world, entity) }
+    }
+
+    /// Gets the query result for the given `entity`
+    /// # Safety
+    /// This allows aliased mutability. You must make sure this call does not result in multiple mutable references to the same component
+    #[inline]
+    pub unsafe fn get_unchecked(
+        &self,
+        entity: Entity,
+    ) -> Result<<Q::Fetch as Fetch>::Item, QueryEntityError> {
+        // SEMI-SAFE: system runs without conflicts with other systems. same-system queries have runtime borrow checks when they conflict
+        self.state.get_unchecked_manual(self.world, entity)
+    }
+
+    /// Gets a reference to the entity's component of the given type. This will fail if the entity does not have
+    /// the given component type or if the given component type does not match this query.
+    #[inline]
+    pub fn get_component<T: Component>(&self, entity: Entity) -> Result<&T, QueryComponentError> {
+        let world = self.world;
+        let entity_ref = world
+            .get_entity(entity)
+            .ok_or(QueryComponentError::NoSuchEntity)?;
+        let component_id = world
+            .components()
+            .get_id(TypeId::of::<T>())
+            .ok_or(QueryComponentError::MissingComponent)?;
+        let archetype_component = entity_ref
+            .archetype()
+            .get_archetype_component_id(component_id)
+            .ok_or(QueryComponentError::MissingComponent)?;
+        if self
+            .state
+            .archetype_component_access
+            .has_read(archetype_component)
+        {
+            entity_ref
+                .get::<T>()
+                .ok_or(QueryComponentError::MissingComponent)
+        } else {
+            Err(QueryComponentError::MissingReadAccess)
+        }
+    }
+
+    /// Gets a mutable reference to the entity's component of the given type. This will fail if the entity does not have
+    /// the given component type or if the given component type does not match this query.
+    #[inline]
+    pub fn get_component_mut<T: Component>(
+        &mut self,
+        entity: Entity,
+    ) -> Result<Mut<'_, T>, QueryComponentError> {
+        // SAFE: unique access to query (preventing aliased access)
+        unsafe { self.get_component_unchecked_mut(entity) }
+    }
+
+    /// Gets a mutable reference to the entity's component of the given type. This will fail if the entity does not have
+    /// the given component type or the component does not match the query.
+    /// # Safety
+    /// This allows aliased mutability. You must make sure this call does not result in multiple mutable references to the same component
+    #[inline]
+    pub unsafe fn get_component_unchecked_mut<T: Component>(
+        &self,
+        entity: Entity,
+    ) -> Result<Mut<'_, T>, QueryComponentError> {
+        let world = self.world;
+        let entity_ref = world
+            .get_entity(entity)
+            .ok_or(QueryComponentError::NoSuchEntity)?;
+        let component_id = world
+            .components()
+            .get_id(TypeId::of::<T>())
+            .ok_or(QueryComponentError::MissingComponent)?;
+        let archetype_component = entity_ref
+            .archetype()
+            .get_archetype_component_id(component_id)
+            .ok_or(QueryComponentError::MissingComponent)?;
+        if self
+            .state
+            .archetype_component_access
+            .has_write(archetype_component)
+        {
+            entity_ref
+                .get_unchecked_mut::<T>()
+                .ok_or(QueryComponentError::MissingComponent)
+        } else {
+            Err(QueryComponentError::MissingWriteAccess)
+        }
+    }
+}
+
+/// An error that occurs when retrieving a specific [Entity]'s component from a [Query]
+#[derive(Error, Debug)]
+pub enum QueryComponentError {
+    #[error("This query does not have read access to the requested component.")]
+    MissingReadAccess,
+    #[error("This query does not have read access to the requested component.")]
+    MissingWriteAccess,
+    #[error("The given entity does not have the requested component.")]
+    MissingComponent,
+    #[error("The requested entity does not exist.")]
+    NoSuchEntity,
+}
diff --git a/crates/bevy_ecs/src/system/query/mod.rs b/crates/bevy_ecs/src/system/query/mod.rs
deleted file mode 100644
index f284751afb6c1..0000000000000
--- a/crates/bevy_ecs/src/system/query/mod.rs
+++ /dev/null
@@ -1,232 +0,0 @@
-mod query_set;
-pub use query_set::*;
-
-use crate::{
-    ArchetypeComponent, Batch, BatchedIter, Component, ComponentError, Entity, Fetch, Mut,
-    QueryFilter, QueryIter, ReadOnlyFetch, TypeAccess, World, WorldQuery,
-};
-use bevy_tasks::ParallelIterator;
-use std::marker::PhantomData;
-
-/// Provides scoped access to a World according to a given [WorldQuery]
-#[derive(Debug)]
-pub struct Query<'a, Q: WorldQuery, F: QueryFilter = ()> {
-    pub(crate) world: &'a World,
-    pub(crate) component_access: &'a TypeAccess<ArchetypeComponent>,
-    _marker: PhantomData<(Q, F)>,
-}
-
-/// An error that occurs when using a [Query]
-#[derive(Debug)]
-pub enum QueryError {
-    CannotReadArchetype,
-    CannotWriteArchetype,
-    ComponentError(ComponentError),
-    NoSuchEntity,
-}
-
-impl<'a, Q: WorldQuery, F: QueryFilter> Query<'a, Q, F> {
-    /// # Safety
-    /// This will create a Query that could violate memory safety rules. Make sure that this is only called in
-    /// ways that ensure the Queries have unique mutable access.
-    #[inline]
-    pub(crate) unsafe fn new(
-        world: &'a World,
-        component_access: &'a TypeAccess<ArchetypeComponent>,
-    ) -> Self {
-        Self {
-            world,
-            component_access,
-            _marker: PhantomData::default(),
-        }
-    }
-
-    /// Iterates over the query results. This can only be called for read-only queries
-    #[inline]
-    pub fn iter(&self) -> QueryIter<'_, Q, F>
-    where
-        Q::Fetch: ReadOnlyFetch,
-    {
-        // SAFE: system runs without conflicts with other systems. same-system queries have runtime borrow checks when they conflict
-        unsafe { self.world.query_unchecked() }
-    }
-
-    /// Iterates over the query results
-    #[inline]
-    pub fn iter_mut(&mut self) -> QueryIter<'_, Q, F> {
-        // SAFE: system runs without conflicts with other systems. same-system queries have runtime borrow checks when they conflict
-        unsafe { self.world.query_unchecked() }
-    }
-
-    /// Iterates over the query results
-    /// # Safety
-    /// This allows aliased mutability. You must make sure this call does not result in multiple mutable references to the same component
-    #[inline]
-    pub unsafe fn iter_unsafe(&self) -> QueryIter<'_, Q, F> {
-        // SAFE: system runs without conflicts with other systems. same-system queries have runtime borrow checks when they conflict
-        self.world.query_unchecked()
-    }
-
-    #[inline]
-    pub fn par_iter(&self, batch_size: usize) -> ParIter<'_, Q, F>
-    where
-        Q::Fetch: ReadOnlyFetch,
-    {
-        // SAFE: system runs without conflicts with other systems. same-system queries have runtime borrow checks when they conflict
-        unsafe { ParIter::new(self.world.query_batched_unchecked(batch_size)) }
-    }
-
-    #[inline]
-    pub fn par_iter_mut(&mut self, batch_size: usize) -> ParIter<'_, Q, F> {
-        // SAFE: system runs without conflicts with other systems. same-system queries have runtime borrow checks when they conflict
-        unsafe { ParIter::new(self.world.query_batched_unchecked(batch_size)) }
-    }
-
-    /// Gets the query result for the given `entity`
-    #[inline]
-    pub fn get(&self, entity: Entity) -> Result<<Q::Fetch as Fetch>::Item, QueryError>
-    where
-        Q::Fetch: ReadOnlyFetch,
-    {
-        // SAFE: system runs without conflicts with other systems. same-system queries have runtime borrow checks when they conflict
-        unsafe {
-            self.world
-                .query_one_unchecked::<Q, F>(entity)
-                .map_err(|_err| QueryError::NoSuchEntity)
-        }
-    }
-
-    /// Gets the query result for the given `entity`
-    #[inline]
-    pub fn get_mut(&mut self, entity: Entity) -> Result<<Q::Fetch as Fetch>::Item, QueryError> {
-        // SAFE: system runs without conflicts with other systems. same-system queries have runtime borrow checks when they conflict
-        unsafe {
-            self.world
-                .query_one_unchecked::<Q, F>(entity)
-                .map_err(|_err| QueryError::NoSuchEntity)
-        }
-    }
-
-    /// Gets the query result for the given `entity`
-    /// # Safety
-    /// This allows aliased mutability. You must make sure this call does not result in multiple mutable references to the same component
-    #[inline]
-    pub unsafe fn get_unsafe(
-        &self,
-        entity: Entity,
-    ) -> Result<<Q::Fetch as Fetch>::Item, QueryError> {
-        self.world
-            .query_one_unchecked::<Q, F>(entity)
-            .map_err(|_err| QueryError::NoSuchEntity)
-    }
-
-    /// Gets a reference to the entity's component of the given type. This will fail if the entity does not have
-    /// the given component type or if the given component type does not match this query.
-    pub fn get_component<T: Component>(&self, entity: Entity) -> Result<&T, QueryError> {
-        if let Some(location) = self.world.get_entity_location(entity) {
-            if self
-                .component_access
-                .is_read_or_write(&ArchetypeComponent::new::<T>(location.archetype))
-            {
-                // SAFE: we have already checked that the entity/component matches our archetype access. and systems are scheduled to run with safe archetype access
-                unsafe {
-                    self.world
-                        .get_at_location_unchecked(location)
-                        .map_err(QueryError::ComponentError)
-                }
-            } else {
-                Err(QueryError::CannotReadArchetype)
-            }
-        } else {
-            Err(QueryError::ComponentError(ComponentError::NoSuchEntity))
-        }
-    }
-
-    /// Gets a mutable reference to the entity's component of the given type. This will fail if the entity does not have
-    /// the given component type or if the given component type does not match this query.
-    pub fn get_component_mut<T: Component>(
-        &mut self,
-        entity: Entity,
-    ) -> Result<Mut<'_, T>, QueryError> {
-        let location = match self.world.get_entity_location(entity) {
-            None => return Err(QueryError::ComponentError(ComponentError::NoSuchEntity)),
-            Some(location) => location,
-        };
-
-        if self
-            .component_access
-            .is_write(&ArchetypeComponent::new::<T>(location.archetype))
-        {
-            // SAFE: RefMut does exclusivity checks and we have already validated the entity
-            unsafe {
-                self.world
-                    .get_mut_at_location_unchecked(location)
-                    .map_err(QueryError::ComponentError)
-            }
-        } else {
-            Err(QueryError::CannotWriteArchetype)
-        }
-    }
-
-    /// Gets a mutable reference to the entity's component of the given type. This will fail if the entity does not have
-    /// the given component type
-    /// # Safety
-    /// This allows aliased mutability. You must make sure this call does not result in multiple mutable references to the same component
-    pub unsafe fn get_component_unsafe<T: Component>(
-        &self,
-        entity: Entity,
-    ) -> Result<Mut<'_, T>, QueryError> {
-        self.world
-            .get_mut_unchecked(entity)
-            .map_err(QueryError::ComponentError)
-    }
-
-    /// Returns an array containing the `Entity`s in this `Query` that had the given `Component`
-    /// removed in this update.
-    ///
-    /// `removed::<C>()` only returns entities whose components were removed before the
-    /// current system started.
-    ///
-    /// Regular systems do not apply `Commands` until the end of their stage. This means component
-    /// removals in a regular system won't be accessible through `removed::<C>()` in the same
-    /// stage, because the removal hasn't actually occurred yet. This can be solved by executing
-    /// `removed::<C>()` in a later stage. `AppBuilder::add_system_to_stage()` can be used to
-    /// control at what stage a system runs.
-    ///
-    /// Thread local systems manipulate the world directly, so removes are applied immediately. This
-    /// means any system that runs after a thread local system in the same update will pick up
-    /// removals that happened in the thread local system, regardless of stages.
-    pub fn removed<C: Component>(&self) -> &[Entity] {
-        self.world.removed::<C>()
-    }
-
-    /// Sets the entity's component to the given value. This will fail if the entity does not already have
-    /// the given component type or if the given component type does not match this query.
-    pub fn set<T: Component>(&mut self, entity: Entity, component: T) -> Result<(), QueryError> {
-        let mut current = self.get_component_mut::<T>(entity)?;
-        *current = component;
-        Ok(())
-    }
-}
-
-/// Parallel version of QueryIter
-pub struct ParIter<'w, Q: WorldQuery, F: QueryFilter> {
-    batched_iter: BatchedIter<'w, Q, F>,
-}
-
-impl<'w, Q: WorldQuery, F: QueryFilter> ParIter<'w, Q, F> {
-    pub fn new(batched_iter: BatchedIter<'w, Q, F>) -> Self {
-        Self { batched_iter }
-    }
-}
-
-unsafe impl<'w, Q: WorldQuery, F: QueryFilter> Send for ParIter<'w, Q, F> {}
-
-impl<'w, Q: WorldQuery, F: QueryFilter> ParallelIterator<Batch<'w, Q, F>> for ParIter<'w, Q, F> {
-    type Item = <Q::Fetch as Fetch<'w>>::Item;
-
-    #[inline]
-    fn next_batch(&mut self) -> Option<Batch<'w, Q, F>> {
-        self.batched_iter.next()
-    }
-}
diff --git a/crates/bevy_ecs/src/system/query/query_set.rs b/crates/bevy_ecs/src/system/query/query_set.rs
deleted file mode 100644
index 5ee1e1f11fa80..0000000000000
--- a/crates/bevy_ecs/src/system/query/query_set.rs
+++ /dev/null
@@ -1,31 +0,0 @@
-use crate::{
-    impl_query_set, ArchetypeComponent, Fetch, Query, QueryAccess, QueryFilter, TypeAccess, World,
-    WorldQuery,
-};
-
-pub struct QuerySet<T: QueryTuple> {
-    value: T,
-}
-
-impl_query_set!();
-
-pub trait QueryTuple {
-    /// # Safety
-    /// this might cast world and component access to the relevant Self lifetimes. verify that this is safe in each impl
-    unsafe fn new(world: &World, component_access: &TypeAccess<ArchetypeComponent>) -> Self;
-    fn get_accesses() -> Vec<QueryAccess>;
-}
-
-impl<T: QueryTuple> QuerySet<T> {
-    /// # Safety
-    /// This will create a set of Query types that could violate memory safety rules. Make sure that this is only called in
-    /// ways that ensure the Queries have unique mutable access.
-    pub(crate) unsafe fn new(
-        world: &World,
-        component_access: &TypeAccess<ArchetypeComponent>,
-    ) -> Self {
-        QuerySet {
-            value: T::new(world, component_access),
-        }
-    }
-}
diff --git a/crates/bevy_ecs/src/system/system.rs b/crates/bevy_ecs/src/system/system.rs
index 98ea24a7e5ad2..5ddfa56e17466 100644
--- a/crates/bevy_ecs/src/system/system.rs
+++ b/crates/bevy_ecs/src/system/system.rs
@@ -1,5 +1,10 @@
-use crate::{ArchetypeComponent, Resources, TypeAccess, World};
-use std::{any::TypeId, borrow::Cow};
+use crate::{
+    archetype::{Archetype, ArchetypeComponentId},
+    component::ComponentId,
+    query::Access,
+    world::World,
+};
+use std::borrow::Cow;
 
 #[derive(Debug, Copy, Clone, Eq, PartialEq, Hash)]
 pub struct SystemId(pub usize);
@@ -11,38 +16,27 @@ impl SystemId {
     }
 }
 
-/// An ECS system that can be added to a [Schedule](crate::Schedule)
+/// An ECS system that can be added to a [Schedule](crate::schedule::Schedule)
 pub trait System: Send + Sync + 'static {
     type In;
     type Out;
     fn name(&self) -> Cow<'static, str>;
     fn id(&self) -> SystemId;
-    fn update_access(&mut self, world: &World);
-    fn archetype_component_access(&self) -> &TypeAccess<ArchetypeComponent>;
-    fn component_access(&self) -> &TypeAccess<TypeId>;
-    fn resource_access(&self) -> &TypeAccess<TypeId>;
-    fn is_non_send(&self) -> bool;
+    fn new_archetype(&mut self, archetype: &Archetype);
+    fn component_access(&self) -> &Access<ComponentId>;
+    fn archetype_component_access(&self) -> &Access<ArchetypeComponentId>;
+    fn is_send(&self) -> bool;
     /// # Safety
     /// This might access World and Resources in an unsafe manner. This should only be called in one of the following contexts:
-    /// 1. This system is the only system running on the given World and Resources across all threads
-    /// 2. This system only runs in parallel with other systems that do not conflict with the `archetype_component_access()` or `resource_access()`
-    unsafe fn run_unsafe(
-        &mut self,
-        input: Self::In,
-        world: &World,
-        resources: &Resources,
-    ) -> Option<Self::Out>;
-    fn run(
-        &mut self,
-        input: Self::In,
-        world: &mut World,
-        resources: &mut Resources,
-    ) -> Option<Self::Out> {
+    /// 1. This system is the only system running on the given World across all threads
+    /// 2. This system only runs in parallel with other systems that do not conflict with the `archetype_component_access()`
+    unsafe fn run_unsafe(&mut self, input: Self::In, world: &World) -> Self::Out;
+    fn run(&mut self, input: Self::In, world: &mut World) -> Self::Out {
         // SAFE: world and resources are exclusively borrowed
-        unsafe { self.run_unsafe(input, world, resources) }
+        unsafe { self.run_unsafe(input, world) }
     }
-    fn apply_buffers(&mut self, world: &mut World, resources: &mut Resources);
-    fn initialize(&mut self, world: &mut World, resources: &mut Resources);
+    fn apply_buffers(&mut self, world: &mut World);
+    fn initialize(&mut self, _world: &mut World);
 }
 
 pub type BoxedSystem<In = (), Out = ()> = Box<dyn System<In = In, Out = Out>>;
diff --git a/crates/bevy_ecs/src/system/system_chaining.rs b/crates/bevy_ecs/src/system/system_chaining.rs
index bca2ea5ae5c97..c620131d98039 100644
--- a/crates/bevy_ecs/src/system/system_chaining.rs
+++ b/crates/bevy_ecs/src/system/system_chaining.rs
@@ -1,14 +1,19 @@
-use crate::{ArchetypeComponent, Resources, System, SystemId, TypeAccess, World};
-use std::{any::TypeId, borrow::Cow};
+use crate::{
+    archetype::{Archetype, ArchetypeComponentId},
+    component::ComponentId,
+    query::Access,
+    system::{System, SystemId},
+    world::World,
+};
+use std::borrow::Cow;
 
 pub struct ChainSystem<SystemA, SystemB> {
     system_a: SystemA,
     system_b: SystemB,
     name: Cow<'static, str>,
     id: SystemId,
-    archetype_component_access: TypeAccess<ArchetypeComponent>,
-    component_access: TypeAccess<TypeId>,
-    resource_access: TypeAccess<TypeId>,
+    component_access: Access<ComponentId>,
+    archetype_component_access: Access<ArchetypeComponentId>,
 }
 
 impl<SystemA: System, SystemB: System<In = SystemA::Out>> System for ChainSystem<SystemA, SystemB> {
@@ -23,59 +28,45 @@ impl<SystemA: System, SystemB: System<In = SystemA::Out>> System for ChainSystem
         self.id
     }
 
-    fn update_access(&mut self, world: &World) {
-        self.archetype_component_access.clear();
-        self.component_access.clear();
-        self.resource_access.clear();
-        self.system_a.update_access(world);
-        self.system_b.update_access(world);
+    fn new_archetype(&mut self, archetype: &Archetype) {
+        self.system_a.new_archetype(archetype);
+        self.system_b.new_archetype(archetype);
 
         self.archetype_component_access
             .extend(self.system_a.archetype_component_access());
         self.archetype_component_access
             .extend(self.system_b.archetype_component_access());
-        self.component_access
-            .extend(self.system_a.component_access());
-        self.component_access
-            .extend(self.system_b.component_access());
-        self.resource_access.extend(self.system_a.resource_access());
-        self.resource_access.extend(self.system_b.resource_access());
     }
 
-    fn archetype_component_access(&self) -> &TypeAccess<ArchetypeComponent> {
+    fn archetype_component_access(&self) -> &Access<ArchetypeComponentId> {
         &self.archetype_component_access
     }
 
-    fn component_access(&self) -> &TypeAccess<TypeId> {
+    fn component_access(&self) -> &Access<ComponentId> {
         &self.component_access
     }
 
-    fn resource_access(&self) -> &TypeAccess<TypeId> {
-        &self.resource_access
-    }
-
-    fn is_non_send(&self) -> bool {
-        self.system_a.is_non_send() || self.system_b.is_non_send()
+    fn is_send(&self) -> bool {
+        self.system_a.is_send() && self.system_b.is_send()
     }
 
-    unsafe fn run_unsafe(
-        &mut self,
-        input: Self::In,
-        world: &World,
-        resources: &Resources,
-    ) -> Option<Self::Out> {
-        let out = self.system_a.run_unsafe(input, world, resources).unwrap();
-        self.system_b.run_unsafe(out, world, resources)
+    unsafe fn run_unsafe(&mut self, input: Self::In, world: &World) -> Self::Out {
+        let out = self.system_a.run_unsafe(input, world);
+        self.system_b.run_unsafe(out, world)
     }
 
-    fn apply_buffers(&mut self, world: &mut World, resources: &mut Resources) {
-        self.system_a.apply_buffers(world, resources);
-        self.system_b.apply_buffers(world, resources);
+    fn apply_buffers(&mut self, world: &mut World) {
+        self.system_a.apply_buffers(world);
+        self.system_b.apply_buffers(world);
     }
 
-    fn initialize(&mut self, world: &mut World, resources: &mut Resources) {
-        self.system_a.initialize(world, resources);
-        self.system_b.initialize(world, resources);
+    fn initialize(&mut self, world: &mut World) {
+        self.system_a.initialize(world);
+        self.system_b.initialize(world);
+        self.component_access
+            .extend(self.system_a.component_access());
+        self.component_access
+            .extend(self.system_b.component_access());
     }
 }
 
@@ -98,7 +89,6 @@ where
             system_b: system,
             archetype_component_access: Default::default(),
             component_access: Default::default(),
-            resource_access: Default::default(),
             id: SystemId::new(),
         }
     }
diff --git a/crates/bevy_ecs/src/system/system_param.rs b/crates/bevy_ecs/src/system/system_param.rs
index 233b0c9133d60..e98a504ca27bd 100644
--- a/crates/bevy_ecs/src/system/system_param.rs
+++ b/crates/bevy_ecs/src/system/system_param.rs
@@ -1,10 +1,18 @@
 use crate::{
-    ArchetypeComponent, Commands, Fetch, FromResources, Local, NonSend, Or, Query, QueryAccess,
-    QueryFilter, QuerySet, QueryTuple, Res, ResMut, Resource, ResourceIndex, Resources,
-    SystemState, TypeAccess, World, WorldQuery,
+    archetype::{Archetype, Archetypes},
+    bundle::Bundles,
+    component::{Component, ComponentFlags, ComponentId, Components},
+    entity::{Entities, Entity},
+    query::{FilterFetch, FilteredAccess, FilteredAccessSet, QueryState, WorldQuery},
+    system::{CommandQueue, Commands, Query, SystemState},
+    world::{FromWorld, World},
+};
+pub use bevy_ecs_macros::SystemParam;
+use bevy_ecs_macros::{all_tuples, impl_query_set};
+use std::{
+    marker::PhantomData,
+    ops::{Deref, DerefMut},
 };
-use parking_lot::Mutex;
-use std::{any::TypeId, marker::PhantomData, sync::Arc};
 
 /// A parameter that can be used in a system function
 ///
@@ -13,7 +21,7 @@ use std::{any::TypeId, marker::PhantomData, sync::Arc};
 ///
 /// ```
 /// # use bevy_ecs::prelude::*;
-/// use bevy_ecs::SystemParam;
+/// use bevy_ecs::system::SystemParam;
 ///
 /// #[derive(SystemParam)]
 /// pub struct MyParam<'a> {
@@ -25,359 +33,757 @@ use std::{any::TypeId, marker::PhantomData, sync::Arc};
 /// }
 /// ```
 pub trait SystemParam: Sized {
-    type Fetch: for<'a> FetchSystemParam<'a>;
+    type Fetch: for<'a> SystemParamFetch<'a>;
+}
+
+/// # Safety
+/// it is the implementors responsibility to ensure `system_state` is populated with the _exact_
+/// [World] access used by the SystemParamState (and associated FetchSystemParam). Additionally, it is the
+/// implementor's responsibility to ensure there is no conflicting access across all SystemParams.
+pub unsafe trait SystemParamState: Send + Sync + 'static {
+    type Config: Default + Send + Sync;
+    fn init(world: &mut World, system_state: &mut SystemState, config: Self::Config) -> Self;
+    #[inline]
+    fn new_archetype(&mut self, _archetype: &Archetype, _system_state: &mut SystemState) {}
+    #[inline]
+    fn apply(&mut self, _world: &mut World) {}
 }
 
-pub trait FetchSystemParam<'a> {
+pub trait SystemParamFetch<'a>: SystemParamState {
     type Item;
-    fn init(system_state: &mut SystemState, world: &World, resources: &mut Resources);
     /// # Safety
     /// This call might access any of the input parameters in an unsafe way. Make sure the data access is safe in
     /// the context of the system scheduler
     unsafe fn get_param(
+        state: &'a mut Self,
         system_state: &'a SystemState,
         world: &'a World,
-        resources: &'a Resources,
-    ) -> Option<Self::Item>;
+    ) -> Self::Item;
 }
 
-pub struct FetchQuery<Q, F>(PhantomData<(Q, F)>);
+pub struct QueryFetch<Q, F>(PhantomData<(Q, F)>);
 
-impl<'a, Q: WorldQuery, F: QueryFilter> SystemParam for Query<'a, Q, F> {
-    type Fetch = FetchQuery<Q, F>;
+impl<'a, Q: WorldQuery + 'static, F: WorldQuery + 'static> SystemParam for Query<'a, Q, F>
+where
+    F::Fetch: FilterFetch,
+{
+    type Fetch = QueryState<Q, F>;
 }
 
-impl<'a, Q: WorldQuery, F: QueryFilter> FetchSystemParam<'a> for FetchQuery<Q, F> {
+// SAFE: Relevant query ComponentId and ArchetypeComponentId access is applied to SystemState. If this QueryState conflicts
+// with any prior access, a panic will occur.
+unsafe impl<Q: WorldQuery + 'static, F: WorldQuery + 'static> SystemParamState for QueryState<Q, F>
+where
+    F::Fetch: FilterFetch,
+{
+    type Config = ();
+
+    fn init(world: &mut World, system_state: &mut SystemState, _config: Self::Config) -> Self {
+        let state = QueryState::new(world);
+        assert_component_access_compatibility(
+            &system_state.name,
+            std::any::type_name::<Q>(),
+            std::any::type_name::<F>(),
+            &system_state.component_access_set,
+            &state.component_access,
+            world,
+        );
+        system_state
+            .component_access_set
+            .add(state.component_access.clone());
+        system_state
+            .archetype_component_access
+            .extend(&state.archetype_component_access);
+        state
+    }
+
+    fn new_archetype(&mut self, archetype: &Archetype, system_state: &mut SystemState) {
+        self.new_archetype(archetype);
+        system_state
+            .archetype_component_access
+            .extend(&self.archetype_component_access);
+    }
+}
+
+impl<'a, Q: WorldQuery + 'static, F: WorldQuery + 'static> SystemParamFetch<'a> for QueryState<Q, F>
+where
+    F::Fetch: FilterFetch,
+{
     type Item = Query<'a, Q, F>;
 
     #[inline]
     unsafe fn get_param(
-        system_state: &'a SystemState,
+        state: &'a mut Self,
+        _system_state: &'a SystemState,
         world: &'a World,
-        _resources: &'a Resources,
-    ) -> Option<Self::Item> {
-        let query_index = *system_state.current_query_index.get();
-        let archetype_component_access: &'a TypeAccess<ArchetypeComponent> =
-            &system_state.query_archetype_component_accesses[query_index];
-        *system_state.current_query_index.get() += 1;
-        Some(Query::new(world, archetype_component_access))
+    ) -> Self::Item {
+        Query::new(world, state)
     }
+}
 
-    fn init(system_state: &mut SystemState, _world: &World, _resources: &mut Resources) {
-        system_state
-            .query_archetype_component_accesses
-            .push(TypeAccess::default());
-        let access = QueryAccess::union(vec![Q::Fetch::access(), F::access()]);
-        access.get_component_access(&mut system_state.component_access);
-        system_state.query_accesses.push(vec![access]);
-        system_state
-            .query_type_names
-            .push(std::any::type_name::<Q>());
+fn assert_component_access_compatibility(
+    system_name: &str,
+    query_type: &'static str,
+    filter_type: &'static str,
+    system_access: &FilteredAccessSet<ComponentId>,
+    current: &FilteredAccess<ComponentId>,
+    world: &World,
+) {
+    let mut conflicts = system_access.get_conflicts(current);
+    if conflicts.is_empty() {
+        return;
     }
+    let conflicting_components = conflicts
+        .drain(..)
+        .map(|component_id| world.components.get_info(component_id).unwrap().name())
+        .collect::<Vec<&str>>();
+    let accesses = conflicting_components.join(", ");
+    panic!("Query<{}, {}> in system {} accesses component(s) {} in a way that conflicts with a previous system parameter. Allowing this would break Rust's mutability rules. Consider merging conflicting Queries into a QuerySet.",
+                query_type, filter_type, system_name, accesses);
 }
 
-pub struct FetchQuerySet<T>(PhantomData<T>);
+pub struct QuerySet<T>(T);
+pub struct QuerySetState<T>(T);
 
-impl<T: QueryTuple> SystemParam for QuerySet<T> {
-    type Fetch = FetchQuerySet<T>;
+impl_query_set!();
+
+pub struct Res<'w, T> {
+    value: &'w T,
+    flags: ComponentFlags,
 }
 
-impl<'a, T: QueryTuple> FetchSystemParam<'a> for FetchQuerySet<T> {
-    type Item = QuerySet<T>;
+impl<'w, T: Component> Res<'w, T> {
+    /// Returns true if (and only if) this resource been added since the start of the frame.
+    pub fn added(&self) -> bool {
+        self.flags.contains(ComponentFlags::ADDED)
+    }
+
+    /// Returns true if (and only if) this resource been mutated since the start of the frame.
+    pub fn mutated(&self) -> bool {
+        self.flags.contains(ComponentFlags::MUTATED)
+    }
+
+    /// Returns true if (and only if) this resource been either mutated or added since the start of the frame.
+    pub fn changed(&self) -> bool {
+        self.flags
+            .intersects(ComponentFlags::ADDED | ComponentFlags::MUTATED)
+    }
+}
+
+impl<'w, T: Component> Deref for Res<'w, T> {
+    type Target = T;
+
+    fn deref(&self) -> &Self::Target {
+        self.value
+    }
+}
+
+pub struct ResState<T> {
+    component_id: ComponentId,
+    marker: PhantomData<T>,
+}
+
+impl<'a, T: Component> SystemParam for Res<'a, T> {
+    type Fetch = ResState<T>;
+}
+
+// SAFE: Res ComponentId and ArchetypeComponentId access is applied to SystemState. If this Res conflicts
+// with any prior access, a panic will occur.
+unsafe impl<T: Component> SystemParamState for ResState<T> {
+    type Config = ();
+
+    fn init(world: &mut World, system_state: &mut SystemState, _config: Self::Config) -> Self {
+        let component_id = world.initialize_resource::<T>();
+        let combined_access = system_state.component_access_set.combined_access_mut();
+        if combined_access.has_write(component_id) {
+            panic!(
+                "Res<{}> in system {} conflicts with a previous ResMut<{0}> access. Allowing this would break Rust's mutability rules. Consider removing the duplicate access.",
+                std::any::type_name::<T>(), system_state.name);
+        }
+        combined_access.add_read(component_id);
+
+        let resource_archetype = world.archetypes.resource();
+        let archetype_component_id = resource_archetype
+            .get_archetype_component_id(component_id)
+            .unwrap();
+        system_state
+            .archetype_component_access
+            .add_read(archetype_component_id);
+        Self {
+            component_id,
+            marker: PhantomData,
+        }
+    }
+}
+
+impl<'a, T: Component> SystemParamFetch<'a> for ResState<T> {
+    type Item = Res<'a, T>;
 
     #[inline]
     unsafe fn get_param(
-        system_state: &'a SystemState,
+        state: &'a mut Self,
+        _system_state: &'a SystemState,
         world: &'a World,
-        _resources: &'a Resources,
-    ) -> Option<Self::Item> {
-        let query_index = *system_state.current_query_index.get();
-        *system_state.current_query_index.get() += 1;
-        Some(QuerySet::new(
-            world,
-            &system_state.query_archetype_component_accesses[query_index],
-        ))
+    ) -> Self::Item {
+        let column = world
+            .get_populated_resource_column(state.component_id)
+            .expect("Requested resource does not exist");
+        Res {
+            value: &*column.get_ptr().as_ptr().cast::<T>(),
+            flags: *column.get_flags_mut_ptr(),
+        }
     }
+}
 
-    fn init(system_state: &mut SystemState, _world: &World, _resources: &mut Resources) {
-        system_state
-            .query_archetype_component_accesses
-            .push(TypeAccess::default());
-        let accesses = T::get_accesses();
-        for access in &accesses {
-            access.get_component_access(&mut system_state.component_access);
+pub struct ResMut<'w, T> {
+    value: &'w mut T,
+    flags: &'w mut ComponentFlags,
+}
+
+impl<'w, T: Component> ResMut<'w, T> {
+    /// Returns true if (and only if) this resource been added since the start of the frame.
+    pub fn added(&self) -> bool {
+        self.flags.contains(ComponentFlags::ADDED)
+    }
+
+    /// Returns true if (and only if) this resource been mutated since the start of the frame.
+    pub fn mutated(&self) -> bool {
+        self.flags.contains(ComponentFlags::MUTATED)
+    }
+
+    /// Returns true if (and only if) this resource been either mutated or added since the start of the frame.
+    pub fn changed(&self) -> bool {
+        self.flags
+            .intersects(ComponentFlags::ADDED | ComponentFlags::MUTATED)
+    }
+}
+
+impl<'w, T: Component> Deref for ResMut<'w, T> {
+    type Target = T;
+
+    fn deref(&self) -> &Self::Target {
+        self.value
+    }
+}
+
+impl<'w, T: Component> DerefMut for ResMut<'w, T> {
+    fn deref_mut(&mut self) -> &mut Self::Target {
+        self.flags.insert(ComponentFlags::MUTATED);
+        self.value
+    }
+}
+
+pub struct ResMutState<T> {
+    component_id: ComponentId,
+    marker: PhantomData<T>,
+}
+
+impl<'a, T: Component> SystemParam for ResMut<'a, T> {
+    type Fetch = ResMutState<T>;
+}
+
+// SAFE: Res ComponentId and ArchetypeComponentId access is applied to SystemState. If this Res conflicts
+// with any prior access, a panic will occur.
+unsafe impl<T: Component> SystemParamState for ResMutState<T> {
+    type Config = ();
+
+    fn init(world: &mut World, system_state: &mut SystemState, _config: Self::Config) -> Self {
+        let component_id = world.initialize_resource::<T>();
+        let combined_access = system_state.component_access_set.combined_access_mut();
+        if combined_access.has_write(component_id) {
+            panic!(
+                "ResMut<{}> in system {} conflicts with a previous ResMut<{0}> access. Allowing this would break Rust's mutability rules. Consider removing the duplicate access.",
+                std::any::type_name::<T>(), system_state.name);
+        } else if combined_access.has_read(component_id) {
+            panic!(
+                "ResMut<{}> in system {} conflicts with a previous Res<{0}> access. Allowing this would break Rust's mutability rules. Consider removing the duplicate access.",
+                std::any::type_name::<T>(), system_state.name);
         }
-        system_state.query_accesses.push(accesses);
+        combined_access.add_write(component_id);
+
+        let resource_archetype = world.archetypes.resource();
+        let archetype_component_id = resource_archetype
+            .get_archetype_component_id(component_id)
+            .unwrap();
         system_state
-            .query_type_names
-            .push(std::any::type_name::<T>());
+            .archetype_component_access
+            .add_write(archetype_component_id);
+        Self {
+            component_id,
+            marker: PhantomData,
+        }
     }
 }
 
-pub struct FetchCommands;
+impl<'a, T: Component> SystemParamFetch<'a> for ResMutState<T> {
+    type Item = ResMut<'a, T>;
+
+    #[inline]
+    unsafe fn get_param(
+        state: &'a mut Self,
+        _system_state: &'a SystemState,
+        world: &'a World,
+    ) -> Self::Item {
+        let value = world
+            .get_resource_unchecked_mut_with_id(state.component_id)
+            .expect("Requested resource does not exist");
+        ResMut {
+            value: value.value,
+            flags: value.flags,
+        }
+    }
+}
 
-impl<'a> SystemParam for &'a mut Commands {
-    type Fetch = FetchCommands;
+impl<'a> SystemParam for Commands<'a> {
+    type Fetch = CommandQueue;
 }
-impl<'a> FetchSystemParam<'a> for FetchCommands {
-    type Item = &'a mut Commands;
 
-    fn init(system_state: &mut SystemState, world: &World, _resources: &mut Resources) {
-        // SAFE: this is called with unique access to SystemState
-        unsafe {
-            (&mut *system_state.commands.get()).set_entity_reserver(world.get_entity_reserver())
-        }
+// SAFE: only local state is accessed
+unsafe impl SystemParamState for CommandQueue {
+    type Config = ();
+
+    fn init(_world: &mut World, _system_state: &mut SystemState, _config: Self::Config) -> Self {
+        Default::default()
+    }
+
+    fn apply(&mut self, world: &mut World) {
+        self.apply(world);
     }
+}
+
+impl<'a> SystemParamFetch<'a> for CommandQueue {
+    type Item = Commands<'a>;
 
     #[inline]
     unsafe fn get_param(
-        system_state: &'a SystemState,
-        _world: &'a World,
-        _resources: &'a Resources,
-    ) -> Option<Self::Item> {
-        Some(&mut *system_state.commands.get())
+        state: &'a mut Self,
+        _system_state: &'a SystemState,
+        world: &'a World,
+    ) -> Self::Item {
+        Commands::new(state, world)
     }
 }
 
-pub struct FetchArcCommands;
-impl SystemParam for Arc<Mutex<Commands>> {
-    type Fetch = FetchArcCommands;
+pub struct Local<'a, T: Component>(&'a mut T);
+
+impl<'a, T: Component> Deref for Local<'a, T> {
+    type Target = T;
+
+    #[inline]
+    fn deref(&self) -> &Self::Target {
+        self.0
+    }
+}
+
+impl<'a, T: Component> DerefMut for Local<'a, T> {
+    #[inline]
+    fn deref_mut(&mut self) -> &mut Self::Target {
+        self.0
+    }
 }
 
-impl<'a> FetchSystemParam<'a> for FetchArcCommands {
-    type Item = Arc<Mutex<Commands>>;
+pub struct LocalState<T: Component>(T);
 
-    fn init(system_state: &mut SystemState, world: &World, _resources: &mut Resources) {
-        system_state.arc_commands.get_or_insert_with(|| {
-            let mut commands = Commands::default();
-            commands.set_entity_reserver(world.get_entity_reserver());
-            Arc::new(Mutex::new(commands))
-        });
+impl<'a, T: Component + FromWorld> SystemParam for Local<'a, T> {
+    type Fetch = LocalState<T>;
+}
+
+// SAFE: only local state is accessed
+unsafe impl<T: Component + FromWorld> SystemParamState for LocalState<T> {
+    type Config = Option<T>;
+
+    fn init(world: &mut World, _system_state: &mut SystemState, config: Self::Config) -> Self {
+        Self(config.unwrap_or_else(|| T::from_world(world)))
     }
+}
+
+impl<'a, T: Component + FromWorld> SystemParamFetch<'a> for LocalState<T> {
+    type Item = Local<'a, T>;
 
     #[inline]
     unsafe fn get_param(
-        system_state: &SystemState,
-        _world: &World,
-        _resources: &Resources,
-    ) -> Option<Self::Item> {
-        Some(system_state.arc_commands.as_ref().unwrap().clone())
+        state: &'a mut Self,
+        _system_state: &'a SystemState,
+        _world: &'a World,
+    ) -> Self::Item {
+        Local(&mut state.0)
     }
 }
 
-pub struct FetchRes<T>(PhantomData<T>);
+pub struct RemovedComponents<'a, T> {
+    world: &'a World,
+    component_id: ComponentId,
+    marker: PhantomData<T>,
+}
 
-impl<'a, T: Resource> SystemParam for Res<'a, T> {
-    type Fetch = FetchRes<T>;
+impl<'a, T> RemovedComponents<'a, T> {
+    pub fn iter(&self) -> std::iter::Cloned<std::slice::Iter<'_, Entity>> {
+        self.world.removed_with_id(self.component_id)
+    }
 }
 
-impl<'a, T: Resource> FetchSystemParam<'a> for FetchRes<T> {
-    type Item = Res<'a, T>;
+pub struct RemovedComponentsState<T> {
+    component_id: ComponentId,
+    marker: PhantomData<T>,
+}
 
-    fn init(system_state: &mut SystemState, _world: &World, _resources: &mut Resources) {
-        if system_state.resource_access.is_write(&TypeId::of::<T>()) {
-            panic!(
-                "System `{}` has a `Res<{res}>` parameter that conflicts with \
-                another parameter with mutable access to the same `{res}` resource.",
-                system_state.name,
-                res = std::any::type_name::<T>()
-            );
+impl<'a, T: Component> SystemParam for RemovedComponents<'a, T> {
+    type Fetch = RemovedComponentsState<T>;
+}
+
+// SAFE: no component access. removed component entity collections can be read in parallel and are never mutably borrowed
+// during system execution
+unsafe impl<T: Component> SystemParamState for RemovedComponentsState<T> {
+    type Config = ();
+
+    fn init(world: &mut World, _system_state: &mut SystemState, _config: Self::Config) -> Self {
+        Self {
+            component_id: world.components.get_or_insert_id::<T>(),
+            marker: PhantomData,
         }
-        system_state.resource_access.add_read(TypeId::of::<T>());
     }
+}
+
+impl<'a, T: Component> SystemParamFetch<'a> for RemovedComponentsState<T> {
+    type Item = RemovedComponents<'a, T>;
 
     #[inline]
     unsafe fn get_param(
+        state: &'a mut Self,
         _system_state: &'a SystemState,
-        _world: &'a World,
-        resources: &'a Resources,
-    ) -> Option<Self::Item> {
-        let result = resources.get_unsafe_ref_with_added_and_mutated::<T>(ResourceIndex::Global);
-        Some(Res::new(result.0, *result.1.as_ptr(), *result.2.as_ptr()))
+        world: &'a World,
+    ) -> Self::Item {
+        RemovedComponents {
+            world,
+            component_id: state.component_id,
+            marker: PhantomData,
+        }
     }
 }
 
-pub struct FetchResMut<T>(PhantomData<T>);
+/// Shared borrow of a NonSend resource
+pub struct NonSend<'w, T> {
+    pub(crate) value: &'w T,
+}
+
+impl<'w, T: 'static> Deref for NonSend<'w, T> {
+    type Target = T;
 
-impl<'a, T: Resource> SystemParam for ResMut<'a, T> {
-    type Fetch = FetchResMut<T>;
+    fn deref(&self) -> &Self::Target {
+        self.value
+    }
 }
-impl<'a, T: Resource> FetchSystemParam<'a> for FetchResMut<T> {
-    type Item = ResMut<'a, T>;
 
-    fn init(system_state: &mut SystemState, _world: &World, _resources: &mut Resources) {
-        // If a system already has access to the resource in another parameter, then we fail early.
-        // e.g. `fn(Res<Foo>, ResMut<Foo>)` or `fn(ResMut<Foo>, ResMut<Foo>)` must not be allowed.
-        if system_state
-            .resource_access
-            .is_read_or_write(&TypeId::of::<T>())
-        {
+pub struct NonSendState<T> {
+    component_id: ComponentId,
+    marker: PhantomData<fn() -> T>,
+}
+
+impl<'a, T: 'static> SystemParam for NonSend<'a, T> {
+    type Fetch = NonSendState<T>;
+}
+
+// SAFE: NonSendComponentId and ArchetypeComponentId access is applied to SystemState. If this NonSend conflicts
+// with any prior access, a panic will occur.
+unsafe impl<T: 'static> SystemParamState for NonSendState<T> {
+    type Config = ();
+
+    fn init(world: &mut World, system_state: &mut SystemState, _config: Self::Config) -> Self {
+        system_state.set_non_send();
+
+        let component_id = world.initialize_non_send_resource::<T>();
+        let combined_access = system_state.component_access_set.combined_access_mut();
+        if combined_access.has_write(component_id) {
             panic!(
-                "System `{}` has a `ResMut<{res}>` parameter that conflicts with \
-                another parameter to the same `{res}` resource. `ResMut` must have unique access.",
-                system_state.name,
-                res = std::any::type_name::<T>()
-            );
+                "NonSend<{}> in system {} conflicts with a previous mutable resource access ({0}). Allowing this would break Rust's mutability rules. Consider removing the duplicate access.",
+                std::any::type_name::<T>(), system_state.name);
+        }
+        combined_access.add_read(component_id);
+
+        let resource_archetype = world.archetypes.resource();
+        let archetype_component_id = resource_archetype
+            .get_archetype_component_id(component_id)
+            .unwrap();
+        system_state
+            .archetype_component_access
+            .add_read(archetype_component_id);
+        Self {
+            component_id,
+            marker: PhantomData,
         }
-        system_state.resource_access.add_write(TypeId::of::<T>());
     }
+}
+
+impl<'a, T: 'static> SystemParamFetch<'a> for NonSendState<T> {
+    type Item = NonSend<'a, T>;
 
     #[inline]
     unsafe fn get_param(
+        state: &'a mut Self,
         _system_state: &'a SystemState,
-        _world: &'a World,
-        resources: &'a Resources,
-    ) -> Option<Self::Item> {
-        let (value, added, mutated) =
-            resources.get_unsafe_ref_with_added_and_mutated::<T>(ResourceIndex::Global);
-        Some(ResMut::new(value, *added.as_ptr(), mutated))
+        world: &'a World,
+    ) -> Self::Item {
+        NonSend {
+            value: world
+                .get_non_send_with_id::<T>(state.component_id)
+                .expect("Requested non-send resource does not exist"),
+        }
     }
 }
 
-pub struct FetchLocal<T>(PhantomData<T>);
+/// Unique borrow of a NonSend resource
+pub struct NonSendMut<'a, T: 'static> {
+    pub(crate) value: &'a mut T,
+    pub(crate) flags: &'a mut ComponentFlags,
+}
+
+impl<'a, T: 'static> Deref for NonSendMut<'a, T> {
+    type Target = T;
 
-impl<'a, T: Resource + FromResources> SystemParam for Local<'a, T> {
-    type Fetch = FetchLocal<T>;
+    #[inline]
+    fn deref(&self) -> &T {
+        self.value
+    }
 }
-impl<'a, T: Resource + FromResources> FetchSystemParam<'a> for FetchLocal<T> {
-    type Item = Local<'a, T>;
 
-    fn init(system_state: &mut SystemState, _world: &World, resources: &mut Resources) {
-        if system_state
-            .local_resource_access
-            .is_read_or_write(&TypeId::of::<T>())
-        {
+impl<'a, T: 'static> DerefMut for NonSendMut<'a, T> {
+    #[inline]
+    fn deref_mut(&mut self) -> &mut T {
+        self.flags.insert(ComponentFlags::MUTATED);
+        self.value
+    }
+}
+
+impl<'a, T: 'static + core::fmt::Debug> core::fmt::Debug for NonSendMut<'a, T> {
+    fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
+        self.value.fmt(f)
+    }
+}
+
+pub struct NonSendMutState<T> {
+    component_id: ComponentId,
+    marker: PhantomData<fn() -> T>,
+}
+
+impl<'a, T: 'static> SystemParam for NonSendMut<'a, T> {
+    type Fetch = NonSendMutState<T>;
+}
+
+// SAFE: NonSendMut ComponentId and ArchetypeComponentId access is applied to SystemState. If this NonSendMut conflicts
+// with any prior access, a panic will occur.
+unsafe impl<T: 'static> SystemParamState for NonSendMutState<T> {
+    type Config = ();
+
+    fn init(world: &mut World, system_state: &mut SystemState, _config: Self::Config) -> Self {
+        system_state.set_non_send();
+
+        let component_id = world.components.get_or_insert_non_send_resource_id::<T>();
+        let combined_access = system_state.component_access_set.combined_access_mut();
+        if combined_access.has_write(component_id) {
             panic!(
-                "System `{}` has multiple parameters requesting access to a local resource of type `{}`. \
-                There may be at most one `Local` parameter per resource type.",
-                system_state.name,
-                std::any::type_name::<T>()
-            );
+                "NonSendMut<{}> in system {} conflicts with a previous mutable resource access ({0}). Allowing this would break Rust's mutability rules. Consider removing the duplicate access.",
+                std::any::type_name::<T>(), system_state.name);
+        } else if combined_access.has_read(component_id) {
+            panic!(
+                "NonSendMut<{}> in system {} conflicts with a previous immutable resource access ({0}). Allowing this would break Rust's mutability rules. Consider removing the duplicate access.",
+                std::any::type_name::<T>(), system_state.name);
         }
+        combined_access.add_write(component_id);
 
-        // A resource could have been already initialized by another system with
-        // `Commands::insert_local_resource` or `Resources::insert_local`
-        if resources.get_local::<T>(system_state.id).is_none() {
-            let value = T::from_resources(resources);
-            resources.insert_local(system_state.id, value);
+        let resource_archetype = world.archetypes.resource();
+        let archetype_component_id = resource_archetype
+            .get_archetype_component_id(component_id)
+            .unwrap();
+        system_state
+            .archetype_component_access
+            .add_write(archetype_component_id);
+        Self {
+            component_id,
+            marker: PhantomData,
         }
+    }
+}
 
-        system_state
-            .local_resource_access
-            .add_write(TypeId::of::<T>());
+impl<'a, T: 'static> SystemParamFetch<'a> for NonSendMutState<T> {
+    type Item = NonSendMut<'a, T>;
+
+    #[inline]
+    unsafe fn get_param(
+        state: &'a mut Self,
+        _system_state: &'a SystemState,
+        world: &'a World,
+    ) -> Self::Item {
+        let value = world
+            .get_non_send_unchecked_mut_with_id(state.component_id)
+            .expect("Requested non-send resource does not exist");
+        NonSendMut {
+            value: value.value,
+            flags: value.flags,
+        }
     }
+}
+
+pub struct OrState<T>(T);
+
+impl<'a> SystemParam for &'a Archetypes {
+    type Fetch = ArchetypesState;
+}
+
+pub struct ArchetypesState;
+
+// SAFE: no component value access
+unsafe impl SystemParamState for ArchetypesState {
+    type Config = ();
+
+    fn init(_world: &mut World, _system_state: &mut SystemState, _config: Self::Config) -> Self {
+        Self
+    }
+}
+
+impl<'a> SystemParamFetch<'a> for ArchetypesState {
+    type Item = &'a Archetypes;
 
     #[inline]
     unsafe fn get_param(
-        system_state: &'a SystemState,
-        _world: &'a World,
-        resources: &'a Resources,
-    ) -> Option<Self::Item> {
-        Some(Local::new(resources, system_state.id))
+        _state: &'a mut Self,
+        _system_state: &'a SystemState,
+        world: &'a World,
+    ) -> Self::Item {
+        world.archetypes()
     }
 }
 
-pub struct FetchNonSend<T>(PhantomData<T>);
+impl<'a> SystemParam for &'a Components {
+    type Fetch = ComponentsState;
+}
 
-impl<'a, T: Resource> SystemParam for NonSend<'a, T> {
-    type Fetch = FetchNonSend<T>;
+pub struct ComponentsState;
+
+// SAFE: no component value access
+unsafe impl SystemParamState for ComponentsState {
+    type Config = ();
+
+    fn init(_world: &mut World, _system_state: &mut SystemState, _config: Self::Config) -> Self {
+        Self
+    }
 }
 
-impl<'a, T: Resource> FetchSystemParam<'a> for FetchNonSend<T> {
-    type Item = NonSend<'a, T>;
+impl<'a> SystemParamFetch<'a> for ComponentsState {
+    type Item = &'a Components;
+
+    #[inline]
+    unsafe fn get_param(
+        _state: &'a mut Self,
+        _system_state: &'a SystemState,
+        world: &'a World,
+    ) -> Self::Item {
+        world.components()
+    }
+}
+
+impl<'a> SystemParam for &'a Entities {
+    type Fetch = EntitiesState;
+}
+
+pub struct EntitiesState;
 
-    fn init(system_state: &mut SystemState, _world: &World, _resources: &mut Resources) {
-        // !Send systems run only on the main thread, so only one system
-        // at a time will ever access any thread-local resource.
-        system_state.is_non_send = true;
+// SAFE: no component value access
+unsafe impl SystemParamState for EntitiesState {
+    type Config = ();
+
+    fn init(_world: &mut World, _system_state: &mut SystemState, _config: Self::Config) -> Self {
+        Self
     }
+}
+
+impl<'a> SystemParamFetch<'a> for EntitiesState {
+    type Item = &'a Entities;
 
     #[inline]
     unsafe fn get_param(
+        _state: &'a mut Self,
         _system_state: &'a SystemState,
-        _world: &'a World,
-        resources: &'a Resources,
-    ) -> Option<Self::Item> {
-        Some(NonSend::new(resources))
+        world: &'a World,
+    ) -> Self::Item {
+        world.entities()
     }
 }
 
-pub struct FetchParamTuple<T>(PhantomData<T>);
-pub struct FetchOr<T>(PhantomData<T>);
+impl<'a> SystemParam for &'a Bundles {
+    type Fetch = BundlesState;
+}
+
+pub struct BundlesState;
+
+// SAFE: no component value access
+unsafe impl SystemParamState for BundlesState {
+    type Config = ();
+
+    fn init(_world: &mut World, _system_state: &mut SystemState, _config: Self::Config) -> Self {
+        Self
+    }
+}
+
+impl<'a> SystemParamFetch<'a> for BundlesState {
+    type Item = &'a Bundles;
+
+    #[inline]
+    unsafe fn get_param(
+        _state: &'a mut Self,
+        _system_state: &'a SystemState,
+        world: &'a World,
+    ) -> Self::Item {
+        world.bundles()
+    }
+}
 
 macro_rules! impl_system_param_tuple {
     ($($param: ident),*) => {
         impl<$($param: SystemParam),*> SystemParam for ($($param,)*) {
-            type Fetch = FetchParamTuple<($($param::Fetch,)*)>;
+            type Fetch = ($($param::Fetch,)*);
         }
         #[allow(unused_variables)]
-        impl<'a, $($param: FetchSystemParam<'a>),*> FetchSystemParam<'a> for FetchParamTuple<($($param,)*)> {
+        #[allow(non_snake_case)]
+        impl<'a, $($param: SystemParamFetch<'a>),*> SystemParamFetch<'a> for ($($param,)*) {
             type Item = ($($param::Item,)*);
-            fn init(system_state: &mut SystemState, world: &World, resources: &mut Resources) {
-                $($param::init(system_state, world, resources);)*
-            }
 
             #[inline]
             unsafe fn get_param(
+                state: &'a mut Self,
                 system_state: &'a SystemState,
                 world: &'a World,
-                resources: &'a Resources,
-            ) -> Option<Self::Item> {
-                Some(($($param::get_param(system_state, world, resources)?,)*))
-            }
-        }
+            ) -> Self::Item {
 
-        impl<$($param: SystemParam),*> SystemParam for Or<($(Option<$param>,)*)> {
-            type Fetch = FetchOr<($($param::Fetch,)*)>;
+                let ($($param,)*) = state;
+                ($($param::get_param($param, system_state, world),)*)
+            }
         }
 
-        #[allow(unused_variables)]
-        #[allow(unused_mut)]
+        /// SAFE: implementors of each SystemParamState in the tuple have validated their impls
         #[allow(non_snake_case)]
-        impl<'a, $($param: FetchSystemParam<'a>),*> FetchSystemParam<'a> for FetchOr<($($param,)*)> {
-            type Item = Or<($(Option<$param::Item>,)*)>;
-            fn init(system_state: &mut SystemState, world: &World, resources: &mut Resources) {
-                $($param::init(system_state, world, resources);)*
+        unsafe impl<$($param: SystemParamState),*> SystemParamState for ($($param,)*) {
+            type Config = ($(<$param as SystemParamState>::Config,)*);
+            #[inline]
+            fn init(_world: &mut World, _system_state: &mut SystemState, config: Self::Config) -> Self {
+                let ($($param,)*) = config;
+                (($($param::init(_world, _system_state, $param),)*))
             }
 
             #[inline]
-            unsafe fn get_param(
-                system_state: &'a SystemState,
-                world: &'a World,
-                resources: &'a Resources,
-            ) -> Option<Self::Item> {
-                let mut has_some = false;
-                $(
-                    let $param = $param::get_param(system_state, world, resources);
-                    if $param.is_some() {
-                        has_some = true;
-                    }
-                )*
-
-                if has_some {
-                    Some(Or(($($param,)*)))
-                } else {
-                    None
-                }
+            fn new_archetype(&mut self, _archetype: &Archetype, _system_state: &mut SystemState) {
+                let ($($param,)*) = self;
+                $($param.new_archetype(_archetype, _system_state);)*
+            }
+
+            #[inline]
+            fn apply(&mut self, _world: &mut World) {
+                let ($($param,)*) = self;
+                $($param.apply(_world);)*
             }
         }
     };
 }
 
-impl_system_param_tuple!();
-impl_system_param_tuple!(A);
-impl_system_param_tuple!(A, B);
-impl_system_param_tuple!(A, B, C);
-impl_system_param_tuple!(A, B, C, D);
-impl_system_param_tuple!(A, B, C, D, E);
-impl_system_param_tuple!(A, B, C, D, E, F);
-impl_system_param_tuple!(A, B, C, D, E, F, G);
-impl_system_param_tuple!(A, B, C, D, E, F, G, H);
-impl_system_param_tuple!(A, B, C, D, E, F, G, H, I);
-impl_system_param_tuple!(A, B, C, D, E, F, G, H, I, J);
-impl_system_param_tuple!(A, B, C, D, E, F, G, H, I, J, K);
-impl_system_param_tuple!(A, B, C, D, E, F, G, H, I, J, K, L);
-impl_system_param_tuple!(A, B, C, D, E, F, G, H, I, J, K, L, M);
-impl_system_param_tuple!(A, B, C, D, E, F, G, H, I, J, K, L, M, N);
-impl_system_param_tuple!(A, B, C, D, E, F, G, H, I, J, K, L, M, N, O);
-impl_system_param_tuple!(A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P);
+// TODO: consider creating a Config trait with a default() function, then implementing that for tuples.
+// that would allow us to go past tuples of len 12
+all_tuples!(impl_system_param_tuple, 0, 12, P);
diff --git a/crates/bevy_ecs/src/tests/tests.rs b/crates/bevy_ecs/src/tests/tests.rs
deleted file mode 100644
index 8054d8444ec08..0000000000000
--- a/crates/bevy_ecs/src/tests/tests.rs
+++ /dev/null
@@ -1,391 +0,0 @@
-// Copyright 2019 Google LLC
-//
-// Licensed under the Apache License, Version 2.0 (the "License");
-// you may not use this file except in compliance with the License.
-// You may obtain a copy of the License at
-//
-//     https://www.apache.org/licenses/LICENSE-2.0
-//
-// Unless required by applicable law or agreed to in writing, software
-// distributed under the License is distributed on an "AS IS" BASIS,
-// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-// See the License for the specific language governing permissions and
-// limitations under the License.
-
-// modified by Bevy contributors
-
-use bevy_ecs::*;
-
-#[test]
-fn random_access() {
-    let mut world = World::new();
-    let e = world.spawn(("abc", 123));
-    let f = world.spawn(("def", 456, true));
-    assert_eq!(*world.get::<&str>(e).unwrap(), "abc");
-    assert_eq!(*world.get::<i32>(e).unwrap(), 123);
-    assert_eq!(*world.get::<&str>(f).unwrap(), "def");
-    assert_eq!(*world.get::<i32>(f).unwrap(), 456);
-    *world.get_mut::<i32>(f).unwrap() = 42;
-    assert_eq!(*world.get::<i32>(f).unwrap(), 42);
-}
-
-#[test]
-fn despawn() {
-    let mut world = World::new();
-    let e = world.spawn(("abc", 123));
-    let f = world.spawn(("def", 456));
-    assert_eq!(world.query::<()>().count(), 2);
-    world.despawn(e).unwrap();
-    assert_eq!(world.query::<()>().count(), 1);
-    assert!(world.get::<&str>(e).is_err());
-    assert!(world.get::<i32>(e).is_err());
-    assert_eq!(*world.get::<&str>(f).unwrap(), "def");
-    assert_eq!(*world.get::<i32>(f).unwrap(), 456);
-}
-
-#[test]
-fn query_all() {
-    let mut world = World::new();
-    let e = world.spawn(("abc", 123));
-    let f = world.spawn(("def", 456));
-
-    let ents = world
-        .query::<(Entity, &i32, &&str)>()
-        .map(|(e, &i, &s)| (e, i, s))
-        .collect::<Vec<_>>();
-    assert_eq!(ents.len(), 2);
-    assert!(ents.contains(&(e, 123, "abc")));
-    assert!(ents.contains(&(f, 456, "def")));
-
-    let ents = world.query::<Entity>().collect::<Vec<_>>();
-    assert_eq!(ents.len(), 2);
-    assert!(ents.contains(&e));
-    assert!(ents.contains(&f));
-}
-
-#[test]
-fn query_single_component() {
-    let mut world = World::new();
-    let e = world.spawn(("abc", 123));
-    let f = world.spawn(("def", 456, true));
-    let ents = world
-        .query::<(Entity, &i32)>()
-        .map(|(e, &i)| (e, i))
-        .collect::<Vec<_>>();
-    assert_eq!(ents.len(), 2);
-    assert!(ents.contains(&(e, 123)));
-    assert!(ents.contains(&(f, 456)));
-}
-
-#[test]
-fn query_missing_component() {
-    let mut world = World::new();
-    world.spawn(("abc", 123));
-    world.spawn(("def", 456));
-    assert!(world.query::<(&bool, &i32)>().next().is_none());
-}
-
-#[test]
-fn query_sparse_component() {
-    let mut world = World::new();
-    world.spawn(("abc", 123));
-    let f = world.spawn(("def", 456, true));
-    let ents = world
-        .query::<(Entity, &bool)>()
-        .map(|(e, &b)| (e, b))
-        .collect::<Vec<_>>();
-    assert_eq!(ents, &[(f, true)]);
-}
-
-#[test]
-fn query_optional_component() {
-    let mut world = World::new();
-    let e = world.spawn(("abc", 123));
-    let f = world.spawn(("def", 456, true));
-    let ents = world
-        .query::<(Entity, Option<&bool>, &i32)>()
-        .map(|(e, b, &i)| (e, b.copied(), i))
-        .collect::<Vec<_>>();
-    assert_eq!(ents.len(), 2);
-    assert!(ents.contains(&(e, None, 123)));
-    assert!(ents.contains(&(f, Some(true), 456)));
-}
-
-#[test]
-fn build_entity() {
-    let mut world = World::new();
-    let mut entity = EntityBuilder::new();
-    entity.add("abc");
-    entity.add(123);
-    let e = world.spawn(entity.build());
-    entity.add("def");
-    entity.add([0u8; 1024]);
-    entity.add(456);
-    let f = world.spawn(entity.build());
-    assert_eq!(*world.get::<&str>(e).unwrap(), "abc");
-    assert_eq!(*world.get::<i32>(e).unwrap(), 123);
-    assert_eq!(*world.get::<&str>(f).unwrap(), "def");
-    assert_eq!(*world.get::<i32>(f).unwrap(), 456);
-}
-
-#[test]
-fn dynamic_components() {
-    let mut world = World::new();
-    let e = world.spawn((42,));
-    world.insert(e, (true, "abc")).unwrap();
-    assert_eq!(
-        world
-            .query::<(Entity, &i32, &bool)>()
-            .map(|(e, &i, &b)| (e, i, b))
-            .collect::<Vec<_>>(),
-        &[(e, 42, true)]
-    );
-    assert_eq!(world.remove_one::<i32>(e), Ok(42));
-    assert_eq!(
-        world
-            .query::<(Entity, &i32, &bool)>()
-            .map(|(e, &i, &b)| (e, i, b))
-            .collect::<Vec<_>>(),
-        &[]
-    );
-    assert_eq!(
-        world
-            .query::<(Entity, &bool, &&str)>()
-            .map(|(e, &b, &s)| (e, b, s))
-            .collect::<Vec<_>>(),
-        &[(e, true, "abc")]
-    );
-}
-
-#[test]
-fn shared_borrow() {
-    let mut world = World::new();
-    world.spawn(("abc", 123));
-    world.spawn(("def", 456));
-
-    world.query::<(&i32, &i32)>();
-}
-
-#[test]
-#[cfg(feature = "macros")]
-fn derived_bundle() {
-    #[derive(Bundle)]
-    struct Foo {
-        x: i32,
-        y: f64,
-    }
-
-    let mut world = World::new();
-    let e = world.spawn(Foo { x: 42, y: 1.0 });
-    assert_eq!(*world.get::<i32>(e).unwrap(), 42);
-    assert_eq!(*world.get::<f64>(e).unwrap(), 1.0);
-}
-
-#[test]
-#[cfg(feature = "macros")]
-#[cfg_attr(
-    debug_assertions,
-    should_panic(
-        expected = "attempted to allocate entity with duplicate i32 components; each type must occur at most once!"
-    )
-)]
-#[cfg_attr(
-    not(debug_assertions),
-    should_panic(
-        expected = "attempted to allocate entity with duplicate components; each type must occur at most once!"
-    )
-)]
-fn bad_bundle_derive() {
-    #[derive(Bundle)]
-    struct Foo {
-        x: i32,
-        y: i32,
-    }
-
-    let mut world = World::new();
-    world.spawn(Foo { x: 42, y: 42 });
-}
-
-#[test]
-#[cfg_attr(miri, ignore)]
-fn spawn_many() {
-    let mut world = World::new();
-    const N: usize = 100_000;
-    for _ in 0..N {
-        world.spawn((42u128,));
-    }
-    assert_eq!(world.iter().count(), N);
-}
-
-#[test]
-fn clear() {
-    let mut world = World::new();
-    world.spawn(("abc", 123));
-    world.spawn(("def", 456, true));
-    world.clear();
-    assert_eq!(world.iter().count(), 0);
-}
-
-#[test]
-fn remove_missing() {
-    let mut world = World::new();
-    let e = world.spawn(("abc", 123));
-    assert!(world.remove_one::<bool>(e).is_err());
-}
-
-#[test]
-fn query_batched() {
-    let mut world = World::new();
-    let a = world.spawn(());
-    let b = world.spawn(());
-    let c = world.spawn((42,));
-    assert_eq!(world.query_batched::<()>(1).count(), 3);
-    assert_eq!(world.query_batched::<()>(2).count(), 2);
-    assert_eq!(world.query_batched::<()>(2).flat_map(|x| x).count(), 3);
-    // different archetypes are always in different batches
-    assert_eq!(world.query_batched::<()>(3).count(), 2);
-    assert_eq!(world.query_batched::<()>(3).flat_map(|x| x).count(), 3);
-    assert_eq!(world.query_batched::<()>(4).count(), 2);
-    let entities = world
-        .query_batched::<Entity>(1)
-        .flat_map(|x| x)
-        .map(|e| e)
-        .collect::<Vec<_>>();
-    assert_eq!(entities.len(), 3);
-    assert!(entities.contains(&a));
-    assert!(entities.contains(&b));
-    assert!(entities.contains(&c));
-}
-
-#[test]
-fn spawn_batch() {
-    let mut world = World::new();
-    world.spawn_batch((0..100).map(|x| (x, "abc")));
-    let entities = world.query::<&i32>().map(|&x| x).collect::<Vec<_>>();
-    assert_eq!(entities.len(), 100);
-}
-
-#[test]
-fn query_one() {
-    let mut world = World::new();
-    let a = world.spawn(("abc", 123));
-    let b = world.spawn(("def", 456));
-    let c = world.spawn(("ghi", 789, true));
-    assert_eq!(world.query_one::<&i32>(a), Ok(&123));
-    assert_eq!(world.query_one::<&i32>(b), Ok(&456));
-    assert!(world.query_one::<(&i32, &bool)>(a).is_err());
-    assert_eq!(world.query_one::<(&i32, &bool)>(c), Ok((&789, &true)));
-    world.despawn(a).unwrap();
-    assert!(world.query_one::<&i32>(a).is_err());
-}
-
-#[test]
-fn remove_tracking() {
-    let mut world = World::new();
-    let a = world.spawn(("abc", 123));
-    let b = world.spawn(("abc", 123));
-
-    world.despawn(a).unwrap();
-    assert_eq!(
-        world.removed::<i32>(),
-        &[a],
-        "despawning results in 'removed component' state"
-    );
-    assert_eq!(
-        world.removed::<&'static str>(),
-        &[a],
-        "despawning results in 'removed component' state"
-    );
-
-    world.insert_one(b, 10.0).unwrap();
-    assert_eq!(
-        world.removed::<i32>(),
-        &[a],
-        "archetype moves does not result in 'removed component' state"
-    );
-
-    world.remove_one::<i32>(b).unwrap();
-    assert_eq!(
-        world.removed::<i32>(),
-        &[a, b],
-        "removing a component results in a 'removed component' state"
-    );
-
-    world.clear_trackers();
-    assert_eq!(
-        world.removed::<i32>(),
-        &[],
-        "clearning trackers clears removals"
-    );
-    assert_eq!(
-        world.removed::<&'static str>(),
-        &[],
-        "clearning trackers clears removals"
-    );
-    assert_eq!(
-        world.removed::<f64>(),
-        &[],
-        "clearning trackers clears removals"
-    );
-
-    let c = world.spawn(("abc", 123));
-    let d = world.spawn(("abc", 123));
-    world.clear();
-    assert_eq!(
-        world.removed::<i32>(),
-        &[c, d],
-        "world clears result in 'removed component' states"
-    );
-    assert_eq!(
-        world.removed::<&'static str>(),
-        &[c, d, b],
-        "world clears result in 'removed component' states"
-    );
-    assert_eq!(
-        world.removed::<f64>(),
-        &[b],
-        "world clears result in 'removed component' states"
-    );
-}
-
-#[test]
-fn added_tracking() {
-    let mut world = World::new();
-    let a = world.spawn((123,));
-
-    assert_eq!(world.query::<&i32>().count(), 1);
-    assert_eq!(world.query_filtered::<(), Added<i32>>().count(), 1);
-    assert_eq!(world.query_mut::<&i32>().count(), 1);
-    assert_eq!(world.query_filtered_mut::<(), Added<i32>>().count(), 1);
-    assert!(world.query_one::<&i32>(a).is_ok());
-    assert!(world.query_one_filtered::<(), Added<i32>>(a).is_ok());
-    assert!(world.query_one_mut::<&i32>(a).is_ok());
-    assert!(world.query_one_filtered_mut::<(), Added<i32>>(a).is_ok());
-
-    world.clear_trackers();
-
-    assert_eq!(world.query::<&i32>().count(), 1);
-    assert_eq!(world.query_filtered::<(), Added<i32>>().count(), 0);
-    assert_eq!(world.query_mut::<&i32>().count(), 1);
-    assert_eq!(world.query_filtered_mut::<(), Added<i32>>().count(), 0);
-    assert!(world.query_one_mut::<&i32>(a).is_ok());
-    assert!(world.query_one_filtered_mut::<(), Added<i32>>(a).is_err());
-}
-
-#[test]
-#[cfg_attr(
-    debug_assertions,
-    should_panic(
-        expected = "attempted to allocate entity with duplicate f32 components; each type must occur at most once!"
-    )
-)]
-#[cfg_attr(
-    not(debug_assertions),
-    should_panic(
-        expected = "attempted to allocate entity with duplicate components; each type must occur at most once!"
-    )
-)]
-fn duplicate_components_panic() {
-    let mut world = World::new();
-    world.reserve::<(f32, i64, f32)>(1);
-}
diff --git a/crates/bevy_ecs/src/world/entity_ref.rs b/crates/bevy_ecs/src/world/entity_ref.rs
new file mode 100644
index 0000000000000..9313d0d833fa9
--- /dev/null
+++ b/crates/bevy_ecs/src/world/entity_ref.rs
@@ -0,0 +1,900 @@
+use crate::{
+    archetype::{Archetype, ArchetypeId, Archetypes},
+    bundle::{Bundle, BundleInfo},
+    component::{Component, ComponentFlags, ComponentId, Components, StorageType},
+    entity::{Entity, EntityLocation},
+    storage::{SparseSet, Storages},
+    world::{Mut, World},
+};
+use std::any::TypeId;
+
+pub struct EntityRef<'w> {
+    world: &'w World,
+    entity: Entity,
+    location: EntityLocation,
+}
+
+impl<'w> EntityRef<'w> {
+    #[inline]
+    pub(crate) fn new(world: &'w World, entity: Entity, location: EntityLocation) -> Self {
+        Self {
+            world,
+            entity,
+            location,
+        }
+    }
+
+    #[inline]
+    pub fn id(&self) -> Entity {
+        self.entity
+    }
+
+    #[inline]
+    pub fn location(&self) -> EntityLocation {
+        self.location
+    }
+
+    #[inline]
+    pub fn archetype(&self) -> &Archetype {
+        // SAFE: EntityRefs always point to valid entities. Valid entities always have valid archetypes
+        unsafe {
+            self.world
+                .archetypes
+                .get_unchecked(self.location.archetype_id)
+        }
+    }
+
+    #[inline]
+    pub fn world(&mut self) -> &World {
+        self.world
+    }
+
+    #[inline]
+    pub fn contains<T: Component>(&self) -> bool {
+        self.contains_type_id(TypeId::of::<T>())
+    }
+
+    #[inline]
+    pub fn contains_id(&self, component_id: ComponentId) -> bool {
+        // SAFE: entity location is valid
+        unsafe { contains_component_with_id(self.world, component_id, self.location) }
+    }
+
+    #[inline]
+    pub fn contains_type_id(&self, type_id: TypeId) -> bool {
+        // SAFE: entity location is valid
+        unsafe { contains_component_with_type(self.world, type_id, self.location) }
+    }
+
+    #[inline]
+    pub fn get<T: Component>(&self) -> Option<&'w T> {
+        // SAFE: entity location is valid and returned component is of type T
+        unsafe {
+            get_component_with_type(self.world, TypeId::of::<T>(), self.entity, self.location)
+                .map(|value| &*value.cast::<T>())
+        }
+    }
+
+    /// # Safety
+    /// This allows aliased mutability. You must make sure this call does not result in multiple mutable references to the same component
+    #[inline]
+    pub unsafe fn get_unchecked_mut<T: Component>(&self) -> Option<Mut<'w, T>> {
+        get_component_and_flags_with_type(self.world, TypeId::of::<T>(), self.entity, self.location)
+            .map(|(value, flags)| Mut {
+                value: &mut *value.cast::<T>(),
+                flags: &mut *flags,
+            })
+    }
+}
+
+pub struct EntityMut<'w> {
+    world: &'w mut World,
+    entity: Entity,
+    location: EntityLocation,
+}
+
+impl<'w> EntityMut<'w> {
+    /// # Safety
+    /// entity and location _must_ be valid
+    #[inline]
+    pub(crate) unsafe fn new(
+        world: &'w mut World,
+        entity: Entity,
+        location: EntityLocation,
+    ) -> Self {
+        EntityMut {
+            world,
+            entity,
+            location,
+        }
+    }
+
+    #[inline]
+    pub fn id(&self) -> Entity {
+        self.entity
+    }
+
+    #[inline]
+    pub fn location(&self) -> EntityLocation {
+        self.location
+    }
+
+    #[inline]
+    pub fn archetype(&self) -> &Archetype {
+        // SAFE: EntityRefs always point to valid entities. Valid entities always have valid archetypes
+        unsafe {
+            self.world
+                .archetypes
+                .get_unchecked(self.location.archetype_id)
+        }
+    }
+
+    #[inline]
+    pub fn contains<T: Component>(&self) -> bool {
+        self.contains_type_id(TypeId::of::<T>())
+    }
+
+    #[inline]
+    pub fn contains_id(&self, component_id: ComponentId) -> bool {
+        // SAFE: entity location is valid
+        unsafe { contains_component_with_id(self.world, component_id, self.location) }
+    }
+
+    #[inline]
+    pub fn contains_type_id(&self, type_id: TypeId) -> bool {
+        // SAFE: entity location is valid
+        unsafe { contains_component_with_type(self.world, type_id, self.location) }
+    }
+
+    #[inline]
+    pub fn get<T: Component>(&self) -> Option<&'w T> {
+        // SAFE: entity location is valid and returned component is of type T
+        unsafe {
+            get_component_with_type(self.world, TypeId::of::<T>(), self.entity, self.location)
+                .map(|value| &*value.cast::<T>())
+        }
+    }
+
+    #[inline]
+    pub fn get_mut<T: Component>(&mut self) -> Option<Mut<'w, T>> {
+        // SAFE: world access is unique, entity location is valid, and returned component is of type T
+        unsafe {
+            get_component_and_flags_with_type(
+                self.world,
+                TypeId::of::<T>(),
+                self.entity,
+                self.location,
+            )
+            .map(|(value, flags)| Mut {
+                value: &mut *value.cast::<T>(),
+                flags: &mut *flags,
+            })
+        }
+    }
+
+    /// # Safety
+    /// This allows aliased mutability. You must make sure this call does not result in multiple mutable references to the same component
+    #[inline]
+    pub unsafe fn get_unchecked_mut<T: Component>(&self) -> Option<Mut<'w, T>> {
+        get_component_and_flags_with_type(self.world, TypeId::of::<T>(), self.entity, self.location)
+            .map(|(value, flags)| Mut {
+                value: &mut *value.cast::<T>(),
+                flags: &mut *flags,
+            })
+    }
+
+    // TODO: factor out non-generic part to cut down on monomorphization (just check perf)
+    // TODO: move relevant methods to World (add/remove bundle)
+    pub fn insert_bundle<T: Bundle>(&mut self, bundle: T) -> &mut Self {
+        let entity = self.entity;
+        let entities = &mut self.world.entities;
+        let archetypes = &mut self.world.archetypes;
+        let components = &mut self.world.components;
+        let storages = &mut self.world.storages;
+
+        let bundle_info = self.world.bundles.init_info::<T>(components);
+        let current_location = self.location;
+
+        let new_location = unsafe {
+            // SAFE: component ids in `bundle_info` and self.location are valid
+            let new_archetype_id = add_bundle_to_archetype(
+                archetypes,
+                storages,
+                components,
+                self.location.archetype_id,
+                bundle_info,
+            );
+            if new_archetype_id == current_location.archetype_id {
+                current_location
+            } else {
+                let old_table_row;
+                let old_table_id;
+                {
+                    let old_archetype = archetypes.get_unchecked_mut(current_location.archetype_id);
+                    let result = old_archetype.swap_remove(current_location.index);
+                    if let Some(swapped_entity) = result.swapped_entity {
+                        // SAFE: entity is live and is contained in an archetype that exists
+                        entities.meta[swapped_entity.id as usize].location = current_location;
+                    }
+                    old_table_row = result.table_row;
+                    old_table_id = old_archetype.table_id()
+                }
+                let new_archetype = archetypes.get_unchecked_mut(new_archetype_id);
+
+                if old_table_id == new_archetype.table_id() {
+                    new_archetype.allocate(entity, old_table_row)
+                } else {
+                    let (old_table, new_table) = storages
+                        .tables
+                        .get_2_mut(old_table_id, new_archetype.table_id());
+                    // PERF: store "non bundle" components in edge, then just move those to avoid redundant copies
+                    let move_result =
+                        old_table.move_to_superset_unchecked(old_table_row, new_table);
+
+                    let new_location = new_archetype.allocate(entity, move_result.new_row);
+                    // if an entity was moved into this entity's table spot, update its table row
+                    if let Some(swapped_entity) = move_result.swapped_entity {
+                        let swapped_location = entities.get(swapped_entity).unwrap();
+                        // SAFE: entity is live and is therefore contained in an archetype that exists
+                        archetypes
+                            .get_unchecked_mut(swapped_location.archetype_id)
+                            .set_entity_table_row(swapped_location.index, old_table_row);
+                    }
+                    new_location
+                }
+
+                // Sparse set components are intentionally ignored here. They don't need to move
+            }
+        };
+        self.location = new_location;
+        entities.meta[self.entity.id as usize].location = new_location;
+
+        // SAFE: archetype was created if it didn't already exist
+        let archetype = unsafe { archetypes.get_unchecked_mut(new_location.archetype_id) };
+        // SAFE: archetype tables always exists
+        let table = unsafe { storages.tables.get_unchecked_mut(archetype.table_id()) };
+        let table_row = archetype.entity_table_row(new_location.index);
+        let from_bundle = archetype.edges().get_from_bundle(bundle_info.id).unwrap();
+        // SAFE: table row is valid
+        unsafe {
+            bundle_info.write_components(
+                &mut storages.sparse_sets,
+                entity,
+                table,
+                table_row,
+                &from_bundle.bundle_flags,
+                bundle,
+            )
+        };
+        self
+    }
+
+    pub fn remove_bundle<T: Bundle>(&mut self) -> Option<T> {
+        let archetypes = &mut self.world.archetypes;
+        let storages = &mut self.world.storages;
+        let components = &mut self.world.components;
+        let entities = &mut self.world.entities;
+        let removed_components = &mut self.world.removed_components;
+
+        let bundle_info = self.world.bundles.init_info::<T>(components);
+        let old_location = self.location;
+        let new_archetype_id = unsafe {
+            remove_bundle_from_archetype(
+                archetypes,
+                storages,
+                components,
+                old_location.archetype_id,
+                bundle_info,
+                false,
+            )?
+        };
+
+        if new_archetype_id == old_location.archetype_id {
+            return None;
+        }
+
+        // SAFE: current entity archetype is valid
+        let old_archetype = unsafe { archetypes.get_unchecked_mut(old_location.archetype_id) };
+        let mut bundle_components = bundle_info.component_ids.iter().cloned();
+        let entity = self.entity;
+        // SAFE: bundle components are iterated in order, which guarantees that the component type matches
+        let result = unsafe {
+            T::from_components(|| {
+                let component_id = bundle_components.next().unwrap();
+                // SAFE: entity location is valid and table row is removed below
+                remove_component(
+                    components,
+                    storages,
+                    old_archetype,
+                    removed_components,
+                    component_id,
+                    entity,
+                    old_location,
+                )
+            })
+        };
+
+        let remove_result = old_archetype.swap_remove(old_location.index);
+        if let Some(swapped_entity) = remove_result.swapped_entity {
+            entities.meta[swapped_entity.id as usize].location = old_location;
+        }
+        let old_table_row = remove_result.table_row;
+        let old_table_id = old_archetype.table_id();
+        // SAFE: new archetype exists thanks to remove_bundle_from_archetype
+        let new_archetype = unsafe { archetypes.get_unchecked_mut(new_archetype_id) };
+
+        let new_location = if old_table_id == new_archetype.table_id() {
+            unsafe { new_archetype.allocate(entity, old_table_row) }
+        } else {
+            let (old_table, new_table) = storages
+                .tables
+                .get_2_mut(old_table_id, new_archetype.table_id());
+
+            // SAFE: table_row exists. All "missing" components have been extracted into the bundle above and the caller takes ownership
+            let move_result =
+                unsafe { old_table.move_to_and_forget_missing_unchecked(old_table_row, new_table) };
+
+            // SAFE: new_table_row is a valid position in new_archetype's table
+            let new_location = unsafe { new_archetype.allocate(entity, move_result.new_row) };
+
+            // if an entity was moved into this entity's table spot, update its table row
+            if let Some(swapped_entity) = move_result.swapped_entity {
+                let swapped_location = entities.get(swapped_entity).unwrap();
+                // SAFE: entity is live and is contained in an archetype that exists
+                let archetype =
+                    unsafe { archetypes.get_unchecked_mut(swapped_location.archetype_id) };
+                archetype.set_entity_table_row(swapped_location.index, old_table_row);
+            }
+
+            new_location
+        };
+
+        self.location = new_location;
+        entities.meta[self.entity.id as usize].location = new_location;
+
+        Some(result)
+    }
+
+    /// Remove any components in the bundle that the entity has.
+    pub fn remove_bundle_intersection<T: Bundle>(&mut self) {
+        let archetypes = &mut self.world.archetypes;
+        let storages = &mut self.world.storages;
+        let components = &mut self.world.components;
+        let entities = &mut self.world.entities;
+        let removed_components = &mut self.world.removed_components;
+
+        let bundle_info = self.world.bundles.init_info::<T>(components);
+        let old_location = self.location;
+        let new_archetype_id = unsafe {
+            remove_bundle_from_archetype(
+                archetypes,
+                storages,
+                components,
+                old_location.archetype_id,
+                bundle_info,
+                true,
+            )
+            .expect("intersections should always return a result")
+        };
+
+        if new_archetype_id == old_location.archetype_id {
+            return;
+        }
+
+        // SAFE: current entity archetype is valid
+        let old_archetype = unsafe { archetypes.get_unchecked_mut(old_location.archetype_id) };
+        let entity = self.entity;
+        for component_id in bundle_info.component_ids.iter().cloned() {
+            if old_archetype.contains(component_id) {
+                // SAFE: entity location is valid and table row is removed below
+                unsafe {
+                    remove_component(
+                        components,
+                        storages,
+                        old_archetype,
+                        removed_components,
+                        component_id,
+                        entity,
+                        old_location,
+                    );
+                }
+            }
+        }
+
+        let remove_result = old_archetype.swap_remove(old_location.index);
+        if let Some(swapped_entity) = remove_result.swapped_entity {
+            entities.meta[swapped_entity.id as usize].location = old_location;
+        }
+        let old_table_row = remove_result.table_row;
+        let old_table_id = old_archetype.table_id();
+        // SAFE: new archetype exists thanks to remove_bundle_from_archetype
+        let new_archetype = unsafe { archetypes.get_unchecked_mut(new_archetype_id) };
+
+        let new_location = if old_table_id == new_archetype.table_id() {
+            unsafe { new_archetype.allocate(entity, old_table_row) }
+        } else {
+            let (old_table, new_table) = storages
+                .tables
+                .get_2_mut(old_table_id, new_archetype.table_id());
+
+            // SAFE: table_row exists
+            let move_result =
+                unsafe { old_table.move_to_and_drop_missing_unchecked(old_table_row, new_table) };
+
+            // SAFE: new_table_row is a valid position in new_archetype's table
+            let new_location = unsafe { new_archetype.allocate(entity, move_result.new_row) };
+
+            // if an entity was moved into this entity's table spot, update its table row
+            if let Some(swapped_entity) = move_result.swapped_entity {
+                let swapped_location = entities.get(swapped_entity).unwrap();
+                // SAFE: entity is live and is contained in an archetype that exists
+                let archetype =
+                    unsafe { archetypes.get_unchecked_mut(swapped_location.archetype_id) };
+                archetype.set_entity_table_row(swapped_location.index, old_table_row);
+            }
+
+            new_location
+        };
+
+        self.location = new_location;
+        entities.meta[self.entity.id as usize].location = new_location;
+    }
+
+    pub fn insert<T: Component>(&mut self, value: T) -> &mut Self {
+        self.insert_bundle((value,))
+    }
+
+    pub fn remove<T: Component>(&mut self) -> Option<T> {
+        self.remove_bundle::<(T,)>().map(|v| v.0)
+    }
+
+    pub fn despawn(self) {
+        let world = self.world;
+        world.flush();
+        let location = world
+            .entities
+            .free(self.entity)
+            .expect("entity should exist at this point.");
+        let table_row;
+        let moved_entity;
+        {
+            // SAFE: entity is live and is contained in an archetype that exists
+            let archetype = unsafe { world.archetypes.get_unchecked_mut(location.archetype_id) };
+            for component_id in archetype.components() {
+                let removed_components = world
+                    .removed_components
+                    .get_or_insert_with(component_id, Vec::new);
+                removed_components.push(self.entity);
+            }
+            let remove_result = archetype.swap_remove(location.index);
+            if let Some(swapped_entity) = remove_result.swapped_entity {
+                world.entities.meta[swapped_entity.id as usize].location = location;
+            }
+            table_row = remove_result.table_row;
+
+            for component_id in archetype.sparse_set_components() {
+                let sparse_set = world.storages.sparse_sets.get_mut(*component_id).unwrap();
+                sparse_set.remove(self.entity);
+            }
+            // SAFE: tables and table rows stored in archetypes always exist
+            moved_entity = unsafe {
+                world
+                    .storages
+                    .tables
+                    .get_unchecked_mut(archetype.table_id())
+                    .swap_remove_unchecked(table_row)
+            };
+        };
+
+        if let Some(moved_entity) = moved_entity {
+            let moved_location = world.entities.get(moved_entity).unwrap();
+            // SAFE: entity is live and is contained in an archetype that exists
+            let archetype = unsafe {
+                world
+                    .archetypes
+                    .get_unchecked_mut(moved_location.archetype_id)
+            };
+            archetype.set_entity_table_row(moved_location.index, table_row);
+        }
+    }
+
+    #[inline]
+    pub fn world(&mut self) -> &World {
+        self.world
+    }
+
+    /// # Safety
+    /// Caller must not modify the world in a way that changes the current entity's location
+    /// If the caller _does_ do something that could change the location, self.update_location() must be
+    /// called before using any other methods in EntityMut
+    #[inline]
+    pub unsafe fn world_mut(&mut self) -> &mut World {
+        self.world
+    }
+
+    /// Updates the internal entity location to match the current location in the internal [World].
+    /// This is only needed if the user called [EntityMut::world], which enables the location to change.
+    pub fn update_location(&mut self) {
+        self.location = self.world.entities().get(self.entity).unwrap();
+    }
+}
+
+/// # Safety
+/// `entity_location` must be within bounds of the given archetype and `entity` must exist inside the archetype
+#[inline]
+unsafe fn get_component(
+    world: &World,
+    component_id: ComponentId,
+    entity: Entity,
+    location: EntityLocation,
+) -> Option<*mut u8> {
+    let archetype = world.archetypes.get_unchecked(location.archetype_id);
+    // SAFE: component_id exists and is therefore valid
+    let component_info = world.components.get_info_unchecked(component_id);
+    match component_info.storage_type() {
+        StorageType::Table => {
+            // SAFE: tables stored in archetype always exist
+            let table = world.storages.tables.get_unchecked(archetype.table_id());
+            let components = table.get_column(component_id)?;
+            let table_row = archetype.entity_table_row(location.index);
+            // SAFE: archetypes only store valid table_rows and the stored component type is T
+            Some(components.get_unchecked(table_row))
+        }
+        StorageType::SparseSet => world
+            .storages
+            .sparse_sets
+            .get(component_id)
+            .and_then(|sparse_set| sparse_set.get(entity)),
+    }
+}
+
+/// # Safety
+/// Caller must ensure that `component_id` is valid
+#[inline]
+unsafe fn get_component_and_flags(
+    world: &World,
+    component_id: ComponentId,
+    entity: Entity,
+    location: EntityLocation,
+) -> Option<(*mut u8, *mut ComponentFlags)> {
+    let archetype = world.archetypes.get_unchecked(location.archetype_id);
+    let component_info = world.components.get_info_unchecked(component_id);
+    match component_info.storage_type() {
+        StorageType::Table => {
+            // SAFE: tables stored in archetype always exist
+            let table = world.storages.tables.get_unchecked(archetype.table_id());
+            let components = table.get_column(component_id)?;
+            let table_row = archetype.entity_table_row(location.index);
+            // SAFE: archetypes only store valid table_rows and the stored component type is T
+            Some((
+                components.get_unchecked(table_row),
+                components.get_flags_unchecked(table_row),
+            ))
+        }
+        StorageType::SparseSet => world
+            .storages
+            .sparse_sets
+            .get(component_id)
+            .and_then(|sparse_set| sparse_set.get_with_flags(entity)),
+    }
+}
+
+/// # Safety
+// `entity_location` must be within bounds of the given archetype and `entity` must exist inside the archetype
+/// The relevant table row must be removed separately
+/// `component_id` must be valid
+#[inline]
+unsafe fn remove_component(
+    components: &Components,
+    storages: &mut Storages,
+    archetype: &Archetype,
+    removed_components: &mut SparseSet<ComponentId, Vec<Entity>>,
+    component_id: ComponentId,
+    entity: Entity,
+    location: EntityLocation,
+) -> *mut u8 {
+    let component_info = components.get_info_unchecked(component_id);
+    let removed_components = removed_components.get_or_insert_with(component_id, Vec::new);
+    removed_components.push(entity);
+    match component_info.storage_type() {
+        StorageType::Table => {
+            // SAFE: tables stored in archetype always exist
+            let table = storages.tables.get_unchecked(archetype.table_id());
+            // SAFE: archetypes will always point to valid columns
+            let components = table.get_column(component_id).unwrap();
+            let table_row = archetype.entity_table_row(location.index);
+            // SAFE: archetypes only store valid table_rows and the stored component type is T
+            components.get_unchecked(table_row)
+        }
+        StorageType::SparseSet => storages
+            .sparse_sets
+            .get_mut(component_id)
+            .unwrap()
+            .remove_and_forget(entity)
+            .unwrap(),
+    }
+}
+
+/// # Safety
+/// `entity_location` must be within bounds of an archetype that exists.
+unsafe fn get_component_with_type(
+    world: &World,
+    type_id: TypeId,
+    entity: Entity,
+    location: EntityLocation,
+) -> Option<*mut u8> {
+    let component_id = world.components.get_id(type_id)?;
+    get_component(world, component_id, entity, location)
+}
+
+/// # Safety
+/// `entity_location` must be within bounds of an archetype that exists.
+pub(crate) unsafe fn get_component_and_flags_with_type(
+    world: &World,
+    type_id: TypeId,
+    entity: Entity,
+    location: EntityLocation,
+) -> Option<(*mut u8, *mut ComponentFlags)> {
+    let component_id = world.components.get_id(type_id)?;
+    get_component_and_flags(world, component_id, entity, location)
+}
+
+/// # Safety
+/// `entity_location` must be within bounds of an archetype that exists.
+unsafe fn contains_component_with_type(
+    world: &World,
+    type_id: TypeId,
+    location: EntityLocation,
+) -> bool {
+    if let Some(component_id) = world.components.get_id(type_id) {
+        contains_component_with_id(world, component_id, location)
+    } else {
+        false
+    }
+}
+
+/// # Safety
+/// `entity_location` must be within bounds of an archetype that exists.
+unsafe fn contains_component_with_id(
+    world: &World,
+    component_id: ComponentId,
+    location: EntityLocation,
+) -> bool {
+    world
+        .archetypes
+        .get_unchecked(location.archetype_id)
+        .contains(component_id)
+}
+
+/// Adds a bundle to the given archetype and returns the resulting archetype. This could be the same [ArchetypeId],
+/// in the event that adding the given bundle does not result in an Archetype change. Results are cached in the
+/// Archetype Graph to avoid redundant work.
+/// # Safety
+/// `archetype_id` must exist and components in `bundle_info` must exist
+pub(crate) unsafe fn add_bundle_to_archetype(
+    archetypes: &mut Archetypes,
+    storages: &mut Storages,
+    components: &mut Components,
+    archetype_id: ArchetypeId,
+    bundle_info: &BundleInfo,
+) -> ArchetypeId {
+    if let Some(archetype_id) = archetypes
+        .get_unchecked(archetype_id)
+        .edges()
+        .get_add_bundle(bundle_info.id)
+    {
+        return archetype_id;
+    }
+    let mut new_table_components = Vec::new();
+    let mut new_sparse_set_components = Vec::new();
+    let mut tracking_flags = Vec::with_capacity(bundle_info.component_ids.len());
+
+    let current_archetype = archetypes.get_unchecked_mut(archetype_id);
+    for component_id in bundle_info.component_ids.iter().cloned() {
+        if current_archetype.contains(component_id) {
+            tracking_flags.push(ComponentFlags::MUTATED);
+        } else {
+            tracking_flags.push(ComponentFlags::ADDED);
+            let component_info = components.get_info_unchecked(component_id);
+            match component_info.storage_type() {
+                StorageType::Table => new_table_components.push(component_id),
+                StorageType::SparseSet => {
+                    storages.sparse_sets.get_or_insert(component_info);
+                    new_sparse_set_components.push(component_id)
+                }
+            }
+        }
+    }
+
+    if new_table_components.is_empty() && new_sparse_set_components.is_empty() {
+        let edges = current_archetype.edges_mut();
+        // the archetype does not change when we add this bundle
+        edges.set_add_bundle(bundle_info.id, archetype_id);
+        edges.set_from_bundle(bundle_info.id, archetype_id, tracking_flags);
+        archetype_id
+    } else {
+        let table_id;
+        let table_components;
+        let sparse_set_components;
+        // the archetype changes when we add this bundle. prepare the new archetype and storages
+        {
+            let current_archetype = archetypes.get_unchecked_mut(archetype_id);
+            table_components = if new_table_components.is_empty() {
+                // if there are no new table components, we can keep using this table
+                table_id = current_archetype.table_id();
+                current_archetype.table_components().to_vec()
+            } else {
+                new_table_components.extend(current_archetype.table_components());
+                // sort to ignore order while hashing
+                new_table_components.sort();
+                // SAFE: all component ids in `new_table_components` exist
+                table_id = storages
+                    .tables
+                    .get_id_or_insert(&new_table_components, components);
+
+                new_table_components
+            };
+
+            sparse_set_components = if new_sparse_set_components.is_empty() {
+                current_archetype.sparse_set_components().to_vec()
+            } else {
+                new_sparse_set_components.extend(current_archetype.sparse_set_components());
+                // sort to ignore order while hashing
+                new_sparse_set_components.sort();
+                new_sparse_set_components
+            };
+        };
+        let new_archetype_id =
+            archetypes.get_id_or_insert(table_id, table_components, sparse_set_components);
+        // add an edge from the old archetype to the new archetype
+        archetypes
+            .get_unchecked_mut(archetype_id)
+            .edges_mut()
+            .set_add_bundle(bundle_info.id, new_archetype_id);
+        // add a "from bundle" edge from the new archetype to the old archetype
+        archetypes
+            .get_unchecked_mut(new_archetype_id)
+            .edges_mut()
+            .set_from_bundle(bundle_info.id, new_archetype_id, tracking_flags);
+        new_archetype_id
+    }
+}
+
+/// Removes a bundle from the given archetype and returns the resulting archetype (or None if the removal was invalid).
+/// in the event that adding the given bundle does not result in an Archetype change. Results are cached in the
+/// Archetype Graph to avoid redundant work.
+/// if `intersection` is false, attempting to remove a bundle with components _not_ contained in the current archetype will fail,
+/// returning None. if `intersection` is true, components in the bundle but not in the current archetype will be ignored
+/// # Safety
+/// `archetype_id` must exist and components in `bundle_info` must exist
+unsafe fn remove_bundle_from_archetype(
+    archetypes: &mut Archetypes,
+    storages: &mut Storages,
+    components: &mut Components,
+    archetype_id: ArchetypeId,
+    bundle_info: &BundleInfo,
+    intersection: bool,
+) -> Option<ArchetypeId> {
+    // check the archetype graph to see if the Bundle has been removed from this archetype in the past
+    let remove_bundle_result = {
+        // SAFE: entity location is valid and therefore the archetype exists
+        let current_archetype = archetypes.get_unchecked_mut(archetype_id);
+        if intersection {
+            current_archetype
+                .edges()
+                .get_remove_bundle_intersection(bundle_info.id)
+        } else {
+            current_archetype.edges().get_remove_bundle(bundle_info.id)
+        }
+    };
+    let result = if let Some(result) = remove_bundle_result {
+        // this Bundle removal result is cached. just return that!
+        result
+    } else {
+        let mut next_table_components;
+        let mut next_sparse_set_components;
+        let next_table_id;
+        {
+            // SAFE: entity location is valid and therefore the archetype exists
+            let current_archetype = archetypes.get_unchecked_mut(archetype_id);
+            let mut removed_table_components = Vec::new();
+            let mut removed_sparse_set_components = Vec::new();
+            for component_id in bundle_info.component_ids.iter().cloned() {
+                if current_archetype.contains(component_id) {
+                    // SAFE: bundle components were already initialized by bundles.get_info
+                    let component_info = components.get_info_unchecked(component_id);
+                    match component_info.storage_type() {
+                        StorageType::Table => removed_table_components.push(component_id),
+                        StorageType::SparseSet => removed_sparse_set_components.push(component_id),
+                    }
+                } else if !intersection {
+                    // a component in the bundle was not present in the entity's archetype, so this removal is invalid
+                    // cache the result in the archetype graph
+                    current_archetype
+                        .edges_mut()
+                        .set_remove_bundle(bundle_info.id, None);
+                    return None;
+                }
+            }
+
+            // sort removed components so we can do an efficient "sorted remove". archetype components are already sorted
+            removed_table_components.sort();
+            removed_sparse_set_components.sort();
+            next_table_components = current_archetype.table_components().to_vec();
+            next_sparse_set_components = current_archetype.sparse_set_components().to_vec();
+            sorted_remove(&mut next_table_components, &removed_table_components);
+            sorted_remove(
+                &mut next_sparse_set_components,
+                &removed_sparse_set_components,
+            );
+
+            next_table_id = if removed_table_components.is_empty() {
+                current_archetype.table_id()
+            } else {
+                // SAFE: all components in next_table_components exist
+                storages
+                    .tables
+                    .get_id_or_insert(&next_table_components, components)
+            };
+        }
+
+        let new_archetype_id = archetypes.get_id_or_insert(
+            next_table_id,
+            next_table_components,
+            next_sparse_set_components,
+        );
+        Some(new_archetype_id)
+    };
+    // SAFE: entity location is valid and therefore the archetype exists
+    let current_archetype = archetypes.get_unchecked_mut(archetype_id);
+    // cache the result in an edge
+    if intersection {
+        current_archetype
+            .edges_mut()
+            .set_remove_bundle_intersection(bundle_info.id, result);
+    } else {
+        current_archetype
+            .edges_mut()
+            .set_remove_bundle(bundle_info.id, result);
+    }
+    result
+}
+
+fn sorted_remove<T: Eq + Ord + Copy>(source: &mut Vec<T>, remove: &[T]) {
+    let mut remove_index = 0;
+    source.retain(|value| {
+        while remove_index < remove.len() && *value > remove[remove_index] {
+            remove_index += 1;
+        }
+
+        if remove_index < remove.len() {
+            *value != remove[remove_index]
+        } else {
+            true
+        }
+    })
+}
+
+#[cfg(test)]
+mod tests {
+    #[test]
+    fn sorted_remove() {
+        let mut a = vec![1, 2, 3, 4, 5, 6, 7];
+        let b = vec![1, 2, 3, 5, 7];
+        super::sorted_remove(&mut a, &b);
+
+        assert_eq!(a, vec![4, 6]);
+
+        let mut a = vec![1];
+        let b = vec![1];
+        super::sorted_remove(&mut a, &b);
+
+        assert_eq!(a, vec![]);
+
+        let mut a = vec![1];
+        let b = vec![2];
+        super::sorted_remove(&mut a, &b);
+
+        assert_eq!(a, vec![1]);
+    }
+}
diff --git a/crates/bevy_ecs/src/world/mod.rs b/crates/bevy_ecs/src/world/mod.rs
new file mode 100644
index 0000000000000..2a932d83d3c23
--- /dev/null
+++ b/crates/bevy_ecs/src/world/mod.rs
@@ -0,0 +1,857 @@
+mod entity_ref;
+mod pointer;
+mod spawn_batch;
+mod world_cell;
+
+pub use entity_ref::*;
+pub use pointer::*;
+pub use spawn_batch::*;
+pub use world_cell::*;
+
+use crate::{
+    archetype::{ArchetypeComponentId, ArchetypeComponentInfo, ArchetypeId, Archetypes},
+    bundle::{Bundle, Bundles},
+    component::{
+        Component, ComponentDescriptor, ComponentFlags, ComponentId, Components, ComponentsError,
+        StorageType,
+    },
+    entity::{Entities, Entity},
+    query::{FilterFetch, QueryState, WorldQuery},
+    storage::{Column, SparseSet, Storages},
+};
+use std::{any::TypeId, fmt};
+
+#[derive(Copy, Clone, PartialEq, Eq, Debug)]
+pub struct WorldId(u64);
+
+impl Default for WorldId {
+    fn default() -> Self {
+        WorldId(rand::random())
+    }
+}
+
+/// [World] stores and exposes operations on [entities](Entity), [components](Component), and their associated metadata.
+/// Each [Entity] has a set of components. Each component can have up to one instance of each component type.
+/// Entity components can be created, updated, removed, and queried using a given [World].
+#[derive(Default)]
+pub struct World {
+    id: WorldId,
+    pub(crate) entities: Entities,
+    pub(crate) components: Components,
+    pub(crate) archetypes: Archetypes,
+    pub(crate) storages: Storages,
+    pub(crate) bundles: Bundles,
+    pub(crate) removed_components: SparseSet<ComponentId, Vec<Entity>>,
+    /// Access cache used by [WorldCell].
+    pub(crate) archetype_component_access: ArchetypeComponentAccess,
+    main_thread_validator: MainThreadValidator,
+}
+
+impl World {
+    /// Creates a new empty [World]
+    #[inline]
+    pub fn new() -> World {
+        World::default()
+    }
+
+    /// Retrieves this world's unique ID
+    #[inline]
+    pub fn id(&self) -> WorldId {
+        self.id
+    }
+
+    /// Retrieves this world's [Entities] collection
+    #[inline]
+    pub fn entities(&self) -> &Entities {
+        &self.entities
+    }
+
+    /// Retrieves this world's [Archetypes] collection
+    #[inline]
+    pub fn archetypes(&self) -> &Archetypes {
+        &self.archetypes
+    }
+
+    /// Retrieves this world's [Components] collection
+    #[inline]
+    pub fn components(&self) -> &Components {
+        &self.components
+    }
+
+    /// Retrieves a mutable reference to this world's [Components] collection
+    #[inline]
+    pub fn components_mut(&mut self) -> &mut Components {
+        &mut self.components
+    }
+
+    /// Retrieves this world's [Storages] collection
+    #[inline]
+    pub fn storages(&self) -> &Storages {
+        &self.storages
+    }
+
+    /// Retrieves this world's [Bundles] collection
+    #[inline]
+    pub fn bundles(&self) -> &Bundles {
+        &self.bundles
+    }
+
+    /// Retrieves a [WorldCell], which safely enables multiple mutable World accesses at the same time,
+    /// provided those accesses do not conflict with each other.
+    #[inline]
+    pub fn cell(&mut self) -> WorldCell<'_> {
+        WorldCell::new(self)
+    }
+
+    /// Registers a new component using the given [ComponentDescriptor]. Components do not need to be manually
+    /// registered. This just provides a way to override default configuration. Attempting to register a component
+    /// with a type that has already been used by [World] will result in an error.
+    ///
+    /// The default component storage type can be overridden like this:
+    ///
+    /// ```
+    /// use bevy_ecs::{component::{ComponentDescriptor, StorageType}, world::World};
+    ///
+    /// struct Position {
+    ///   x: f32,
+    ///   y: f32,
+    /// }
+    ///
+    /// let mut world = World::new();
+    /// world.register_component(ComponentDescriptor::new::<Position>(StorageType::SparseSet)).unwrap();
+    /// ```
+    pub fn register_component(
+        &mut self,
+        descriptor: ComponentDescriptor,
+    ) -> Result<ComponentId, ComponentsError> {
+        let storage_type = descriptor.storage_type();
+        let component_id = self.components.add(descriptor)?;
+        // ensure sparse set is created for SparseSet components
+        if storage_type == StorageType::SparseSet {
+            // SAFE: just created
+            let info = unsafe { self.components.get_info_unchecked(component_id) };
+            self.storages.sparse_sets.get_or_insert(info);
+        }
+
+        Ok(component_id)
+    }
+
+    /// Retrieves an [EntityRef] that exposes read-only operations for the given `entity`.
+    /// This will panic if the `entity` does not exist. Use [World::get_entity] if you want
+    /// to check for entity existence instead of implicitly panic-ing.
+    ///
+    /// ```
+    /// use bevy_ecs::world::World;
+    ///
+    /// struct Position {
+    ///   x: f32,
+    ///   y: f32,
+    /// }
+    ///
+    /// let mut world = World::new();
+    /// let entity = world.spawn()
+    ///     .insert(Position { x: 0.0, y: 0.0 })
+    ///     .id();
+    ///
+    /// let position = world.entity(entity).get::<Position>().unwrap();
+    /// assert_eq!(position.x, 0.0);
+    /// ```
+    #[inline]
+    pub fn entity(&self, entity: Entity) -> EntityRef {
+        self.get_entity(entity).expect("Entity does not exist")
+    }
+
+    /// Retrieves an [EntityMut] that exposes read and write operations for the given `entity`.
+    /// This will panic if the `entity` does not exist. Use [World::get_entity_mut] if you want
+    /// to check for entity existence instead of implicitly panic-ing.
+    ///
+    /// ```
+    /// use bevy_ecs::world::World;
+    ///
+    /// struct Position {
+    ///   x: f32,
+    ///   y: f32,
+    /// }
+    ///
+    /// let mut world = World::new();
+    /// let entity = world.spawn()
+    ///     .insert(Position { x: 0.0, y: 0.0 })
+    ///     .id();
+    ///
+    /// let mut position = world.entity_mut(entity).get_mut::<Position>().unwrap();
+    /// position.x = 1.0;
+    /// ```
+    #[inline]
+    pub fn entity_mut(&mut self, entity: Entity) -> EntityMut {
+        self.get_entity_mut(entity).expect("Entity does not exist")
+    }
+
+    /// Retrieves an [EntityRef] that exposes read-only operations for the given `entity`.
+    /// Returns [None] if the `entity` does not exist. Use [World::entity] if you don't want
+    /// to unwrap the [EntityRef] yourself.
+    ///
+    /// ```
+    /// use bevy_ecs::world::World;
+    ///
+    /// struct Position {
+    ///   x: f32,
+    ///   y: f32,
+    /// }
+    ///
+    /// let mut world = World::new();
+    /// let entity = world.spawn()
+    ///     .insert(Position { x: 0.0, y: 0.0 })
+    ///     .id();
+    ///
+    /// let entity_ref = world.get_entity(entity).unwrap();
+    /// let position = entity_ref.get::<Position>().unwrap();
+    /// assert_eq!(position.x, 0.0);
+    /// ```
+    #[inline]
+    pub fn get_entity(&self, entity: Entity) -> Option<EntityRef> {
+        let location = self.entities.get(entity)?;
+        Some(EntityRef::new(self, entity, location))
+    }
+
+    /// Retrieves an [EntityMut] that exposes read and write operations for the given `entity`.
+    /// Returns [None] if the `entity` does not exist. Use [World::entity_mut] if you don't want
+    /// to unwrap the [EntityMut] yourself.
+    ///
+    /// ```
+    /// use bevy_ecs::world::World;
+    ///
+    /// struct Position {
+    ///   x: f32,
+    ///   y: f32,
+    /// }
+    ///
+    /// let mut world = World::new();
+    /// let entity = world.spawn()
+    ///     .insert(Position { x: 0.0, y: 0.0 })
+    ///     .id();
+    ///
+    /// let mut entity_mut = world.get_entity_mut(entity).unwrap();
+    /// let mut position = entity_mut.get_mut::<Position>().unwrap();
+    /// position.x = 1.0;
+    /// ```
+    #[inline]
+    pub fn get_entity_mut(&mut self, entity: Entity) -> Option<EntityMut> {
+        let location = self.entities.get(entity)?;
+        // SAFE: `entity` exists and `location` is that entity's location
+        Some(unsafe { EntityMut::new(self, entity, location) })
+    }
+
+    /// Spawns a new [Entity] and returns a corresponding [EntityMut], which can be used
+    /// to add components to the entity or retrieve its id.
+    ///
+    /// ```
+    /// use bevy_ecs::world::World;
+    ///
+    /// struct Position {
+    ///   x: f32,
+    ///   y: f32,
+    /// }
+    ///
+    /// let mut world = World::new();
+    /// let entity = world.spawn()
+    ///     .insert(Position { x: 0.0, y: 0.0 }) // add a single component
+    ///     .insert_bundle((1, 2.0, "hello")) // add a bundle of components
+    ///     .id();
+    ///
+    /// let position = world.entity(entity).get::<Position>().unwrap();
+    /// assert_eq!(position.x, 0.0);
+    /// ```
+    pub fn spawn(&mut self) -> EntityMut {
+        self.flush();
+        let entity = self.entities.alloc();
+        let archetype = self.archetypes.empty_mut();
+        unsafe {
+            // PERF: consider avoiding allocating entities in the empty archetype unless needed
+            // SAFE: archetype tables always exist
+            let table = self.storages.tables.get_unchecked_mut(archetype.table_id());
+            // SAFE: no components are allocated by archetype.allocate() because the archetype is empty
+            let location = archetype.allocate(entity, table.allocate(entity));
+            // SAFE: entity index was just allocated
+            self.entities
+                .meta
+                .get_unchecked_mut(entity.id() as usize)
+                .location = location;
+            EntityMut::new(self, entity, location)
+        }
+    }
+
+    /// Spawns a batch of entities with the same component [Bundle] type. Takes a given [Bundle]
+    /// iterator and returns a corresponding [Entity] iterator.
+    /// This is more efficient than spawning entities and adding components to them individually,
+    /// but it is limited to spawning entities with the same [Bundle] type, whereas spawning
+    /// individually is more flexible.
+    ///
+    /// ```
+    /// use bevy_ecs::{entity::Entity, world::World};
+    ///
+    /// let mut world = World::new();
+    /// let entities = world.spawn_batch(vec![
+    ///   ("a", 0.0), // the first entity
+    ///   ("b", 1.0), // the second entity
+    /// ]).collect::<Vec<Entity>>();
+    ///
+    /// assert_eq!(entities.len(), 2);
+    /// ```
+    pub fn spawn_batch<I>(&mut self, iter: I) -> SpawnBatchIter<'_, I::IntoIter>
+    where
+        I: IntoIterator,
+        I::Item: Bundle,
+    {
+        SpawnBatchIter::new(self, iter.into_iter())
+    }
+
+    /// Retrieves a reference to the given `entity`'s [Component] of the given type.
+    /// Returns [None] if the `entity` does not have a [Component] of the given type.
+    /// ```
+    /// use bevy_ecs::world::World;
+    ///
+    /// struct Position {
+    ///   x: f32,
+    ///   y: f32,
+    /// }
+    ///
+    /// let mut world = World::new();
+    /// let entity = world.spawn()
+    ///     .insert(Position { x: 0.0, y: 0.0 })
+    ///     .id();
+    /// let position = world.get::<Position>(entity).unwrap();
+    /// assert_eq!(position.x, 0.0);
+    #[inline]
+    pub fn get<T: Component>(&self, entity: Entity) -> Option<&T> {
+        self.get_entity(entity)?.get()
+    }
+
+    /// Retrieves a mutable reference to the given `entity`'s [Component] of the given type.
+    /// Returns [None] if the `entity` does not have a [Component] of the given type.
+    /// ```
+    /// use bevy_ecs::world::World;
+    ///
+    /// struct Position {
+    ///   x: f32,
+    ///   y: f32,
+    /// }
+    ///
+    /// let mut world = World::new();
+    /// let entity = world.spawn()
+    ///     .insert(Position { x: 0.0, y: 0.0 })
+    ///     .id();
+    /// let mut position = world.get_mut::<Position>(entity).unwrap();
+    /// position.x = 1.0;
+    #[inline]
+    pub fn get_mut<T: Component>(&mut self, entity: Entity) -> Option<Mut<T>> {
+        self.get_entity_mut(entity)?.get_mut()
+    }
+
+    /// Despawns the given `entity`, if it exists. This will also remove all of the entity's [Component]s.
+    /// Returns `true` if the `entity` is successfully despawned and `false` if the `entity` does not exist.
+    /// ```
+    /// use bevy_ecs::world::World;
+    ///
+    /// struct Position {
+    ///   x: f32,
+    ///   y: f32,
+    /// }
+    ///
+    /// let mut world = World::new();
+    /// let entity = world.spawn()
+    ///     .insert(Position { x: 0.0, y: 0.0 })
+    ///     .id();
+    /// assert!(world.despawn(entity));
+    /// assert!(world.get_entity(entity).is_none());
+    /// assert!(world.get::<Position>(entity).is_none());
+    #[inline]
+    pub fn despawn(&mut self, entity: Entity) -> bool {
+        self.get_entity_mut(entity)
+            .map(|e| {
+                e.despawn();
+                true
+            })
+            .unwrap_or(false)
+    }
+
+    /// Clears all component tracker state, such as "added", "mutated", and "removed".
+    pub fn clear_trackers(&mut self) {
+        self.storages.tables.clear_flags();
+        self.storages.sparse_sets.clear_flags();
+        for entities in self.removed_components.values_mut() {
+            entities.clear();
+        }
+
+        let resource_archetype = self.archetypes.resource_mut();
+        for column in resource_archetype.unique_components.values_mut() {
+            column.clear_flags();
+        }
+    }
+
+    /// Returns [QueryState] for the given [WorldQuery], which is used to efficiently
+    /// run queries on the [World].
+    /// ```
+    ///
+    /// use bevy_ecs::{entity::Entity, world::World};
+    ///
+    /// #[derive(Debug, PartialEq)]
+    /// struct Position {
+    ///   x: f32,
+    ///   y: f32,
+    /// }
+    ///
+    /// struct Velocity {
+    ///   x: f32,
+    ///   y: f32,
+    /// }
+    ///
+    /// let mut world = World::new();
+    /// let entities = world.spawn_batch(vec![
+    ///     (Position { x: 0.0, y: 0.0}, Velocity { x: 1.0, y: 0.0 }),    
+    ///     (Position { x: 0.0, y: 0.0}, Velocity { x: 0.0, y: 1.0 }),    
+    /// ]).collect::<Vec<Entity>>();
+    ///
+    /// let mut query = world.query::<(&mut Position, &Velocity)>();
+    /// for (mut position, velocity) in query.iter_mut(&mut world) {
+    ///    position.x += velocity.x;
+    ///    position.y += velocity.y;
+    /// }     
+    ///
+    /// assert_eq!(world.get::<Position>(entities[0]).unwrap(), &Position { x: 1.0, y: 0.0 });
+    /// assert_eq!(world.get::<Position>(entities[1]).unwrap(), &Position { x: 0.0, y: 1.0 });
+    /// ```
+    #[inline]
+    pub fn query<Q: WorldQuery>(&mut self) -> QueryState<Q, ()> {
+        QueryState::new(self)
+    }
+
+    /// Returns [QueryState] for the given [WorldQuery] and filter, which is used to efficiently
+    /// run filtered queries on the [World].
+    /// ```
+    /// use bevy_ecs::{entity::Entity, world::World, query::With};
+    ///
+    /// struct A;
+    /// struct B;
+    ///
+    /// let mut world = World::new();
+    /// let e1 = world.spawn().insert(A).id();
+    /// let e2 = world.spawn().insert_bundle((A, B)).id();
+    ///
+    /// let mut query = world.query_filtered::<Entity, With<B>>();
+    /// let matching_entities = query.iter(&world).collect::<Vec<Entity>>();
+    ///
+    /// assert_eq!(matching_entities, vec![e2]);
+    /// ```
+    #[inline]
+    pub fn query_filtered<Q: WorldQuery, F: WorldQuery>(&mut self) -> QueryState<Q, F>
+    where
+        F::Fetch: FilterFetch,
+    {
+        QueryState::new(self)
+    }
+
+    /// Returns an iterator of entities that had components of type `T` removed since the last call to [World::clear_trackers].
+    pub fn removed<T: Component>(&self) -> std::iter::Cloned<std::slice::Iter<'_, Entity>> {
+        if let Some(component_id) = self.components.get_id(TypeId::of::<T>()) {
+            self.removed_with_id(component_id)
+        } else {
+            [].iter().cloned()
+        }
+    }
+
+    /// Returns an iterator of entities that had components with the given `component_id` removed since the last call to [World::clear_trackers].
+    pub fn removed_with_id(
+        &self,
+        component_id: ComponentId,
+    ) -> std::iter::Cloned<std::slice::Iter<'_, Entity>> {
+        if let Some(removed) = self.removed_components.get(component_id) {
+            removed.iter().cloned()
+        } else {
+            [].iter().cloned()
+        }
+    }
+
+    /// Inserts a new resource with the given `value`.
+    /// Resources are "unique" data of a given type.
+    #[inline]
+    pub fn insert_resource<T: Component>(&mut self, value: T) {
+        let component_id = self.components.get_or_insert_resource_id::<T>();
+        // SAFE: component_id just initialized and corresponds to resource of type T
+        unsafe { self.insert_resource_with_id(component_id, value) };
+    }
+
+    /// Inserts a new non-send resource with the given `value`.
+    /// Resources are "unique" data of a given type.
+    #[inline]
+    pub fn insert_non_send<T: 'static>(&mut self, value: T) {
+        self.validate_non_send_access::<T>();
+        let component_id = self.components.get_or_insert_non_send_resource_id::<T>();
+        // SAFE: component_id just initialized and corresponds to resource of type T
+        unsafe { self.insert_resource_with_id(component_id, value) };
+    }
+
+    /// Removes the resource of a given type and returns it, if it exists. Otherwise returns [None].
+    /// Resources are "unique" data of a given type.
+    #[inline]
+    pub fn remove_resource<T: Component>(&mut self) -> Option<T> {
+        let component_id = self.components.get_resource_id(TypeId::of::<T>())?;
+        let resource_archetype = self.archetypes.resource_mut();
+        let unique_components = resource_archetype.unique_components_mut();
+        let column = unique_components.get_mut(component_id)?;
+        if column.is_empty() {
+            return None;
+        }
+        // SAFE: if a resource column exists, row 0 exists as well. caller takes ownership of the ptr value / drop is called when
+        // T is dropped
+        let (ptr, _) = unsafe { column.swap_remove_and_forget_unchecked(0) };
+        // SAFE: column is of type T
+        Some(unsafe { ptr.cast::<T>().read() })
+    }
+
+    /// Returns `true` if a resource of type `T` exists. Otherwise returns `false`.
+    #[inline]
+    pub fn contains_resource<T: Component>(&self) -> bool {
+        let component_id =
+            if let Some(component_id) = self.components.get_resource_id(TypeId::of::<T>()) {
+                component_id
+            } else {
+                return false;
+            };
+        self.get_populated_resource_column(component_id).is_some()
+    }
+
+    /// Gets a reference to the resource of the given type, if it exists. Otherwise returns [None]
+    /// Resources are "unique" data of a given type.
+    #[inline]
+    pub fn get_resource<T: Component>(&self) -> Option<&T> {
+        let component_id = self.components.get_resource_id(TypeId::of::<T>())?;
+        unsafe { self.get_resource_with_id(component_id) }
+    }
+
+    /// Gets a mutable reference to the resource of the given type, if it exists. Otherwise returns [None]
+    /// Resources are "unique" data of a given type.
+    #[inline]
+    pub fn get_resource_mut<T: Component>(&mut self) -> Option<Mut<'_, T>> {
+        // SAFE: unique world access
+        unsafe { self.get_resource_unchecked_mut() }
+    }
+
+    // PERF: optimize this to avoid redundant lookups
+    /// Gets a resource of type `T` if it exists, otherwise inserts the resource using the result of calling `func`.
+    #[inline]
+    pub fn get_resource_or_insert_with<T: Component>(
+        &mut self,
+        func: impl FnOnce() -> T,
+    ) -> Mut<'_, T> {
+        if !self.contains_resource::<T>() {
+            self.insert_resource(func());
+        }
+        self.get_resource_mut().unwrap()
+    }
+
+    /// Gets a mutable reference to the resource of the given type, if it exists. Otherwise returns [None]
+    /// Resources are "unique" data of a given type.
+    /// # Safety
+    /// This will allow aliased mutable access to the given resource type. The caller must ensure that only
+    /// one mutable access exists at a time.
+    #[inline]
+    pub unsafe fn get_resource_unchecked_mut<T: Component>(&self) -> Option<Mut<'_, T>> {
+        let component_id = self.components.get_resource_id(TypeId::of::<T>())?;
+        self.get_resource_unchecked_mut_with_id(component_id)
+    }
+
+    /// Gets a reference to the non-send resource of the given type, if it exists. Otherwise returns [None]
+    /// Resources are "unique" data of a given type.
+    #[inline]
+    pub fn get_non_send_resource<T: 'static>(&self) -> Option<&T> {
+        let component_id = self.components.get_resource_id(TypeId::of::<T>())?;
+        // SAFE: component id matches type T
+        unsafe { self.get_non_send_with_id(component_id) }
+    }
+
+    /// Gets a mutable reference to the non-send resource of the given type, if it exists. Otherwise returns [None]
+    /// Resources are "unique" data of a given type.
+    #[inline]
+    pub fn get_non_send_resource_mut<T: 'static>(&mut self) -> Option<Mut<'_, T>> {
+        // SAFE: unique world access
+        unsafe { self.get_non_send_resource_unchecked_mut() }
+    }
+
+    /// Gets a mutable reference to the non-send resource of the given type, if it exists. Otherwise returns [None]
+    /// Resources are "unique" data of a given type.
+    /// # Safety
+    /// This will allow aliased mutable access to the given non-send resource type. The caller must ensure that only
+    /// one mutable access exists at a time.
+    #[inline]
+    pub unsafe fn get_non_send_resource_unchecked_mut<T: 'static>(&self) -> Option<Mut<'_, T>> {
+        let component_id = self.components.get_resource_id(TypeId::of::<T>())?;
+        self.get_non_send_unchecked_mut_with_id(component_id)
+    }
+
+    /// Temporarily removes the requested resource from this [World], then re-adds it before returning.
+    /// This enables safe mutable access to a resource while still providing mutable world access
+    /// ```
+    /// use bevy_ecs::world::{World, Mut};
+    /// struct A(u32);
+    /// struct B(u32);
+    /// let mut world = World::new();
+    /// world.insert_resource(A(1));
+    /// let entity = world.spawn().insert(B(1)).id();
+    ///
+    /// world.resource_scope(|mut a: Mut<A>, world| {
+    ///     let b = world.get_mut::<B>(entity).unwrap();
+    ///     a.0 += b.0;
+    /// });
+    /// assert_eq!(world.get_resource::<A>().unwrap().0, 2);
+    /// ```
+    pub fn resource_scope<T: Component, U>(
+        &mut self,
+        f: impl FnOnce(Mut<T>, &mut World) -> U,
+    ) -> U {
+        let component_id = self
+            .components
+            .get_resource_id(TypeId::of::<T>())
+            .expect("resource does not exist");
+        let (ptr, mut flags) = {
+            let resource_archetype = self.archetypes.resource_mut();
+            let unique_components = resource_archetype.unique_components_mut();
+            let column = unique_components
+                .get_mut(component_id)
+                .expect("resource does not exist");
+            if column.is_empty() {
+                panic!("resource does not exist");
+            }
+            // SAFE: if a resource column exists, row 0 exists as well. caller takes ownership of the ptr value / drop is called when
+            // T is dropped
+            unsafe { column.swap_remove_and_forget_unchecked(0) }
+        };
+        // SAFE: pointer is of type T
+        let value = Mut {
+            value: unsafe { &mut *ptr.cast::<T>() },
+            flags: &mut flags,
+        };
+        let result = f(value, self);
+        let resource_archetype = self.archetypes.resource_mut();
+        let unique_components = resource_archetype.unique_components_mut();
+        let column = unique_components
+            .get_mut(component_id)
+            .expect("resource does not exist");
+        // SAFE: new location is immediately written to below
+        let row = unsafe { column.push_uninit() };
+        // SAFE: row was just allocated above
+        unsafe { column.set_unchecked(row, ptr) };
+        // SAFE: row was just allocated above
+        unsafe { *column.get_flags_unchecked_mut(row) = flags };
+        result
+    }
+
+    /// # Safety
+    /// `component_id` must be assigned to a component of type T
+    #[inline]
+    pub(crate) unsafe fn get_resource_with_id<T: 'static>(
+        &self,
+        component_id: ComponentId,
+    ) -> Option<&T> {
+        let column = self.get_populated_resource_column(component_id)?;
+        Some(&*column.get_ptr().as_ptr().cast::<T>())
+    }
+
+    /// # Safety
+    /// `component_id` must be assigned to a component of type T.
+    /// Caller must ensure this doesn't violate Rust mutability rules for the given resource.
+    #[inline]
+    pub(crate) unsafe fn get_resource_unchecked_mut_with_id<T>(
+        &self,
+        component_id: ComponentId,
+    ) -> Option<Mut<'_, T>> {
+        let column = self.get_populated_resource_column(component_id)?;
+        Some(Mut {
+            value: &mut *column.get_ptr().as_ptr().cast::<T>(),
+            flags: &mut *column.get_flags_mut_ptr(),
+        })
+    }
+
+    /// # Safety
+    /// `component_id` must be assigned to a component of type T
+    #[inline]
+    pub(crate) unsafe fn get_non_send_with_id<T: 'static>(
+        &self,
+        component_id: ComponentId,
+    ) -> Option<&T> {
+        self.validate_non_send_access::<T>();
+        self.get_resource_with_id(component_id)
+    }
+
+    /// # Safety
+    /// `component_id` must be assigned to a component of type T.
+    /// Caller must ensure this doesn't violate Rust mutability rules for the given resource.
+    #[inline]
+    pub(crate) unsafe fn get_non_send_unchecked_mut_with_id<T: 'static>(
+        &self,
+        component_id: ComponentId,
+    ) -> Option<Mut<'_, T>> {
+        self.validate_non_send_access::<T>();
+        self.get_resource_unchecked_mut_with_id(component_id)
+    }
+
+    /// # Safety
+    /// `component_id` must be valid and correspond to a resource component of type T
+    #[inline]
+    unsafe fn insert_resource_with_id<T>(&mut self, component_id: ComponentId, mut value: T) {
+        let column = self.initialize_resource_internal(component_id);
+        if column.is_empty() {
+            // SAFE: column is of type T and has been allocated above
+            let data = (&mut value as *mut T).cast::<u8>();
+            // SAFE: new location is immediately written to below
+            let row = column.push_uninit();
+            // SAFE: index was just allocated above
+            column.set_unchecked(row, data);
+            std::mem::forget(value);
+            column
+                .get_flags_unchecked_mut(row)
+                .set(ComponentFlags::ADDED, true);
+        } else {
+            // SAFE: column is of type T and has already been allocated
+            *column.get_unchecked(0).cast::<T>() = value;
+            column
+                .get_flags_unchecked_mut(0)
+                .set(ComponentFlags::MUTATED, true);
+        }
+    }
+
+    /// # Safety
+    /// `component_id` must be valid and correspond to a resource component of type T
+    #[inline]
+    unsafe fn initialize_resource_internal(&mut self, component_id: ComponentId) -> &mut Column {
+        // SAFE: resource archetype always exists
+        let resource_archetype = self
+            .archetypes
+            .archetypes
+            .get_unchecked_mut(ArchetypeId::resource().index());
+        let resource_archetype_components = &mut resource_archetype.components;
+        let archetype_component_count = &mut self.archetypes.archetype_component_count;
+        let components = &self.components;
+        resource_archetype
+            .unique_components
+            .get_or_insert_with(component_id, || {
+                resource_archetype_components.insert(
+                    component_id,
+                    ArchetypeComponentInfo {
+                        archetype_component_id: ArchetypeComponentId::new(
+                            *archetype_component_count,
+                        ),
+                        storage_type: StorageType::Table,
+                    },
+                );
+                *archetype_component_count += 1;
+                let component_info = components.get_info_unchecked(component_id);
+                Column::with_capacity(component_info, 1)
+            })
+    }
+
+    pub(crate) fn initialize_resource<T: Component>(&mut self) -> ComponentId {
+        let component_id = self.components.get_or_insert_resource_id::<T>();
+        // SAFE: resource initialized above
+        unsafe { self.initialize_resource_internal(component_id) };
+        component_id
+    }
+
+    pub(crate) fn initialize_non_send_resource<T: 'static>(&mut self) -> ComponentId {
+        let component_id = self.components.get_or_insert_non_send_resource_id::<T>();
+        // SAFE: resource initialized above
+        unsafe { self.initialize_resource_internal(component_id) };
+        component_id
+    }
+
+    /// returns the resource column if the requested resource exists
+    pub(crate) fn get_populated_resource_column(
+        &self,
+        component_id: ComponentId,
+    ) -> Option<&Column> {
+        let resource_archetype = self.archetypes.resource();
+        let unique_components = resource_archetype.unique_components();
+        unique_components.get(component_id).and_then(|column| {
+            if column.is_empty() {
+                None
+            } else {
+                Some(column)
+            }
+        })
+    }
+
+    fn validate_non_send_access<T: 'static>(&self) {
+        if !self.main_thread_validator.is_main_thread() {
+            panic!(
+                "attempted to access NonSend resource {} off of the main thread",
+                std::any::type_name::<T>()
+            );
+        }
+    }
+
+    /// Empties queued entities and adds them to the empty [Archetype].
+    /// This should be called before doing operations that might operate on queued entities,
+    /// such as inserting a [Component].
+    pub(crate) fn flush(&mut self) {
+        let empty_archetype = self.archetypes.empty_mut();
+        unsafe {
+            // SAFE: archetype tables always exist
+            let table = self
+                .storages
+                .tables
+                .get_unchecked_mut(empty_archetype.table_id());
+            // PERF: consider pre-allocating space for flushed entities
+            self.entities.flush(|entity, location| {
+                // SAFE: no components are allocated by archetype.allocate() because the archetype is empty
+                *location = empty_archetype.allocate(entity, table.allocate(entity));
+            });
+        }
+    }
+}
+
+impl fmt::Debug for World {
+    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+        f.debug_struct("World")
+            .field("id", &self.id)
+            .field("entity_count", &self.entities.len())
+            .field("archetype_count", &self.archetypes.len())
+            .field("component_count", &self.components.len())
+            .field(
+                "resource_count",
+                &self.archetypes.resource().unique_components.len(),
+            )
+            .finish()
+    }
+}
+
+unsafe impl Send for World {}
+unsafe impl Sync for World {}
+
+/// Creates `Self` using data from the given [World]
+pub trait FromWorld {
+    /// Creates `Self` using data from the given [World]
+    fn from_world(world: &mut World) -> Self;
+}
+
+impl<T: Default> FromWorld for T {
+    fn from_world(_world: &mut World) -> Self {
+        T::default()
+    }
+}
+
+struct MainThreadValidator {
+    main_thread: std::thread::ThreadId,
+}
+
+impl MainThreadValidator {
+    fn is_main_thread(&self) -> bool {
+        self.main_thread == std::thread::current().id()
+    }
+}
+
+impl Default for MainThreadValidator {
+    fn default() -> Self {
+        Self {
+            main_thread: std::thread::current().id(),
+        }
+    }
+}
diff --git a/crates/bevy_ecs/src/world/pointer.rs b/crates/bevy_ecs/src/world/pointer.rs
new file mode 100644
index 0000000000000..c857f424a30e2
--- /dev/null
+++ b/crates/bevy_ecs/src/world/pointer.rs
@@ -0,0 +1,49 @@
+use crate::component::ComponentFlags;
+use std::ops::{Deref, DerefMut};
+
+/// Unique borrow of an entity's component
+pub struct Mut<'a, T> {
+    pub(crate) value: &'a mut T,
+    pub(crate) flags: &'a mut ComponentFlags,
+}
+
+impl<'a, T> Deref for Mut<'a, T> {
+    type Target = T;
+
+    #[inline]
+    fn deref(&self) -> &T {
+        self.value
+    }
+}
+
+impl<'a, T> DerefMut for Mut<'a, T> {
+    #[inline]
+    fn deref_mut(&mut self) -> &mut T {
+        self.flags.insert(ComponentFlags::MUTATED);
+        self.value
+    }
+}
+
+impl<'a, T: core::fmt::Debug> core::fmt::Debug for Mut<'a, T> {
+    fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
+        self.value.fmt(f)
+    }
+}
+
+impl<'w, T> Mut<'w, T> {
+    /// Returns true if (and only if) this component been added since the start of the frame.
+    pub fn added(&self) -> bool {
+        self.flags.contains(ComponentFlags::ADDED)
+    }
+
+    /// Returns true if (and only if) this component been mutated since the start of the frame.
+    pub fn mutated(&self) -> bool {
+        self.flags.contains(ComponentFlags::MUTATED)
+    }
+
+    /// Returns true if (and only if) this component been either mutated or added since the start of the frame.
+    pub fn changed(&self) -> bool {
+        self.flags
+            .intersects(ComponentFlags::ADDED | ComponentFlags::MUTATED)
+    }
+}
diff --git a/crates/bevy_ecs/src/world/spawn_batch.rs b/crates/bevy_ecs/src/world/spawn_batch.rs
new file mode 100644
index 0000000000000..6eeab491b43e4
--- /dev/null
+++ b/crates/bevy_ecs/src/world/spawn_batch.rs
@@ -0,0 +1,126 @@
+use crate::{
+    archetype::{Archetype, ArchetypeId},
+    bundle::{Bundle, BundleInfo},
+    entity::{Entities, Entity},
+    storage::{SparseSets, Table},
+    world::{add_bundle_to_archetype, World},
+};
+
+pub struct SpawnBatchIter<'w, I>
+where
+    I: Iterator,
+    I::Item: Bundle,
+{
+    inner: I,
+    entities: &'w mut Entities,
+    archetype: &'w mut Archetype,
+    table: &'w mut Table,
+    sparse_sets: &'w mut SparseSets,
+    bundle_info: &'w BundleInfo,
+}
+
+impl<'w, I> SpawnBatchIter<'w, I>
+where
+    I: Iterator,
+    I::Item: Bundle,
+{
+    #[inline]
+    pub(crate) fn new(world: &'w mut World, iter: I) -> Self {
+        // Ensure all entity allocations are accounted for so `self.entities` can realloc if
+        // necessary
+        world.flush();
+
+        let (lower, upper) = iter.size_hint();
+
+        let bundle_info = world.bundles.init_info::<I::Item>(&mut world.components);
+
+        let length = upper.unwrap_or(lower);
+        // SAFE: empty archetype exists and bundle components were initialized above
+        let archetype_id = unsafe {
+            add_bundle_to_archetype(
+                &mut world.archetypes,
+                &mut world.storages,
+                &mut world.components,
+                ArchetypeId::empty(),
+                bundle_info,
+            )
+        };
+        // SAFE: archetype exists
+        let archetype = unsafe { world.archetypes.get_unchecked_mut(archetype_id) };
+        // SAFE: table exists
+        let table = unsafe {
+            world
+                .storages
+                .tables
+                .get_unchecked_mut(archetype.table_id())
+        };
+        archetype.reserve(length);
+        table.reserve(length);
+        world.entities.reserve(length as u32);
+        Self {
+            inner: iter,
+            entities: &mut world.entities,
+            archetype,
+            table,
+            sparse_sets: &mut world.storages.sparse_sets,
+            bundle_info,
+        }
+    }
+}
+
+impl<I> Drop for SpawnBatchIter<'_, I>
+where
+    I: Iterator,
+    I::Item: Bundle,
+{
+    fn drop(&mut self) {
+        for _ in self {}
+    }
+}
+
+impl<I> Iterator for SpawnBatchIter<'_, I>
+where
+    I: Iterator,
+    I::Item: Bundle,
+{
+    type Item = Entity;
+
+    fn next(&mut self) -> Option<Entity> {
+        let bundle = self.inner.next()?;
+        let entity = self.entities.alloc();
+        // SAFE: component values are immediately written to relevant storages (which have been allocated)
+        unsafe {
+            let table_row = self.table.allocate(entity);
+            let location = self.archetype.allocate(entity, table_row);
+            let from_bundle = self
+                .archetype
+                .edges()
+                .get_from_bundle(self.bundle_info.id)
+                .unwrap();
+            self.bundle_info.write_components(
+                self.sparse_sets,
+                entity,
+                self.table,
+                table_row,
+                &from_bundle.bundle_flags,
+                bundle,
+            );
+            self.entities.meta[entity.id as usize].location = location;
+        }
+        Some(entity)
+    }
+
+    fn size_hint(&self) -> (usize, Option<usize>) {
+        self.inner.size_hint()
+    }
+}
+
+impl<I, T> ExactSizeIterator for SpawnBatchIter<'_, I>
+where
+    I: ExactSizeIterator<Item = T>,
+    T: Bundle,
+{
+    fn len(&self) -> usize {
+        self.inner.len()
+    }
+}
diff --git a/crates/bevy_ecs/src/world/world_cell.rs b/crates/bevy_ecs/src/world/world_cell.rs
new file mode 100644
index 0000000000000..762f7178c0a01
--- /dev/null
+++ b/crates/bevy_ecs/src/world/world_cell.rs
@@ -0,0 +1,353 @@
+use crate::{
+    archetype::ArchetypeComponentId,
+    component::Component,
+    storage::SparseSet,
+    world::{Mut, World},
+};
+use std::{
+    any::TypeId,
+    cell::RefCell,
+    ops::{Deref, DerefMut},
+    rc::Rc,
+};
+
+/// Exposes safe mutable access to multiple resources at a time in a World. Attempting to access World in a way that violates
+/// Rust's mutability rules will panic thanks to runtime checks.
+pub struct WorldCell<'w> {
+    pub(crate) world: &'w mut World,
+    pub(crate) access: Rc<RefCell<ArchetypeComponentAccess>>,
+}
+
+pub(crate) struct ArchetypeComponentAccess {
+    access: SparseSet<ArchetypeComponentId, usize>,
+}
+
+impl Default for ArchetypeComponentAccess {
+    fn default() -> Self {
+        Self {
+            access: SparseSet::new(),
+        }
+    }
+}
+
+const UNIQUE_ACCESS: usize = 0;
+const BASE_ACCESS: usize = 1;
+impl ArchetypeComponentAccess {
+    const fn new() -> Self {
+        Self {
+            access: SparseSet::new(),
+        }
+    }
+
+    fn read(&mut self, id: ArchetypeComponentId) -> bool {
+        let id_access = self.access.get_or_insert_with(id, || BASE_ACCESS);
+        if *id_access == UNIQUE_ACCESS {
+            false
+        } else {
+            *id_access += 1;
+            true
+        }
+    }
+
+    fn drop_read(&mut self, id: ArchetypeComponentId) {
+        let id_access = self.access.get_or_insert_with(id, || BASE_ACCESS);
+        *id_access -= 1;
+    }
+
+    fn write(&mut self, id: ArchetypeComponentId) -> bool {
+        let id_access = self.access.get_or_insert_with(id, || BASE_ACCESS);
+        if *id_access == BASE_ACCESS {
+            *id_access = UNIQUE_ACCESS;
+            true
+        } else {
+            false
+        }
+    }
+
+    fn drop_write(&mut self, id: ArchetypeComponentId) {
+        let id_access = self.access.get_or_insert_with(id, || BASE_ACCESS);
+        *id_access = BASE_ACCESS;
+    }
+}
+
+impl<'w> Drop for WorldCell<'w> {
+    fn drop(&mut self) {
+        let mut access = self.access.borrow_mut();
+        // give world ArchetypeComponentAccess back to reuse allocations
+        let _ = std::mem::swap(&mut self.world.archetype_component_access, &mut *access);
+    }
+}
+
+pub struct WorldBorrow<'w, T> {
+    value: &'w T,
+    archetype_component_id: ArchetypeComponentId,
+    access: Rc<RefCell<ArchetypeComponentAccess>>,
+}
+
+impl<'w, T> WorldBorrow<'w, T> {
+    fn new(
+        value: &'w T,
+        archetype_component_id: ArchetypeComponentId,
+        access: Rc<RefCell<ArchetypeComponentAccess>>,
+    ) -> Self {
+        if !access.borrow_mut().read(archetype_component_id) {
+            panic!(
+                "Attempted to immutably access {}, but it is already mutably borrowed",
+                std::any::type_name::<T>()
+            )
+        }
+        Self {
+            value,
+            archetype_component_id,
+            access,
+        }
+    }
+}
+
+impl<'w, T> Deref for WorldBorrow<'w, T> {
+    type Target = T;
+
+    #[inline]
+    fn deref(&self) -> &Self::Target {
+        self.value
+    }
+}
+
+impl<'w, T> Drop for WorldBorrow<'w, T> {
+    fn drop(&mut self) {
+        let mut access = self.access.borrow_mut();
+        access.drop_read(self.archetype_component_id);
+    }
+}
+
+pub struct WorldBorrowMut<'w, T> {
+    value: Mut<'w, T>,
+    archetype_component_id: ArchetypeComponentId,
+    access: Rc<RefCell<ArchetypeComponentAccess>>,
+}
+
+impl<'w, T> WorldBorrowMut<'w, T> {
+    fn new(
+        value: Mut<'w, T>,
+        archetype_component_id: ArchetypeComponentId,
+        access: Rc<RefCell<ArchetypeComponentAccess>>,
+    ) -> Self {
+        if !access.borrow_mut().write(archetype_component_id) {
+            panic!(
+                "Attempted to mutably access {}, but it is already mutably borrowed",
+                std::any::type_name::<T>()
+            )
+        }
+        Self {
+            value,
+            archetype_component_id,
+            access,
+        }
+    }
+}
+
+impl<'w, T> Deref for WorldBorrowMut<'w, T> {
+    type Target = T;
+
+    #[inline]
+    fn deref(&self) -> &Self::Target {
+        self.value.deref()
+    }
+}
+
+impl<'w, T> DerefMut for WorldBorrowMut<'w, T> {
+    fn deref_mut(&mut self) -> &mut Self::Target {
+        self.value.deref_mut()
+    }
+}
+
+impl<'w, T> Drop for WorldBorrowMut<'w, T> {
+    fn drop(&mut self) {
+        let mut access = self.access.borrow_mut();
+        access.drop_write(self.archetype_component_id);
+    }
+}
+
+impl<'w> WorldCell<'w> {
+    pub(crate) fn new(world: &'w mut World) -> Self {
+        // this is cheap because ArchetypeComponentAccess::new() is const / allocation free
+        let access = std::mem::replace(
+            &mut world.archetype_component_access,
+            ArchetypeComponentAccess::new(),
+        );
+        // world's ArchetypeComponentAccess is recycled to cut down on allocations
+        Self {
+            world,
+            access: Rc::new(RefCell::new(access)),
+        }
+    }
+
+    pub fn get_resource<T: Component>(&self) -> Option<WorldBorrow<'_, T>> {
+        let component_id = self.world.components.get_resource_id(TypeId::of::<T>())?;
+        let resource_archetype = self.world.archetypes.resource();
+        let archetype_component_id = resource_archetype.get_archetype_component_id(component_id)?;
+        Some(WorldBorrow::new(
+            // SAFE: ComponentId matches TypeId
+            unsafe { self.world.get_resource_with_id(component_id)? },
+            archetype_component_id,
+            self.access.clone(),
+        ))
+    }
+
+    pub fn get_resource_mut<T: Component>(&self) -> Option<WorldBorrowMut<'_, T>> {
+        let component_id = self.world.components.get_resource_id(TypeId::of::<T>())?;
+        let resource_archetype = self.world.archetypes.resource();
+        let archetype_component_id = resource_archetype.get_archetype_component_id(component_id)?;
+        Some(WorldBorrowMut::new(
+            // SAFE: ComponentId matches TypeId and access is checked by WorldBorrowMut
+            unsafe {
+                self.world
+                    .get_resource_unchecked_mut_with_id(component_id)?
+            },
+            archetype_component_id,
+            self.access.clone(),
+        ))
+    }
+
+    pub fn get_non_send<T: 'static>(&self) -> Option<WorldBorrow<'_, T>> {
+        let component_id = self.world.components.get_resource_id(TypeId::of::<T>())?;
+        let resource_archetype = self.world.archetypes.resource();
+        let archetype_component_id = resource_archetype.get_archetype_component_id(component_id)?;
+        Some(WorldBorrow::new(
+            // SAFE: ComponentId matches TypeId
+            unsafe { self.world.get_non_send_with_id(component_id)? },
+            archetype_component_id,
+            self.access.clone(),
+        ))
+    }
+
+    pub fn get_non_send_mut<T: 'static>(&self) -> Option<WorldBorrowMut<'_, T>> {
+        let component_id = self.world.components.get_resource_id(TypeId::of::<T>())?;
+        let resource_archetype = self.world.archetypes.resource();
+        let archetype_component_id = resource_archetype.get_archetype_component_id(component_id)?;
+        Some(WorldBorrowMut::new(
+            // SAFE: ComponentId matches TypeId and access is checked by WorldBorrowMut
+            unsafe {
+                self.world
+                    .get_non_send_unchecked_mut_with_id(component_id)?
+            },
+            archetype_component_id,
+            self.access.clone(),
+        ))
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use super::BASE_ACCESS;
+    use crate::{archetype::ArchetypeId, world::World};
+    use std::any::TypeId;
+
+    #[test]
+    fn world_cell() {
+        let mut world = World::default();
+        world.insert_resource(1u32);
+        world.insert_resource(1u64);
+        let cell = world.cell();
+        {
+            let mut a = cell.get_resource_mut::<u32>().unwrap();
+            assert_eq!(1, *a);
+            *a = 2;
+        }
+        {
+            let a = cell.get_resource::<u32>().unwrap();
+            assert_eq!(2, *a, "ensure access is dropped");
+
+            let b = cell.get_resource::<u32>().unwrap();
+            assert_eq!(
+                2, *b,
+                "ensure multiple immutable accesses can occur at the same time"
+            );
+        }
+        {
+            let a = cell.get_resource_mut::<u32>().unwrap();
+            assert_eq!(
+                2, *a,
+                "ensure both immutable accesses are dropped, enabling a new mutable access"
+            );
+
+            let b = cell.get_resource::<u64>().unwrap();
+            assert_eq!(
+                1, *b,
+                "ensure multiple non-conflicting mutable accesses can occur at the same time"
+            );
+        }
+    }
+
+    #[test]
+    fn world_access_reused() {
+        let mut world = World::default();
+        world.insert_resource(1u32);
+        {
+            let cell = world.cell();
+            {
+                let mut a = cell.get_resource_mut::<u32>().unwrap();
+                assert_eq!(1, *a);
+                *a = 2;
+            }
+        }
+
+        let u32_component_id = world
+            .components
+            .get_resource_id(TypeId::of::<u32>())
+            .unwrap();
+        let resource_archetype = world.archetypes.get(ArchetypeId::resource()).unwrap();
+        let u32_archetype_component_id = resource_archetype
+            .get_archetype_component_id(u32_component_id)
+            .unwrap();
+        assert_eq!(world.archetype_component_access.access.len(), 1);
+        assert_eq!(
+            world
+                .archetype_component_access
+                .access
+                .get(u32_archetype_component_id),
+            Some(&BASE_ACCESS),
+            "reused access count is 'base'"
+        );
+    }
+
+    #[test]
+    #[should_panic]
+    fn world_cell_double_mut() {
+        let mut world = World::default();
+        world.insert_resource(1u32);
+        let cell = world.cell();
+        let _value_a = cell.get_resource_mut::<u32>().unwrap();
+        let _value_b = cell.get_resource_mut::<u32>().unwrap();
+    }
+
+    #[test]
+    #[should_panic]
+    fn world_cell_ref_and_mut() {
+        let mut world = World::default();
+        world.insert_resource(1u32);
+        let cell = world.cell();
+        let _value_a = cell.get_resource::<u32>().unwrap();
+        let _value_b = cell.get_resource_mut::<u32>().unwrap();
+    }
+
+    #[test]
+    #[should_panic]
+    fn world_cell_mut_and_ref() {
+        let mut world = World::default();
+        world.insert_resource(1u32);
+        let cell = world.cell();
+        let _value_a = cell.get_resource_mut::<u32>().unwrap();
+        let _value_b = cell.get_resource::<u32>().unwrap();
+    }
+
+    #[test]
+    #[should_panic]
+    fn world_cell_ref_and_ref() {
+        let mut world = World::default();
+        world.insert_resource(1u32);
+        let cell = world.cell();
+        let _value_a = cell.get_resource_mut::<u32>().unwrap();
+        let _value_b = cell.get_resource::<u32>().unwrap();
+    }
+}
diff --git a/crates/bevy_gilrs/src/gilrs_system.rs b/crates/bevy_gilrs/src/gilrs_system.rs
index 4eae105cc2679..4f34370e91619 100644
--- a/crates/bevy_gilrs/src/gilrs_system.rs
+++ b/crates/bevy_gilrs/src/gilrs_system.rs
@@ -1,12 +1,13 @@
 use crate::converter::{convert_axis, convert_button, convert_gamepad_id};
 use bevy_app::Events;
-use bevy_ecs::{Resources, World};
+use bevy_ecs::world::World;
 use bevy_input::{gamepad::GamepadEventRaw, prelude::*};
 use gilrs::{EventType, Gilrs};
 
-pub fn gilrs_event_startup_system(_world: &mut World, resources: &mut Resources) {
-    let gilrs = resources.get_non_send::<Gilrs>().unwrap();
-    let mut event = resources.get_mut::<Events<GamepadEventRaw>>().unwrap();
+pub fn gilrs_event_startup_system(world: &mut World) {
+    let world = world.cell();
+    let gilrs = world.get_non_send::<Gilrs>().unwrap();
+    let mut event = world.get_resource_mut::<Events<GamepadEventRaw>>().unwrap();
     for (id, _) in gilrs.gamepads() {
         event.send(GamepadEventRaw(
             convert_gamepad_id(id),
@@ -15,9 +16,10 @@ pub fn gilrs_event_startup_system(_world: &mut World, resources: &mut Resources)
     }
 }
 
-pub fn gilrs_event_system(_world: &mut World, resources: &mut Resources) {
-    let mut gilrs = resources.get_non_send_mut::<Gilrs>().unwrap();
-    let mut event = resources.get_mut::<Events<GamepadEventRaw>>().unwrap();
+pub fn gilrs_event_system(world: &mut World) {
+    let world = world.cell();
+    let mut gilrs = world.get_non_send_mut::<Gilrs>().unwrap();
+    let mut event = world.get_resource_mut::<Events<GamepadEventRaw>>().unwrap();
     event.update();
     while let Some(gilrs_event) = gilrs.next_event() {
         match gilrs_event.event {
diff --git a/crates/bevy_gilrs/src/lib.rs b/crates/bevy_gilrs/src/lib.rs
index 5cf74c9d28516..483ead514e05b 100644
--- a/crates/bevy_gilrs/src/lib.rs
+++ b/crates/bevy_gilrs/src/lib.rs
@@ -1,8 +1,8 @@
 mod converter;
 mod gilrs_system;
 
-use bevy_app::prelude::*;
-use bevy_ecs::IntoExclusiveSystem;
+use bevy_app::{AppBuilder, CoreStage, Plugin, StartupStage};
+use bevy_ecs::system::IntoExclusiveSystem;
 use bevy_utils::tracing::error;
 use gilrs::GilrsBuilder;
 use gilrs_system::{gilrs_event_startup_system, gilrs_event_system};
diff --git a/crates/bevy_gltf/src/loader.rs b/crates/bevy_gltf/src/loader.rs
index 941b6512098ea..e48fd990787a9 100644
--- a/crates/bevy_gltf/src/loader.rs
+++ b/crates/bevy_gltf/src/loader.rs
@@ -1,7 +1,9 @@
 use anyhow::Result;
-use bevy_asset::{AssetIoError, AssetLoader, AssetPath, Handle, LoadContext, LoadedAsset};
+use bevy_asset::{
+    AssetIoError, AssetLoader, AssetPath, BoxedFuture, Handle, LoadContext, LoadedAsset,
+};
 use bevy_core::Name;
-use bevy_ecs::{bevy_utils::BoxedFuture, World, WorldBuilderSource};
+use bevy_ecs::world::World;
 use bevy_math::Mat4;
 use bevy_pbr::prelude::{PbrBundle, StandardMaterial};
 use bevy_render::{
@@ -207,9 +209,9 @@ async fn load_gltf<'a, 'b>(
     for scene in gltf.scenes() {
         let mut err = None;
         let mut world = World::default();
-        let world_builder = &mut world.build();
-        world_builder
-            .spawn((Transform::default(), GlobalTransform::default()))
+        world
+            .spawn()
+            .insert_bundle((Transform::default(), GlobalTransform::default()))
             .with_children(|parent| {
                 for node in scene.nodes() {
                     let result = load_node(&node, parent, load_context, &buffer_data);
diff --git a/crates/bevy_input/src/gamepad.rs b/crates/bevy_input/src/gamepad.rs
index 0f3ce315d3c62..23e2edd38bab0 100644
--- a/crates/bevy_input/src/gamepad.rs
+++ b/crates/bevy_input/src/gamepad.rs
@@ -1,6 +1,6 @@
 use crate::{Axis, Input};
 use bevy_app::{EventReader, Events};
-use bevy_ecs::{Res, ResMut};
+use bevy_ecs::system::{Res, ResMut};
 use bevy_utils::HashMap;
 
 #[derive(Debug, Copy, Clone, PartialEq, Eq, Hash)]
diff --git a/crates/bevy_input/src/keyboard.rs b/crates/bevy_input/src/keyboard.rs
index a113c19155313..7120699c8f578 100644
--- a/crates/bevy_input/src/keyboard.rs
+++ b/crates/bevy_input/src/keyboard.rs
@@ -1,6 +1,6 @@
 use crate::{ElementState, Input};
-use bevy_app::prelude::*;
-use bevy_ecs::ResMut;
+use bevy_app::EventReader;
+use bevy_ecs::system::ResMut;
 
 /// A key input event from a keyboard device
 #[derive(Debug, Clone)]
@@ -196,7 +196,7 @@ pub enum KeyCode {
     NumpadComma,
     NumpadEnter,
     NumpadEquals,
-    OEM102,
+    Oem102,
     Period,
     PlayPause,
     Power,
diff --git a/crates/bevy_input/src/lib.rs b/crates/bevy_input/src/lib.rs
index 9d5b5ec118a00..22a0a4e7d4dc7 100644
--- a/crates/bevy_input/src/lib.rs
+++ b/crates/bevy_input/src/lib.rs
@@ -7,7 +7,7 @@ pub mod system;
 pub mod touch;
 
 pub use axis::*;
-use bevy_ecs::IntoSystem;
+use bevy_ecs::system::IntoSystem;
 pub use input::*;
 
 pub mod prelude {
diff --git a/crates/bevy_input/src/mouse.rs b/crates/bevy_input/src/mouse.rs
index 0d99632c2fca5..01a5afaecdc87 100644
--- a/crates/bevy_input/src/mouse.rs
+++ b/crates/bevy_input/src/mouse.rs
@@ -1,6 +1,6 @@
 use crate::{ElementState, Input};
 use bevy_app::prelude::EventReader;
-use bevy_ecs::ResMut;
+use bevy_ecs::system::ResMut;
 use bevy_math::Vec2;
 
 /// A mouse button input event
diff --git a/crates/bevy_input/src/system.rs b/crates/bevy_input/src/system.rs
index d5197ef512c4d..644fc67176def 100644
--- a/crates/bevy_input/src/system.rs
+++ b/crates/bevy_input/src/system.rs
@@ -6,7 +6,7 @@ use bevy_app::{
     prelude::{EventReader, Events},
     AppExit,
 };
-use bevy_ecs::ResMut;
+use bevy_ecs::system::ResMut;
 
 /// Sends the AppExit event whenever the "esc" key is pressed.
 pub fn exit_on_esc_system(
diff --git a/crates/bevy_input/src/touch.rs b/crates/bevy_input/src/touch.rs
index b3b5b90f1838b..07ec595185d72 100644
--- a/crates/bevy_input/src/touch.rs
+++ b/crates/bevy_input/src/touch.rs
@@ -1,5 +1,5 @@
 use bevy_app::EventReader;
-use bevy_ecs::ResMut;
+use bevy_ecs::system::ResMut;
 use bevy_math::Vec2;
 use bevy_utils::HashMap;
 
diff --git a/crates/bevy_internal/src/default_plugins.rs b/crates/bevy_internal/src/default_plugins.rs
index e416c8b17ad7d..62921f669f804 100644
--- a/crates/bevy_internal/src/default_plugins.rs
+++ b/crates/bevy_internal/src/default_plugins.rs
@@ -5,7 +5,6 @@ pub struct DefaultPlugins;
 impl PluginGroup for DefaultPlugins {
     fn build(&mut self, group: &mut PluginGroupBuilder) {
         group.add(bevy_log::LogPlugin::default());
-        group.add(bevy_reflect::ReflectPlugin::default());
         group.add(bevy_core::CorePlugin::default());
         group.add(bevy_transform::TransformPlugin::default());
         group.add(bevy_diagnostic::DiagnosticsPlugin::default());
@@ -50,7 +49,6 @@ pub struct MinimalPlugins;
 
 impl PluginGroup for MinimalPlugins {
     fn build(&mut self, group: &mut PluginGroupBuilder) {
-        group.add(bevy_reflect::ReflectPlugin::default());
         group.add(bevy_core::CorePlugin::default());
         group.add(bevy_app::ScheduleRunnerPlugin::default());
     }
diff --git a/crates/bevy_log/src/lib.rs b/crates/bevy_log/src/lib.rs
index f7541ef378862..2460afb7aefef 100644
--- a/crates/bevy_log/src/lib.rs
+++ b/crates/bevy_log/src/lib.rs
@@ -42,7 +42,9 @@ impl Default for LogSettings {
 impl Plugin for LogPlugin {
     fn build(&self, app: &mut AppBuilder) {
         let default_filter = {
-            let settings = app.resources_mut().get_or_insert_with(LogSettings::default);
+            let settings = app
+                .world_mut()
+                .get_resource_or_insert_with(LogSettings::default);
             format!("{},{}", settings.level, settings.filter)
         };
 
@@ -71,7 +73,7 @@ impl Plugin for LogPlugin {
                         }
                     }))
                     .build();
-                app.resources_mut().insert_non_send(guard);
+                app.world_mut().insert_non_send(guard);
                 let subscriber = subscriber.with(chrome_layer);
                 bevy_utils::tracing::subscriber::set_global_default(subscriber)
                     .expect("Could not set global default tracing subscriber. If you've already set up a tracing subscriber, please disable LogPlugin from Bevy's DefaultPlugins");
diff --git a/crates/bevy_pbr/src/entity.rs b/crates/bevy_pbr/src/entity.rs
index 5cf11e89844e4..d03b0d89cf988 100644
--- a/crates/bevy_pbr/src/entity.rs
+++ b/crates/bevy_pbr/src/entity.rs
@@ -1,6 +1,6 @@
 use crate::{light::Light, material::StandardMaterial, render_graph::FORWARD_PIPELINE_HANDLE};
 use bevy_asset::Handle;
-use bevy_ecs::Bundle;
+use bevy_ecs::bundle::Bundle;
 use bevy_render::{
     draw::Draw,
     mesh::Mesh,
diff --git a/crates/bevy_pbr/src/lib.rs b/crates/bevy_pbr/src/lib.rs
index 060761b71c102..73790b395f751 100644
--- a/crates/bevy_pbr/src/lib.rs
+++ b/crates/bevy_pbr/src/lib.rs
@@ -4,7 +4,6 @@ mod entity;
 mod light;
 mod material;
 
-use bevy_ecs::IntoSystem;
 pub use entity::*;
 pub use light::*;
 pub use material::*;
@@ -15,8 +14,8 @@ pub mod prelude {
 
 use bevy_app::prelude::*;
 use bevy_asset::{AddAsset, Assets, Handle};
-use bevy_reflect::RegisterTypeBuilder;
-use bevy_render::{prelude::Color, render_graph::RenderGraph, shader};
+use bevy_ecs::system::IntoSystem;
+use bevy_render::{prelude::Color, shader};
 use material::StandardMaterial;
 use render_graph::add_pbr_graph;
 
@@ -33,14 +32,12 @@ impl Plugin for PbrPlugin {
                 shader::asset_shader_defs_system::<StandardMaterial>.system(),
             )
             .init_resource::<AmbientLight>();
-        let resources = app.resources();
-        let mut render_graph = resources.get_mut::<RenderGraph>().unwrap();
-        add_pbr_graph(&mut render_graph, resources);
+        add_pbr_graph(app.world_mut());
 
         // add default StandardMaterial
         let mut materials = app
-            .resources()
-            .get_mut::<Assets<StandardMaterial>>()
+            .world_mut()
+            .get_resource_mut::<Assets<StandardMaterial>>()
             .unwrap();
         materials.set_untracked(
             Handle::<StandardMaterial>::default(),
diff --git a/crates/bevy_pbr/src/light.rs b/crates/bevy_pbr/src/light.rs
index c0a0bb65dd31f..4a674a45ab100 100644
--- a/crates/bevy_pbr/src/light.rs
+++ b/crates/bevy_pbr/src/light.rs
@@ -1,5 +1,6 @@
 use bevy_core::Byteable;
-use bevy_reflect::{Reflect, ReflectComponent};
+use bevy_ecs::reflect::ReflectComponent;
+use bevy_reflect::Reflect;
 use bevy_render::{
     camera::{CameraProjection, PerspectiveProjection},
     color::Color,
diff --git a/crates/bevy_pbr/src/render_graph/lights_node.rs b/crates/bevy_pbr/src/render_graph/lights_node.rs
index 94ad213f4fbfc..776ef83524abb 100644
--- a/crates/bevy_pbr/src/render_graph/lights_node.rs
+++ b/crates/bevy_pbr/src/render_graph/lights_node.rs
@@ -4,7 +4,8 @@ use crate::{
 };
 use bevy_core::{AsBytes, Byteable};
 use bevy_ecs::{
-    BoxedSystem, Commands, IntoSystem, Local, Query, Res, ResMut, Resources, System, World,
+    system::{BoxedSystem, IntoSystem, Local, Query, Res, ResMut},
+    world::World,
 };
 use bevy_render::{
     render_graph::{CommandQueue, Node, ResourceSlots, SystemNode},
@@ -35,7 +36,6 @@ impl Node for LightsNode {
     fn update(
         &mut self,
         _world: &World,
-        _resources: &Resources,
         render_context: &mut dyn RenderContext,
         _input: &ResourceSlots,
         _output: &mut ResourceSlots,
@@ -53,17 +53,15 @@ struct LightCount {
 unsafe impl Byteable for LightCount {}
 
 impl SystemNode for LightsNode {
-    fn get_system(&self, commands: &mut Commands) -> BoxedSystem {
-        let system = lights_node_system.system();
-        commands.insert_local_resource(
-            system.id(),
-            LightsNodeSystemState {
+    fn get_system(&self) -> BoxedSystem {
+        let system = lights_node_system.system().config(|config| {
+            config.0 = Some(LightsNodeSystemState {
                 command_queue: self.command_queue.clone(),
                 max_lights: self.max_lights,
                 light_buffer: None,
                 staging_buffer: None,
-            },
-        );
+            })
+        });
         Box::new(system)
     }
 }
diff --git a/crates/bevy_pbr/src/render_graph/mod.rs b/crates/bevy_pbr/src/render_graph/mod.rs
index 8fb942427bcbf..5eccb6799fc2e 100644
--- a/crates/bevy_pbr/src/render_graph/mod.rs
+++ b/crates/bevy_pbr/src/render_graph/mod.rs
@@ -1,6 +1,7 @@
 mod forward_pipeline;
 mod lights_node;
 
+use bevy_ecs::world::World;
 pub use forward_pipeline::*;
 pub use lights_node::*;
 
@@ -18,7 +19,6 @@ pub mod uniform {
 
 use crate::prelude::StandardMaterial;
 use bevy_asset::Assets;
-use bevy_ecs::Resources;
 use bevy_render::{
     pipeline::PipelineDescriptor,
     render_graph::{base, AssetRenderResourcesNode, RenderGraph, RenderResourcesNode},
@@ -26,31 +26,34 @@ use bevy_render::{
 };
 use bevy_transform::prelude::GlobalTransform;
 
-pub(crate) fn add_pbr_graph(graph: &mut RenderGraph, resources: &Resources) {
-    graph.add_system_node(
-        node::TRANSFORM,
-        RenderResourcesNode::<GlobalTransform>::new(true),
-    );
-    graph.add_system_node(
-        node::STANDARD_MATERIAL,
-        AssetRenderResourcesNode::<StandardMaterial>::new(true),
-    );
-    graph.add_system_node(node::LIGHTS, LightsNode::new(10));
-    let mut shaders = resources.get_mut::<Assets<Shader>>().unwrap();
-    let mut pipelines = resources.get_mut::<Assets<PipelineDescriptor>>().unwrap();
-    pipelines.set_untracked(
-        FORWARD_PIPELINE_HANDLE,
-        build_forward_pipeline(&mut shaders),
-    );
+pub(crate) fn add_pbr_graph(world: &mut World) {
+    {
+        let mut graph = world.get_resource_mut::<RenderGraph>().unwrap();
+        graph.add_system_node(
+            node::TRANSFORM,
+            RenderResourcesNode::<GlobalTransform>::new(true),
+        );
+        graph.add_system_node(
+            node::STANDARD_MATERIAL,
+            AssetRenderResourcesNode::<StandardMaterial>::new(true),
+        );
+        graph.add_system_node(node::LIGHTS, LightsNode::new(10));
 
-    // TODO: replace these with "autowire" groups
-    graph
-        .add_node_edge(node::STANDARD_MATERIAL, base::node::MAIN_PASS)
-        .unwrap();
-    graph
-        .add_node_edge(node::TRANSFORM, base::node::MAIN_PASS)
-        .unwrap();
-    graph
-        .add_node_edge(node::LIGHTS, base::node::MAIN_PASS)
+        // TODO: replace these with "autowire" groups
+        graph
+            .add_node_edge(node::STANDARD_MATERIAL, base::node::MAIN_PASS)
+            .unwrap();
+        graph
+            .add_node_edge(node::TRANSFORM, base::node::MAIN_PASS)
+            .unwrap();
+        graph
+            .add_node_edge(node::LIGHTS, base::node::MAIN_PASS)
+            .unwrap();
+    }
+    let forward_pipeline =
+        build_forward_pipeline(&mut world.get_resource_mut::<Assets<Shader>>().unwrap());
+    let mut pipelines = world
+        .get_resource_mut::<Assets<PipelineDescriptor>>()
         .unwrap();
+    pipelines.set_untracked(FORWARD_PIPELINE_HANDLE, forward_pipeline);
 }
diff --git a/crates/bevy_reflect/Cargo.toml b/crates/bevy_reflect/Cargo.toml
index a4f7c9c364f59..d48e78918e70e 100644
--- a/crates/bevy_reflect/Cargo.toml
+++ b/crates/bevy_reflect/Cargo.toml
@@ -14,14 +14,12 @@ keywords = ["bevy"]
 readme = "README.md"
 
 [features]
-bevy = ["bevy_ecs", "bevy_app", "glam", "smallvec"]
+bevy = ["glam", "smallvec"]
 
 [dependencies]
 # bevy
 bevy_reflect_derive = { path = "bevy_reflect_derive", version = "0.4.0" }
 bevy_utils = { path = "../bevy_utils", version = "0.4.0" }
-bevy_ecs = { path = "../bevy_ecs", version = "0.4.0", optional = true }
-bevy_app = { path = "../bevy_app", version = "0.4.0", optional = true }
 
 # other
 erased-serde = "0.3"
diff --git a/crates/bevy_reflect/src/impls/bevy_app.rs b/crates/bevy_reflect/src/impls/bevy_app.rs
deleted file mode 100644
index f73a6f031f057..0000000000000
--- a/crates/bevy_reflect/src/impls/bevy_app.rs
+++ /dev/null
@@ -1,63 +0,0 @@
-use crate::{impl_reflect_value, GetTypeRegistration, ReflectDeserialize, TypeRegistryArc};
-use bevy_app::{AppBuilder, Plugin};
-use bevy_ecs::Entity;
-
-#[derive(Default)]
-pub struct ReflectPlugin;
-
-impl Plugin for ReflectPlugin {
-    fn build(&self, app: &mut AppBuilder) {
-        app.init_resource::<TypeRegistryArc>()
-            .register_type::<bool>()
-            .register_type::<u8>()
-            .register_type::<u16>()
-            .register_type::<u32>()
-            .register_type::<u64>()
-            .register_type::<u128>()
-            .register_type::<usize>()
-            .register_type::<i8>()
-            .register_type::<i16>()
-            .register_type::<i32>()
-            .register_type::<i64>()
-            .register_type::<i128>()
-            .register_type::<isize>()
-            .register_type::<f32>()
-            .register_type::<f64>()
-            .register_type::<String>();
-        #[cfg(feature = "glam")]
-        {
-            app.register_type::<glam::IVec2>()
-                .register_type::<glam::IVec3>()
-                .register_type::<glam::IVec4>()
-                .register_type::<glam::UVec2>()
-                .register_type::<glam::UVec3>()
-                .register_type::<glam::UVec4>()
-                .register_type::<glam::Vec2>()
-                .register_type::<glam::Vec3>()
-                .register_type::<glam::Vec4>()
-                .register_type::<glam::Mat3>()
-                .register_type::<glam::Mat4>()
-                .register_type::<glam::Quat>();
-        }
-        #[cfg(feature = "bevy_ecs")]
-        {
-            app.register_type::<bevy_ecs::Entity>();
-        }
-    }
-}
-
-impl_reflect_value!(Entity(Hash, PartialEq, Serialize, Deserialize));
-
-pub trait RegisterTypeBuilder {
-    fn register_type<T: GetTypeRegistration>(&mut self) -> &mut Self;
-}
-
-impl RegisterTypeBuilder for AppBuilder {
-    fn register_type<T: GetTypeRegistration>(&mut self) -> &mut Self {
-        {
-            let registry = self.resources().get_mut::<TypeRegistryArc>().unwrap();
-            registry.write().register::<T>();
-        }
-        self
-    }
-}
diff --git a/crates/bevy_reflect/src/impls/bevy_ecs.rs b/crates/bevy_reflect/src/impls/bevy_ecs.rs
deleted file mode 100644
index 0a05ffbc491e2..0000000000000
--- a/crates/bevy_reflect/src/impls/bevy_ecs.rs
+++ /dev/null
@@ -1,245 +0,0 @@
-use crate::{FromType, Reflect};
-use bevy_ecs::{
-    Archetype, Component, Entity, EntityMap, FromResources, MapEntities, MapEntitiesError,
-    Resources, World,
-};
-use std::marker::PhantomData;
-
-#[derive(Clone)]
-pub struct ReflectComponent {
-    add_component: fn(&mut World, resources: &Resources, Entity, &dyn Reflect),
-    apply_component: fn(&mut World, Entity, &dyn Reflect),
-    reflect_component: unsafe fn(&Archetype, usize) -> &dyn Reflect,
-    reflect_component_mut: unsafe fn(&Archetype, usize) -> &mut dyn Reflect,
-    copy_component: fn(&World, &mut World, &Resources, Entity, Entity),
-}
-
-impl ReflectComponent {
-    pub fn add_component(
-        &self,
-        world: &mut World,
-        resources: &Resources,
-        entity: Entity,
-        component: &dyn Reflect,
-    ) {
-        (self.add_component)(world, resources, entity, component);
-    }
-
-    pub fn apply_component(&self, world: &mut World, entity: Entity, component: &dyn Reflect) {
-        (self.apply_component)(world, entity, component);
-    }
-
-    /// # Safety
-    /// This does not do bound checks on entity_index. You must make sure entity_index is within bounds before calling.
-    pub unsafe fn reflect_component<'a>(
-        &self,
-        archetype: &'a Archetype,
-        entity_index: usize,
-    ) -> &'a dyn Reflect {
-        (self.reflect_component)(archetype, entity_index)
-    }
-
-    /// # Safety
-    /// This does not do bound checks on entity_index. You must make sure entity_index is within bounds before calling.
-    /// This method does not prevent you from having two mutable pointers to the same data, violating Rust's aliasing rules. To avoid this:
-    /// * Only call this method in a thread-local system to avoid sharing across threads.
-    /// * Don't call this method more than once in the same scope for a given component.
-    #[allow(clippy::mut_from_ref)]
-    pub unsafe fn reflect_component_mut<'a>(
-        &self,
-        archetype: &'a Archetype,
-        entity_index: usize,
-    ) -> &'a mut dyn Reflect {
-        (self.reflect_component_mut)(archetype, entity_index)
-    }
-
-    pub fn copy_component(
-        &self,
-        source_world: &World,
-        destination_world: &mut World,
-        resources: &Resources,
-        source_entity: Entity,
-        destination_entity: Entity,
-    ) {
-        (self.copy_component)(
-            source_world,
-            destination_world,
-            resources,
-            source_entity,
-            destination_entity,
-        );
-    }
-}
-
-impl<C: Component + Reflect + FromResources> FromType<C> for ReflectComponent {
-    fn from_type() -> Self {
-        ReflectComponent {
-            add_component: |world, resources, entity, reflected_component| {
-                let mut component = C::from_resources(resources);
-                component.apply(reflected_component);
-                world.insert_one(entity, component).unwrap();
-            },
-            apply_component: |world, entity, reflected_component| {
-                let mut component = world.get_mut::<C>(entity).unwrap();
-                component.apply(reflected_component);
-            },
-            copy_component: |source_world,
-                             destination_world,
-                             resources,
-                             source_entity,
-                             destination_entity| {
-                let source_component = source_world.get::<C>(source_entity).unwrap();
-                let mut destination_component = C::from_resources(resources);
-                destination_component.apply(source_component);
-                destination_world
-                    .insert_one(destination_entity, destination_component)
-                    .unwrap();
-            },
-            reflect_component: |archetype, index| {
-                unsafe {
-                    // the type has been looked up by the caller, so this is safe
-                    let ptr = archetype.get::<C>().unwrap().as_ptr().add(index);
-                    ptr.as_ref().unwrap()
-                }
-            },
-            reflect_component_mut: |archetype, index| {
-                unsafe {
-                    // the type has been looked up by the caller, so this is safe
-                    let ptr = archetype.get::<C>().unwrap().as_ptr().add(index);
-                    &mut *ptr
-                }
-            },
-        }
-    }
-}
-
-#[derive(Clone)]
-pub struct SceneComponent<Scene: Component, Runtime: Component> {
-    copy_scene_to_runtime: fn(&World, &mut World, &Resources, Entity, Entity),
-    marker: PhantomData<(Scene, Runtime)>,
-}
-
-impl<Scene: Component + IntoComponent<Runtime>, Runtime: Component> SceneComponent<Scene, Runtime> {
-    pub fn copy_scene_to_runtime(
-        &self,
-        scene_world: &World,
-        runtime_world: &mut World,
-        resources: &Resources,
-        scene_entity: Entity,
-        runtime_entity: Entity,
-    ) {
-        (self.copy_scene_to_runtime)(
-            scene_world,
-            runtime_world,
-            resources,
-            scene_entity,
-            runtime_entity,
-        );
-    }
-}
-
-impl<Scene: Component + IntoComponent<Runtime>, Runtime: Component> FromType<Scene>
-    for SceneComponent<Scene, Runtime>
-{
-    fn from_type() -> Self {
-        SceneComponent {
-            copy_scene_to_runtime: |scene_world,
-                                    runtime_world,
-                                    resources,
-                                    scene_entity,
-                                    runtime_entity| {
-                let scene_component = scene_world.get::<Scene>(scene_entity).unwrap();
-                let destination_component = scene_component.as_component(resources);
-                runtime_world
-                    .insert_one(runtime_entity, destination_component)
-                    .unwrap();
-            },
-            marker: Default::default(),
-        }
-    }
-}
-
-#[derive(Clone)]
-pub struct RuntimeComponent<Runtime: Component, Scene: Component> {
-    copy_runtime_to_scene: fn(&World, &mut World, &Resources, Entity, Entity),
-    marker: PhantomData<(Runtime, Scene)>,
-}
-
-impl<Runtime: Component + IntoComponent<Scene>, Scene: Component> RuntimeComponent<Runtime, Scene> {
-    pub fn copy_runtime_to_scene(
-        &self,
-        runtime_world: &World,
-        scene_world: &mut World,
-        resources: &Resources,
-        runtime_entity: Entity,
-        scene_entity: Entity,
-    ) {
-        (self.copy_runtime_to_scene)(
-            runtime_world,
-            scene_world,
-            resources,
-            runtime_entity,
-            scene_entity,
-        );
-    }
-}
-
-impl<Runtime: Component + IntoComponent<Scene>, Scene: Component> FromType<Runtime>
-    for RuntimeComponent<Runtime, Scene>
-{
-    fn from_type() -> Self {
-        RuntimeComponent {
-            copy_runtime_to_scene: |runtime_world,
-                                    scene_world,
-                                    resources,
-                                    runtime_entity,
-                                    scene_entity| {
-                let runtime_component = runtime_world.get::<Runtime>(runtime_entity).unwrap();
-                let scene_component = runtime_component.as_component(resources);
-                scene_world
-                    .insert_one(scene_entity, scene_component)
-                    .unwrap();
-            },
-            marker: Default::default(),
-        }
-    }
-}
-
-#[derive(Clone)]
-pub struct ReflectMapEntities {
-    map_entities: fn(&mut World, &EntityMap) -> Result<(), MapEntitiesError>,
-}
-
-impl ReflectMapEntities {
-    pub fn map_entities(
-        &self,
-        world: &mut World,
-        entity_map: &EntityMap,
-    ) -> Result<(), MapEntitiesError> {
-        (self.map_entities)(world, entity_map)
-    }
-}
-
-impl<C: Component + MapEntities> FromType<C> for ReflectMapEntities {
-    fn from_type() -> Self {
-        ReflectMapEntities {
-            map_entities: |world, entity_map| {
-                for entity in entity_map.values() {
-                    if let Ok(mut component) = world.get_mut::<C>(entity) {
-                        component.map_entities(entity_map)?;
-                    }
-                }
-
-                Ok(())
-            },
-        }
-    }
-}
-
-// TODO: Dead code - this trait is never implemented
-// The name of the method was changed in <https://github.com/bevyengine/bevy/pull/1433>
-// to fix the update to clippy for Rust 1.50
-// which is why this is inconsistent
-pub trait IntoComponent<ToComponent: Component> {
-    fn as_component(&self, resources: &Resources) -> ToComponent;
-}
diff --git a/crates/bevy_reflect/src/lib.rs b/crates/bevy_reflect/src/lib.rs
index d5934c0e3f871..6d00e533f4bc6 100644
--- a/crates/bevy_reflect/src/lib.rs
+++ b/crates/bevy_reflect/src/lib.rs
@@ -8,20 +8,12 @@ mod tuple_struct;
 mod type_registry;
 mod type_uuid;
 mod impls {
-    #[cfg(feature = "bevy_app")]
-    mod bevy_app;
-    #[cfg(feature = "bevy_ecs")]
-    mod bevy_ecs;
     #[cfg(feature = "glam")]
     mod glam;
     #[cfg(feature = "smallvec")]
     mod smallvec;
     mod std;
 
-    #[cfg(feature = "bevy_app")]
-    pub use self::bevy_app::*;
-    #[cfg(feature = "bevy_ecs")]
-    pub use self::bevy_ecs::*;
     #[cfg(feature = "glam")]
     pub use self::glam::*;
     #[cfg(feature = "smallvec")]
@@ -31,10 +23,6 @@ mod impls {
 
 pub mod serde;
 pub mod prelude {
-    #[cfg(feature = "bevy_ecs")]
-    pub use crate::ReflectComponent;
-    #[cfg(feature = "bevy_app")]
-    pub use crate::RegisterTypeBuilder;
     pub use crate::{
         reflect_trait, GetField, GetTupleStructField, Reflect, ReflectDeserialize, Struct,
         TupleStruct,
diff --git a/crates/bevy_render/src/camera/active_cameras.rs b/crates/bevy_render/src/camera/active_cameras.rs
index 9384774b15c52..d6e0a9c0601f8 100644
--- a/crates/bevy_render/src/camera/active_cameras.rs
+++ b/crates/bevy_render/src/camera/active_cameras.rs
@@ -1,5 +1,8 @@
 use super::Camera;
-use bevy_ecs::{Entity, Query, ResMut};
+use bevy_ecs::{
+    entity::Entity,
+    system::{Query, ResMut},
+};
 use bevy_utils::HashMap;
 
 #[derive(Debug, Default)]
diff --git a/crates/bevy_render/src/camera/camera.rs b/crates/bevy_render/src/camera/camera.rs
index bebbb39c87675..90762c1423c46 100644
--- a/crates/bevy_render/src/camera/camera.rs
+++ b/crates/bevy_render/src/camera/camera.rs
@@ -1,8 +1,14 @@
 use super::CameraProjection;
 use bevy_app::prelude::EventReader;
-use bevy_ecs::{Added, Component, Entity, Query, QuerySet, Res};
+use bevy_ecs::{
+    component::Component,
+    entity::Entity,
+    query::Added,
+    reflect::ReflectComponent,
+    system::{Query, QuerySet, Res},
+};
 use bevy_math::{Mat4, Vec2, Vec3};
-use bevy_reflect::{Reflect, ReflectComponent, ReflectDeserialize};
+use bevy_reflect::{Reflect, ReflectDeserialize};
 use bevy_transform::components::GlobalTransform;
 use bevy_window::{WindowCreated, WindowId, WindowResized, Windows};
 use serde::{Deserialize, Serialize};
diff --git a/crates/bevy_render/src/camera/projection.rs b/crates/bevy_render/src/camera/projection.rs
index 51c5c3e535cf2..4e227654f9d24 100644
--- a/crates/bevy_render/src/camera/projection.rs
+++ b/crates/bevy_render/src/camera/projection.rs
@@ -1,6 +1,7 @@
 use super::DepthCalculation;
+use bevy_ecs::reflect::ReflectComponent;
 use bevy_math::Mat4;
-use bevy_reflect::{Reflect, ReflectComponent, ReflectDeserialize};
+use bevy_reflect::{Reflect, ReflectDeserialize};
 use serde::{Deserialize, Serialize};
 
 pub trait CameraProjection {
diff --git a/crates/bevy_render/src/camera/visible_entities.rs b/crates/bevy_render/src/camera/visible_entities.rs
index 9c7edd59168eb..940adab57ab32 100644
--- a/crates/bevy_render/src/camera/visible_entities.rs
+++ b/crates/bevy_render/src/camera/visible_entities.rs
@@ -1,8 +1,8 @@
 use super::{Camera, DepthCalculation};
 use crate::prelude::Visible;
 use bevy_core::FloatOrd;
-use bevy_ecs::{Entity, Query, With};
-use bevy_reflect::{Reflect, ReflectComponent};
+use bevy_ecs::{entity::Entity, query::With, reflect::ReflectComponent, system::Query};
+use bevy_reflect::Reflect;
 use bevy_transform::prelude::GlobalTransform;
 
 #[derive(Debug)]
diff --git a/crates/bevy_render/src/draw.rs b/crates/bevy_render/src/draw.rs
index ab6c6192465bd..9bdbb5533dac1 100644
--- a/crates/bevy_render/src/draw.rs
+++ b/crates/bevy_render/src/draw.rs
@@ -9,8 +9,11 @@ use crate::{
     shader::Shader,
 };
 use bevy_asset::{Asset, Assets, Handle};
-use bevy_ecs::{Query, Res, ResMut, SystemParam};
-use bevy_reflect::{Reflect, ReflectComponent};
+use bevy_ecs::{
+    reflect::ReflectComponent,
+    system::{Query, Res, ResMut, SystemParam},
+};
+use bevy_reflect::Reflect;
 use std::{ops::Range, sync::Arc};
 use thiserror::Error;
 
diff --git a/crates/bevy_render/src/entity.rs b/crates/bevy_render/src/entity.rs
index 28344fd4bdeb7..7c6d4df1a93f0 100644
--- a/crates/bevy_render/src/entity.rs
+++ b/crates/bevy_render/src/entity.rs
@@ -10,7 +10,7 @@ use crate::{
 };
 use base::MainPass;
 use bevy_asset::Handle;
-use bevy_ecs::Bundle;
+use bevy_ecs::bundle::Bundle;
 use bevy_transform::components::{GlobalTransform, Transform};
 
 /// A component bundle for "mesh" entities
diff --git a/crates/bevy_render/src/lib.rs b/crates/bevy_render/src/lib.rs
index 62e97060735f0..0c6326305cb99 100644
--- a/crates/bevy_render/src/lib.rs
+++ b/crates/bevy_render/src/lib.rs
@@ -12,8 +12,10 @@ pub mod shader;
 pub mod texture;
 pub mod wireframe;
 
-use bevy_ecs::{IntoExclusiveSystem, IntoSystem, SystemStage};
-use bevy_reflect::RegisterTypeBuilder;
+use bevy_ecs::{
+    schedule::SystemStage,
+    system::{IntoExclusiveSystem, IntoSystem},
+};
 use draw::Visible;
 pub use once_cell;
 
@@ -35,7 +37,7 @@ use crate::prelude::*;
 use base::Msaa;
 use bevy_app::prelude::*;
 use bevy_asset::{AddAsset, AssetStage};
-use bevy_ecs::StageLabel;
+use bevy_ecs::schedule::StageLabel;
 use camera::{
     ActiveCameras, Camera, OrthographicProjection, PerspectiveProjection, VisibleEntities,
 };
@@ -44,7 +46,7 @@ use pipeline::{
     ShaderSpecialization,
 };
 use render_graph::{
-    base::{self, BaseRenderGraphBuilder, BaseRenderGraphConfig, MainPass},
+    base::{self, BaseRenderGraphConfig, MainPass},
     RenderGraph,
 };
 use renderer::{AssetRenderResourceBindings, RenderResourceBindings};
@@ -92,12 +94,6 @@ impl Plugin for RenderPlugin {
             app.init_asset_loader::<HdrTextureLoader>();
         }
 
-        app.init_asset_loader::<ShaderLoader>();
-
-        if app.resources().get::<ClearColor>().is_none() {
-            app.resources_mut().insert(ClearColor::default());
-        }
-
         app.add_stage_after(
             AssetStage::AssetEvents,
             RenderStage::RenderResource,
@@ -123,6 +119,7 @@ impl Plugin for RenderPlugin {
             RenderStage::PostRender,
             SystemStage::parallel(),
         )
+        .init_asset_loader::<ShaderLoader>()
         .add_asset::<Mesh>()
         .add_asset::<Texture>()
         .add_asset::<Shader>()
@@ -140,6 +137,7 @@ impl Plugin for RenderPlugin {
         .register_type::<PrimitiveTopology>()
         .register_type::<IndexFormat>()
         .register_type::<PipelineSpecialization>()
+        .init_resource::<ClearColor>()
         .init_resource::<RenderGraph>()
         .init_resource::<PipelineCompiler>()
         .init_resource::<Msaa>()
@@ -190,11 +188,8 @@ impl Plugin for RenderPlugin {
         );
 
         if let Some(ref config) = self.base_render_graph_config {
-            let resources = app.resources();
-            let mut render_graph = resources.get_mut::<RenderGraph>().unwrap();
-            let msaa = resources.get::<Msaa>().unwrap();
-            render_graph.add_base_graph(config, &msaa);
-            let mut active_cameras = resources.get_mut::<ActiveCameras>().unwrap();
+            crate::base::add_base_graph(config, app.world_mut());
+            let mut active_cameras = app.world_mut().get_resource_mut::<ActiveCameras>().unwrap();
             if config.add_3d_camera {
                 active_cameras.add(base::camera::CAMERA_3D);
             }
diff --git a/crates/bevy_render/src/mesh/mesh.rs b/crates/bevy_render/src/mesh/mesh.rs
index edb309ece04dd..59e5c6602ec1e 100644
--- a/crates/bevy_render/src/mesh/mesh.rs
+++ b/crates/bevy_render/src/mesh/mesh.rs
@@ -5,7 +5,12 @@ use crate::{
 use bevy_app::prelude::EventReader;
 use bevy_asset::{AssetEvent, Assets, Handle};
 use bevy_core::AsBytes;
-use bevy_ecs::{Changed, Entity, Local, Mut, Query, QuerySet, Res, With};
+use bevy_ecs::{
+    entity::Entity,
+    query::{Changed, With},
+    system::{Local, Query, QuerySet, Res},
+    world::Mut,
+};
 use bevy_math::*;
 use bevy_reflect::TypeUuid;
 use std::borrow::Cow;
diff --git a/crates/bevy_render/src/pipeline/render_pipelines.rs b/crates/bevy_render/src/pipeline/render_pipelines.rs
index da2928e5fe4c2..8f0476024f9cc 100644
--- a/crates/bevy_render/src/pipeline/render_pipelines.rs
+++ b/crates/bevy_render/src/pipeline/render_pipelines.rs
@@ -6,8 +6,11 @@ use crate::{
     renderer::RenderResourceBindings,
 };
 use bevy_asset::{Assets, Handle};
-use bevy_ecs::{Query, Res, ResMut};
-use bevy_reflect::{Reflect, ReflectComponent};
+use bevy_ecs::{
+    reflect::ReflectComponent,
+    system::{Query, Res, ResMut},
+};
+use bevy_reflect::Reflect;
 use bevy_utils::HashSet;
 
 #[derive(Debug, Default, Clone, Reflect)]
diff --git a/crates/bevy_render/src/render_graph/base.rs b/crates/bevy_render/src/render_graph/base.rs
index 28eced3a71d84..f145eb316cfc6 100644
--- a/crates/bevy_render/src/render_graph/base.rs
+++ b/crates/bevy_render/src/render_graph/base.rs
@@ -10,7 +10,8 @@ use crate::{
     texture::{Extent3d, TextureDescriptor, TextureDimension, TextureFormat, TextureUsage},
     Color,
 };
-use bevy_reflect::{Reflect, ReflectComponent};
+use bevy_ecs::{reflect::ReflectComponent, world::World};
+use bevy_reflect::Reflect;
 use bevy_window::WindowId;
 
 /// A component that indicates that an entity should be drawn in the "main pass"
@@ -90,102 +91,107 @@ impl Default for BaseRenderGraphConfig {
         }
     }
 }
+
 /// The "base render graph" provides a core set of render graph nodes which can be used to build any graph.
 /// By itself this graph doesn't do much, but it allows Render plugins to interop with each other by having a common
 /// set of nodes. It can be customized using `BaseRenderGraphConfig`.
-pub trait BaseRenderGraphBuilder {
-    fn add_base_graph(&mut self, config: &BaseRenderGraphConfig, msaa: &Msaa) -> &mut Self;
-}
-
-impl BaseRenderGraphBuilder for RenderGraph {
-    fn add_base_graph(&mut self, config: &BaseRenderGraphConfig, msaa: &Msaa) -> &mut Self {
-        self.add_node(node::TEXTURE_COPY, TextureCopyNode::default());
-        if config.add_3d_camera {
-            self.add_system_node(node::CAMERA_3D, CameraNode::new(camera::CAMERA_3D));
-        }
+pub(crate) fn add_base_graph(config: &BaseRenderGraphConfig, world: &mut World) {
+    let world = world.cell();
+    let mut graph = world.get_resource_mut::<RenderGraph>().unwrap();
+    let msaa = world.get_resource::<Msaa>().unwrap();
+
+    graph.add_node(node::TEXTURE_COPY, TextureCopyNode::default());
+    if config.add_3d_camera {
+        graph.add_system_node(node::CAMERA_3D, CameraNode::new(camera::CAMERA_3D));
+    }
 
-        if config.add_2d_camera {
-            self.add_system_node(node::CAMERA_2D, CameraNode::new(camera::CAMERA_2D));
-        }
+    if config.add_2d_camera {
+        graph.add_system_node(node::CAMERA_2D, CameraNode::new(camera::CAMERA_2D));
+    }
 
-        self.add_node(node::SHARED_BUFFERS, SharedBuffersNode::default());
-        if config.add_main_depth_texture {
-            self.add_node(
-                node::MAIN_DEPTH_TEXTURE,
-                WindowTextureNode::new(
-                    WindowId::primary(),
-                    TextureDescriptor {
-                        size: Extent3d {
-                            depth: 1,
-                            width: 1,
-                            height: 1,
-                        },
-                        mip_level_count: 1,
-                        sample_count: msaa.samples,
-                        dimension: TextureDimension::D2,
-                        format: TextureFormat::Depth32Float, // PERF: vulkan docs recommend using 24 bit depth for better performance
-                        usage: TextureUsage::OUTPUT_ATTACHMENT,
+    graph.add_node(node::SHARED_BUFFERS, SharedBuffersNode::default());
+    if config.add_main_depth_texture {
+        graph.add_node(
+            node::MAIN_DEPTH_TEXTURE,
+            WindowTextureNode::new(
+                WindowId::primary(),
+                TextureDescriptor {
+                    size: Extent3d {
+                        depth: 1,
+                        width: 1,
+                        height: 1,
                     },
-                ),
-            );
-        }
+                    mip_level_count: 1,
+                    sample_count: msaa.samples,
+                    dimension: TextureDimension::D2,
+                    format: TextureFormat::Depth32Float, // PERF: vulkan docs recommend using 24 bit depth for better performance
+                    usage: TextureUsage::OUTPUT_ATTACHMENT,
+                },
+            ),
+        );
+    }
 
-        if config.add_main_pass {
-            let mut main_pass_node = PassNode::<&MainPass>::new(PassDescriptor {
-                color_attachments: vec![msaa.color_attachment_descriptor(
-                    TextureAttachment::Input("color_attachment".to_string()),
-                    TextureAttachment::Input("color_resolve_target".to_string()),
-                    Operations {
-                        load: LoadOp::Clear(Color::rgb(0.1, 0.1, 0.1)),
-                        store: true,
-                    },
-                )],
-                depth_stencil_attachment: Some(RenderPassDepthStencilAttachmentDescriptor {
-                    attachment: TextureAttachment::Input("depth".to_string()),
-                    depth_ops: Some(Operations {
-                        load: LoadOp::Clear(1.0),
-                        store: true,
-                    }),
-                    stencil_ops: None,
+    if config.add_main_pass {
+        let mut main_pass_node = PassNode::<&MainPass>::new(PassDescriptor {
+            color_attachments: vec![msaa.color_attachment_descriptor(
+                TextureAttachment::Input("color_attachment".to_string()),
+                TextureAttachment::Input("color_resolve_target".to_string()),
+                Operations {
+                    load: LoadOp::Clear(Color::rgb(0.1, 0.1, 0.1)),
+                    store: true,
+                },
+            )],
+            depth_stencil_attachment: Some(RenderPassDepthStencilAttachmentDescriptor {
+                attachment: TextureAttachment::Input("depth".to_string()),
+                depth_ops: Some(Operations {
+                    load: LoadOp::Clear(1.0),
+                    store: true,
                 }),
-                sample_count: msaa.samples,
-            });
+                stencil_ops: None,
+            }),
+            sample_count: msaa.samples,
+        });
 
-            main_pass_node.use_default_clear_color(0);
+        main_pass_node.use_default_clear_color(0);
 
-            if config.add_3d_camera {
-                main_pass_node.add_camera(camera::CAMERA_3D);
-            }
+        if config.add_3d_camera {
+            main_pass_node.add_camera(camera::CAMERA_3D);
+        }
 
-            if config.add_2d_camera {
-                main_pass_node.add_camera(camera::CAMERA_2D);
-            }
+        if config.add_2d_camera {
+            main_pass_node.add_camera(camera::CAMERA_2D);
+        }
 
-            self.add_node(node::MAIN_PASS, main_pass_node);
+        graph.add_node(node::MAIN_PASS, main_pass_node);
 
-            self.add_node_edge(node::TEXTURE_COPY, node::MAIN_PASS)
-                .unwrap();
-            self.add_node_edge(node::SHARED_BUFFERS, node::MAIN_PASS)
-                .unwrap();
+        graph
+            .add_node_edge(node::TEXTURE_COPY, node::MAIN_PASS)
+            .unwrap();
+        graph
+            .add_node_edge(node::SHARED_BUFFERS, node::MAIN_PASS)
+            .unwrap();
 
-            if config.add_3d_camera {
-                self.add_node_edge(node::CAMERA_3D, node::MAIN_PASS)
-                    .unwrap();
-            }
+        if config.add_3d_camera {
+            graph
+                .add_node_edge(node::CAMERA_3D, node::MAIN_PASS)
+                .unwrap();
+        }
 
-            if config.add_2d_camera {
-                self.add_node_edge(node::CAMERA_2D, node::MAIN_PASS)
-                    .unwrap();
-            }
+        if config.add_2d_camera {
+            graph
+                .add_node_edge(node::CAMERA_2D, node::MAIN_PASS)
+                .unwrap();
         }
+    }
 
-        self.add_node(
-            node::PRIMARY_SWAP_CHAIN,
-            WindowSwapChainNode::new(WindowId::primary()),
-        );
+    graph.add_node(
+        node::PRIMARY_SWAP_CHAIN,
+        WindowSwapChainNode::new(WindowId::primary()),
+    );
 
-        if config.connect_main_pass_to_swapchain {
-            self.add_slot_edge(
+    if config.connect_main_pass_to_swapchain {
+        graph
+            .add_slot_edge(
                 node::PRIMARY_SWAP_CHAIN,
                 WindowSwapChainNode::OUT_TEXTURE,
                 node::MAIN_PASS,
@@ -196,47 +202,46 @@ impl BaseRenderGraphBuilder for RenderGraph {
                 },
             )
             .unwrap();
-        }
+    }
 
-        if msaa.samples > 1 {
-            self.add_node(
-                node::MAIN_SAMPLED_COLOR_ATTACHMENT,
-                WindowTextureNode::new(
-                    WindowId::primary(),
-                    TextureDescriptor {
-                        size: Extent3d {
-                            depth: 1,
-                            width: 1,
-                            height: 1,
-                        },
-                        mip_level_count: 1,
-                        sample_count: msaa.samples,
-                        dimension: TextureDimension::D2,
-                        format: TextureFormat::default(),
-                        usage: TextureUsage::OUTPUT_ATTACHMENT,
+    if msaa.samples > 1 {
+        graph.add_node(
+            node::MAIN_SAMPLED_COLOR_ATTACHMENT,
+            WindowTextureNode::new(
+                WindowId::primary(),
+                TextureDescriptor {
+                    size: Extent3d {
+                        depth: 1,
+                        width: 1,
+                        height: 1,
                     },
-                ),
-            );
+                    mip_level_count: 1,
+                    sample_count: msaa.samples,
+                    dimension: TextureDimension::D2,
+                    format: TextureFormat::default(),
+                    usage: TextureUsage::OUTPUT_ATTACHMENT,
+                },
+            ),
+        );
 
-            self.add_slot_edge(
+        graph
+            .add_slot_edge(
                 node::MAIN_SAMPLED_COLOR_ATTACHMENT,
                 WindowSwapChainNode::OUT_TEXTURE,
                 node::MAIN_PASS,
                 "color_attachment",
             )
             .unwrap();
-        }
+    }
 
-        if config.connect_main_pass_to_main_depth_texture {
-            self.add_slot_edge(
+    if config.connect_main_pass_to_main_depth_texture {
+        graph
+            .add_slot_edge(
                 node::MAIN_DEPTH_TEXTURE,
                 WindowTextureNode::OUT_TEXTURE,
                 node::MAIN_PASS,
                 "depth",
             )
             .unwrap();
-        }
-
-        self
     }
 }
diff --git a/crates/bevy_render/src/render_graph/command.rs b/crates/bevy_render/src/render_graph/command.rs
index d098db74aa1f6..b689ceead5a6b 100644
--- a/crates/bevy_render/src/render_graph/command.rs
+++ b/crates/bevy_render/src/render_graph/command.rs
@@ -147,7 +147,7 @@ impl CommandQueue {
         self.queue.lock().clear();
     }
 
-    pub fn execute(&mut self, render_context: &mut dyn RenderContext) {
+    pub fn execute(&self, render_context: &mut dyn RenderContext) {
         for command in self.queue.lock().drain(..) {
             match command {
                 Command::CopyBufferToBuffer {
diff --git a/crates/bevy_render/src/render_graph/graph.rs b/crates/bevy_render/src/render_graph/graph.rs
index 6a1e14ef7036b..90fcdd4353381 100644
--- a/crates/bevy_render/src/render_graph/graph.rs
+++ b/crates/bevy_render/src/render_graph/graph.rs
@@ -1,12 +1,14 @@
 use super::{Edge, Node, NodeId, NodeLabel, NodeState, RenderGraphError, SlotLabel, SystemNode};
-use bevy_ecs::{Commands, Schedule, StageLabel, SystemStage};
+use bevy_ecs::{
+    schedule::{Schedule, StageLabel, SystemStage},
+    world::World,
+};
 use bevy_utils::HashMap;
 use std::{borrow::Cow, fmt::Debug};
 pub struct RenderGraph {
     nodes: HashMap<NodeId, NodeState>,
     node_names: HashMap<Cow<'static, str>, NodeId>,
     system_node_schedule: Option<Schedule>,
-    commands: Commands,
 }
 
 #[derive(Debug, Hash, PartialEq, Eq, Clone, StageLabel)]
@@ -20,7 +22,6 @@ impl Default for RenderGraph {
             nodes: Default::default(),
             node_names: Default::default(),
             system_node_schedule: Some(schedule),
-            commands: Default::default(),
         }
     }
 }
@@ -47,7 +48,7 @@ impl RenderGraph {
         let stage = schedule
             .get_stage_mut::<SystemStage>(&RenderGraphUpdate)
             .unwrap();
-        stage.add_system(node.get_system(&mut self.commands));
+        stage.add_system(node.get_system());
         self.add_node(name, node)
     }
 
@@ -279,8 +280,10 @@ impl RenderGraph {
             .map(move |(edge, input_node_id)| (edge, self.get_node_state(input_node_id).unwrap())))
     }
 
-    pub fn take_commands(&mut self) -> Commands {
-        std::mem::take(&mut self.commands)
+    pub fn prepare(&mut self, world: &mut World) {
+        for node in self.nodes.values_mut() {
+            node.node.prepare(world);
+        }
     }
 }
 
@@ -303,7 +306,7 @@ mod tests {
         render_graph::{Edge, Node, NodeId, RenderGraphError, ResourceSlotInfo, ResourceSlots},
         renderer::{RenderContext, RenderResourceType},
     };
-    use bevy_ecs::{Resources, World};
+    use bevy_ecs::world::World;
     use bevy_utils::HashSet;
     use std::iter::FromIterator;
 
@@ -344,7 +347,6 @@ mod tests {
         fn update(
             &mut self,
             _: &World,
-            _: &Resources,
             _: &mut dyn RenderContext,
             _: &ResourceSlots,
             _: &mut ResourceSlots,
@@ -418,7 +420,6 @@ mod tests {
             fn update(
                 &mut self,
                 _: &World,
-                _: &Resources,
                 _: &mut dyn RenderContext,
                 _: &ResourceSlots,
                 _: &mut ResourceSlots,
diff --git a/crates/bevy_render/src/render_graph/node.rs b/crates/bevy_render/src/render_graph/node.rs
index 3b61a7a60403b..048533e900455 100644
--- a/crates/bevy_render/src/render_graph/node.rs
+++ b/crates/bevy_render/src/render_graph/node.rs
@@ -1,6 +1,6 @@
 use super::{Edge, RenderGraphError, ResourceSlotInfo, ResourceSlots};
 use crate::renderer::RenderContext;
-use bevy_ecs::{BoxedSystem, Commands, Resources, World};
+use bevy_ecs::{system::BoxedSystem, world::World};
 use bevy_utils::Uuid;
 use downcast_rs::{impl_downcast, Downcast};
 use std::{borrow::Cow, fmt::Debug};
@@ -28,10 +28,13 @@ pub trait Node: Downcast + Send + Sync + 'static {
         &[]
     }
 
+    /// Prepare the graph node with unique world access. This runs once per graph run before [Node::update] is called.
+    fn prepare(&mut self, _world: &mut World) {}
+
+    /// Run the graph node logic. This runs once per graph run after [Node::prepare] has been called on all nodes.
     fn update(
         &mut self,
         world: &World,
-        resources: &Resources,
         render_context: &mut dyn RenderContext,
         input: &ResourceSlots,
         output: &mut ResourceSlots,
@@ -41,7 +44,7 @@ pub trait Node: Downcast + Send + Sync + 'static {
 impl_downcast!(Node);
 
 pub trait SystemNode: Node {
-    fn get_system(&self, commands: &mut Commands) -> BoxedSystem;
+    fn get_system(&self) -> BoxedSystem;
 }
 
 #[derive(Debug)]
diff --git a/crates/bevy_render/src/render_graph/nodes/camera_node.rs b/crates/bevy_render/src/render_graph/nodes/camera_node.rs
index 54d119c13a4b4..ed62fdd395197 100644
--- a/crates/bevy_render/src/render_graph/nodes/camera_node.rs
+++ b/crates/bevy_render/src/render_graph/nodes/camera_node.rs
@@ -7,9 +7,9 @@ use crate::{
     },
 };
 use bevy_core::AsBytes;
-
 use bevy_ecs::{
-    BoxedSystem, Commands, IntoSystem, Local, Query, Res, ResMut, Resources, System, World,
+    system::{BoxedSystem, IntoSystem, Local, Query, Res, ResMut},
+    world::World,
 };
 use bevy_transform::prelude::*;
 use std::borrow::Cow;
@@ -36,7 +36,6 @@ impl Node for CameraNode {
     fn update(
         &mut self,
         _world: &World,
-        _resources: &Resources,
         render_context: &mut dyn RenderContext,
         _input: &ResourceSlots,
         _output: &mut ResourceSlots,
@@ -46,17 +45,15 @@ impl Node for CameraNode {
 }
 
 impl SystemNode for CameraNode {
-    fn get_system(&self, commands: &mut Commands) -> BoxedSystem {
-        let system = camera_node_system.system();
-        commands.insert_local_resource(
-            system.id(),
-            CameraNodeState {
+    fn get_system(&self) -> BoxedSystem {
+        let system = camera_node_system.system().config(|config| {
+            config.0 = Some(CameraNodeState {
                 camera_name: self.camera_name.clone(),
                 command_queue: self.command_queue.clone(),
                 camera_buffer: None,
                 staging_buffer: None,
-            },
-        );
+            })
+        });
         Box::new(system)
     }
 }
diff --git a/crates/bevy_render/src/render_graph/nodes/pass_node.rs b/crates/bevy_render/src/render_graph/nodes/pass_node.rs
index 2db0058ac52b4..e105f9bc900b5 100644
--- a/crates/bevy_render/src/render_graph/nodes/pass_node.rs
+++ b/crates/bevy_render/src/render_graph/nodes/pass_node.rs
@@ -13,9 +13,12 @@ use crate::{
     },
 };
 use bevy_asset::{Assets, Handle};
-use bevy_ecs::{ReadOnlyFetch, Resources, World, WorldQuery};
+use bevy_ecs::{
+    query::{QueryState, ReadOnlyFetch, WorldQuery},
+    world::World,
+};
 use bevy_utils::tracing::debug;
-use std::{fmt, marker::PhantomData, ops::Deref};
+use std::{fmt, ops::Deref};
 
 #[derive(Debug)]
 struct CameraInfo {
@@ -32,7 +35,7 @@ pub struct PassNode<Q: WorldQuery> {
     depth_stencil_attachment_input_index: Option<usize>,
     default_clear_color_inputs: Vec<usize>,
     camera_bind_group_descriptor: BindGroupDescriptor,
-    _marker: PhantomData<Q>,
+    query_state: Option<QueryState<Q>>,
 }
 
 impl<Q: WorldQuery> fmt::Debug for PassNode<Q> {
@@ -125,7 +128,7 @@ impl<Q: WorldQuery> PassNode<Q> {
             depth_stencil_attachment_input_index,
             default_clear_color_inputs: Vec::new(),
             camera_bind_group_descriptor,
-            _marker: PhantomData::default(),
+            query_state: None,
         }
     }
 
@@ -149,21 +152,24 @@ where
         &self.inputs
     }
 
+    fn prepare(&mut self, world: &mut World) {
+        self.query_state.get_or_insert_with(|| world.query());
+    }
+
     fn update(
         &mut self,
         world: &World,
-        resources: &Resources,
         render_context: &mut dyn RenderContext,
         input: &ResourceSlots,
         _output: &mut ResourceSlots,
     ) {
-        let render_resource_bindings = resources.get::<RenderResourceBindings>().unwrap();
-        let pipelines = resources.get::<Assets<PipelineDescriptor>>().unwrap();
-        let active_cameras = resources.get::<ActiveCameras>().unwrap();
+        let render_resource_bindings = world.get_resource::<RenderResourceBindings>().unwrap();
+        let pipelines = world.get_resource::<Assets<PipelineDescriptor>>().unwrap();
+        let active_cameras = world.get_resource::<ActiveCameras>().unwrap();
 
         for (i, color_attachment) in self.descriptor.color_attachments.iter_mut().enumerate() {
             if self.default_clear_color_inputs.contains(&i) {
-                if let Some(default_clear_color) = resources.get::<ClearColor>() {
+                if let Some(default_clear_color) = world.get_resource::<ClearColor>() {
                     color_attachment.ops.load = LoadOp::Clear(default_clear_color.0);
                 }
             }
@@ -205,11 +211,14 @@ where
             }
         }
 
+        let query_state = self.query_state.as_mut().unwrap();
+        let cameras = &self.cameras;
+        let camera_bind_group_descriptor = &self.camera_bind_group_descriptor;
         render_context.begin_pass(
             &self.descriptor,
             &render_resource_bindings,
             &mut |render_pass| {
-                for camera_info in self.cameras.iter() {
+                for camera_info in cameras.iter() {
                     let camera_bind_group_id= if let Some(bind_group_id) = camera_info.bind_group_id {
                         bind_group_id
                     } else {
@@ -226,18 +235,18 @@ where
                     // attempt to draw each visible entity
                     let mut draw_state = DrawState::default();
                     for visible_entity in visible_entities.iter() {
-                        if world.query_one::<Q>(visible_entity.entity).is_err() {
+                        if query_state.get(world, visible_entity.entity).is_err() {
                             // visible entity does not match the Pass query
                             continue;
                         }
 
-                        let draw = if let Ok(draw) = world.get::<Draw>(visible_entity.entity) {
+                        let draw = if let Some(draw) = world.get::<Draw>(visible_entity.entity) {
                             draw
                         } else {
                             continue;
                         };
 
-                        if let Ok(visible) = world.get::<Visible>(visible_entity.entity) {
+                        if let Some(visible) = world.get::<Visible>(visible_entity.entity) {
                             if !visible.is_visible {
                                 continue;
                             }
@@ -257,7 +266,7 @@ where
                                     // try to set current camera bind group
                                     let layout = descriptor.get_layout().unwrap();
                                     if let Some(descriptor) = layout.get_bind_group(0) {
-                                        if *descriptor == self.camera_bind_group_descriptor {
+                                        if descriptor == camera_bind_group_descriptor {
                                             draw_state.set_bind_group(0, camera_bind_group_id);
                                             render_pass.set_bind_group(
                                                 0,
diff --git a/crates/bevy_render/src/render_graph/nodes/render_resources_node.rs b/crates/bevy_render/src/render_graph/nodes/render_resources_node.rs
index 141d8bfc9d757..1afb198f46025 100644
--- a/crates/bevy_render/src/render_graph/nodes/render_resources_node.rs
+++ b/crates/bevy_render/src/render_graph/nodes/render_resources_node.rs
@@ -12,8 +12,10 @@ use crate::{
 use bevy_app::EventReader;
 use bevy_asset::{Asset, AssetEvent, Assets, Handle, HandleId};
 use bevy_ecs::{
-    BoxedSystem, Changed, Commands, Entity, IntoSystem, Local, Or, Query, QuerySet, Res, ResMut,
-    Resources, System, With, World,
+    entity::Entity,
+    query::{Changed, Or, With},
+    system::{BoxedSystem, IntoSystem, Local, Query, QuerySet, RemovedComponents, Res, ResMut},
+    world::World,
 };
 use bevy_utils::HashMap;
 use renderer::{AssetRenderResourceBindings, BufferId, RenderResourceType, RenderResources};
@@ -388,7 +390,6 @@ where
     fn update(
         &mut self,
         _world: &World,
-        _resources: &Resources,
         render_context: &mut dyn RenderContext,
         _input: &ResourceSlots,
         _output: &mut ResourceSlots,
@@ -401,16 +402,14 @@ impl<T> SystemNode for RenderResourcesNode<T>
 where
     T: renderer::RenderResources,
 {
-    fn get_system(&self, commands: &mut Commands) -> BoxedSystem {
-        let system = render_resources_node_system::<T>.system();
-        commands.insert_local_resource(
-            system.id(),
-            RenderResourcesNodeState {
+    fn get_system(&self) -> BoxedSystem {
+        let system = render_resources_node_system::<T>.system().config(|config| {
+            config.0 = Some(RenderResourcesNodeState {
                 command_queue: self.command_queue.clone(),
                 uniform_buffer_arrays: UniformBufferArrays::<Entity, T>::default(),
                 dynamic_uniforms: self.dynamic_uniforms,
-            },
-        );
+            })
+        });
 
         Box::new(system)
     }
@@ -436,6 +435,7 @@ fn render_resources_node_system<T: RenderResources>(
     mut state: Local<RenderResourcesNodeState<Entity, T>>,
     mut entities_waiting_for_textures: Local<Vec<Entity>>,
     render_resource_context: Res<Box<dyn RenderResourceContext>>,
+    removed: RemovedComponents<T>,
     mut queries: QuerySet<(
         Query<(Entity, &T, &Visible, &mut RenderPipelines), Or<(Changed<T>, Changed<Visible>)>>,
         Query<(Entity, &T, &Visible, &mut RenderPipelines)>,
@@ -450,8 +450,8 @@ fn render_resources_node_system<T: RenderResources>(
         uniform_buffer_arrays.initialize(first, render_resource_context);
     }
 
-    for entity in queries.q0().removed::<T>() {
-        uniform_buffer_arrays.remove_bindings(*entity);
+    for entity in removed.iter() {
+        uniform_buffer_arrays.remove_bindings(entity);
     }
 
     // handle entities that were waiting for texture loads on the last update
@@ -571,7 +571,6 @@ where
     fn update(
         &mut self,
         _world: &World,
-        _resources: &Resources,
         render_context: &mut dyn RenderContext,
         _input: &ResourceSlots,
         _output: &mut ResourceSlots,
@@ -584,16 +583,16 @@ impl<T> SystemNode for AssetRenderResourcesNode<T>
 where
     T: renderer::RenderResources + Asset,
 {
-    fn get_system(&self, commands: &mut Commands) -> BoxedSystem {
-        let system = asset_render_resources_node_system::<T>.system();
-        commands.insert_local_resource(
-            system.id(),
-            RenderResourcesNodeState {
-                command_queue: self.command_queue.clone(),
-                uniform_buffer_arrays: UniformBufferArrays::<HandleId, T>::default(),
-                dynamic_uniforms: self.dynamic_uniforms,
-            },
-        );
+    fn get_system(&self) -> BoxedSystem {
+        let system = asset_render_resources_node_system::<T>
+            .system()
+            .config(|config| {
+                config.0 = Some(RenderResourcesNodeState {
+                    command_queue: self.command_queue.clone(),
+                    uniform_buffer_arrays: UniformBufferArrays::<HandleId, T>::default(),
+                    dynamic_uniforms: self.dynamic_uniforms,
+                })
+            });
 
         Box::new(system)
     }
@@ -621,11 +620,11 @@ fn asset_render_resources_node_system<T: RenderResources + Asset>(
     mut asset_events: EventReader<AssetEvent<T>>,
     mut asset_render_resource_bindings: ResMut<AssetRenderResourceBindings>,
     render_resource_context: Res<Box<dyn RenderResourceContext>>,
+    removed_handles: RemovedComponents<Handle<T>>,
     mut queries: QuerySet<(
         Query<(&Handle<T>, &mut RenderPipelines), Changed<Handle<T>>>,
         Query<&mut RenderPipelines, With<Handle<T>>>,
     )>,
-    entity_query: Query<Entity>,
 ) {
     let state = state.deref_mut();
     let uniform_buffer_arrays = &mut state.uniform_buffer_arrays;
@@ -747,8 +746,8 @@ fn asset_render_resources_node_system<T: RenderResources + Asset>(
     }
 
     // update removed entity asset mapping
-    for entity in entity_query.removed::<Handle<T>>() {
-        if let Ok(mut render_pipelines) = queries.q1_mut().get_mut(*entity) {
+    for entity in removed_handles.iter() {
+        if let Ok(mut render_pipelines) = queries.q1_mut().get_mut(entity) {
             render_pipelines
                 .bindings
                 .remove_asset_with_type(TypeId::of::<T>())
diff --git a/crates/bevy_render/src/render_graph/nodes/shared_buffers_node.rs b/crates/bevy_render/src/render_graph/nodes/shared_buffers_node.rs
index 39144b22d744d..6106ef7261c89 100644
--- a/crates/bevy_render/src/render_graph/nodes/shared_buffers_node.rs
+++ b/crates/bevy_render/src/render_graph/nodes/shared_buffers_node.rs
@@ -2,21 +2,20 @@ use crate::{
     render_graph::{Node, ResourceSlots},
     renderer::{RenderContext, SharedBuffers},
 };
-use bevy_ecs::{Resources, World};
+use bevy_ecs::world::World;
 
-#[derive(Debug, Default)]
+#[derive(Default)]
 pub struct SharedBuffersNode;
 
 impl Node for SharedBuffersNode {
     fn update(
         &mut self,
-        _world: &World,
-        resources: &Resources,
+        world: &World,
         render_context: &mut dyn RenderContext,
         _input: &ResourceSlots,
         _output: &mut ResourceSlots,
     ) {
-        let mut shared_buffers = resources.get_mut::<SharedBuffers>().unwrap();
+        let shared_buffers = world.get_resource::<SharedBuffers>().unwrap();
         shared_buffers.apply(render_context);
     }
 }
diff --git a/crates/bevy_render/src/render_graph/nodes/texture_copy_node.rs b/crates/bevy_render/src/render_graph/nodes/texture_copy_node.rs
index fcb8bf801586a..ef9a6c1b7323d 100644
--- a/crates/bevy_render/src/render_graph/nodes/texture_copy_node.rs
+++ b/crates/bevy_render/src/render_graph/nodes/texture_copy_node.rs
@@ -5,7 +5,7 @@ use crate::{
 };
 use bevy_app::{prelude::Events, ManualEventReader};
 use bevy_asset::{AssetEvent, Assets};
-use bevy_ecs::{Resources, World};
+use bevy_ecs::world::World;
 use bevy_utils::HashSet;
 
 #[derive(Default)]
@@ -16,14 +16,13 @@ pub struct TextureCopyNode {
 impl Node for TextureCopyNode {
     fn update(
         &mut self,
-        _world: &World,
-        resources: &Resources,
+        world: &World,
         render_context: &mut dyn RenderContext,
         _input: &ResourceSlots,
         _output: &mut ResourceSlots,
     ) {
-        let texture_events = resources.get::<Events<AssetEvent<Texture>>>().unwrap();
-        let textures = resources.get::<Assets<Texture>>().unwrap();
+        let texture_events = world.get_resource::<Events<AssetEvent<Texture>>>().unwrap();
+        let textures = world.get_resource::<Assets<Texture>>().unwrap();
         let mut copied_textures = HashSet::default();
         for event in self.texture_event_reader.iter(&texture_events) {
             match event {
diff --git a/crates/bevy_render/src/render_graph/nodes/window_swapchain_node.rs b/crates/bevy_render/src/render_graph/nodes/window_swapchain_node.rs
index 189cbda2b5d58..40aa0f66401b0 100644
--- a/crates/bevy_render/src/render_graph/nodes/window_swapchain_node.rs
+++ b/crates/bevy_render/src/render_graph/nodes/window_swapchain_node.rs
@@ -3,7 +3,7 @@ use crate::{
     renderer::{RenderContext, RenderResourceId, RenderResourceType},
 };
 use bevy_app::{prelude::Events, ManualEventReader};
-use bevy_ecs::{Resources, World};
+use bevy_ecs::world::World;
 use bevy_window::{WindowCreated, WindowId, WindowResized, Windows};
 use std::borrow::Cow;
 
@@ -36,16 +36,15 @@ impl Node for WindowSwapChainNode {
 
     fn update(
         &mut self,
-        _world: &World,
-        resources: &Resources,
+        world: &World,
         render_context: &mut dyn RenderContext,
         _input: &ResourceSlots,
         output: &mut ResourceSlots,
     ) {
         const WINDOW_TEXTURE: usize = 0;
-        let window_created_events = resources.get::<Events<WindowCreated>>().unwrap();
-        let window_resized_events = resources.get::<Events<WindowResized>>().unwrap();
-        let windows = resources.get::<Windows>().unwrap();
+        let window_created_events = world.get_resource::<Events<WindowCreated>>().unwrap();
+        let window_resized_events = world.get_resource::<Events<WindowResized>>().unwrap();
+        let windows = world.get_resource::<Windows>().unwrap();
 
         let window = windows
             .get(self.window_id)
diff --git a/crates/bevy_render/src/render_graph/nodes/window_texture_node.rs b/crates/bevy_render/src/render_graph/nodes/window_texture_node.rs
index 782428190154f..6ce0afae27963 100644
--- a/crates/bevy_render/src/render_graph/nodes/window_texture_node.rs
+++ b/crates/bevy_render/src/render_graph/nodes/window_texture_node.rs
@@ -4,7 +4,7 @@ use crate::{
     texture::TextureDescriptor,
 };
 use bevy_app::{prelude::Events, ManualEventReader};
-use bevy_ecs::{Resources, World};
+use bevy_ecs::world::World;
 use bevy_window::{WindowCreated, WindowId, WindowResized, Windows};
 use std::borrow::Cow;
 
@@ -39,16 +39,15 @@ impl Node for WindowTextureNode {
 
     fn update(
         &mut self,
-        _world: &World,
-        resources: &Resources,
+        world: &World,
         render_context: &mut dyn RenderContext,
         _input: &ResourceSlots,
         output: &mut ResourceSlots,
     ) {
         const WINDOW_TEXTURE: usize = 0;
-        let window_created_events = resources.get::<Events<WindowCreated>>().unwrap();
-        let window_resized_events = resources.get::<Events<WindowResized>>().unwrap();
-        let windows = resources.get::<Windows>().unwrap();
+        let window_created_events = world.get_resource::<Events<WindowCreated>>().unwrap();
+        let window_resized_events = world.get_resource::<Events<WindowResized>>().unwrap();
+        let windows = world.get_resource::<Windows>().unwrap();
 
         let window = windows
             .get(self.window_id)
diff --git a/crates/bevy_render/src/render_graph/schedule.rs b/crates/bevy_render/src/render_graph/schedule.rs
index 23d70d2ec2e8a..b0ef997294767 100644
--- a/crates/bevy_render/src/render_graph/schedule.rs
+++ b/crates/bevy_render/src/render_graph/schedule.rs
@@ -267,7 +267,7 @@ mod tests {
         render_graph::{Node, NodeId, RenderGraph, ResourceSlotInfo, ResourceSlots},
         renderer::{RenderContext, RenderResourceType},
     };
-    use bevy_ecs::{Resources, World};
+    use bevy_ecs::world::World;
 
     struct TestNode {
         inputs: Vec<ResourceSlotInfo>,
@@ -305,7 +305,6 @@ mod tests {
         fn update(
             &mut self,
             _: &World,
-            _: &Resources,
             _: &mut dyn RenderContext,
             _: &ResourceSlots,
             _: &mut ResourceSlots,
diff --git a/crates/bevy_render/src/render_graph/system.rs b/crates/bevy_render/src/render_graph/system.rs
index abeac8b1d7e73..650e318c4ab59 100644
--- a/crates/bevy_render/src/render_graph/system.rs
+++ b/crates/bevy_render/src/render_graph/system.rs
@@ -1,18 +1,17 @@
 use super::RenderGraph;
-use bevy_ecs::{Resources, Stage, World};
+use bevy_ecs::{schedule::Stage, world::World};
 
-pub fn render_graph_schedule_executor_system(world: &mut World, resources: &mut Resources) {
+pub fn render_graph_schedule_executor_system(world: &mut World) {
     // run render graph systems
-    let (mut system_schedule, mut commands) = {
-        let mut render_graph = resources.get_mut::<RenderGraph>().unwrap();
-        (render_graph.take_schedule(), render_graph.take_commands())
+    let mut system_schedule = {
+        let mut render_graph = world.get_resource_mut::<RenderGraph>().unwrap();
+        render_graph.take_schedule()
     };
 
-    commands.apply(world, resources);
     if let Some(schedule) = system_schedule.as_mut() {
-        schedule.run(world, resources);
+        schedule.run(world);
     }
-    let mut render_graph = resources.get_mut::<RenderGraph>().unwrap();
+    let mut render_graph = world.get_resource_mut::<RenderGraph>().unwrap();
     if let Some(schedule) = system_schedule.take() {
         render_graph.set_schedule(schedule);
     }
diff --git a/crates/bevy_render/src/renderer/render_context.rs b/crates/bevy_render/src/renderer/render_context.rs
index b82149e54b6d4..4389f11c91e1a 100644
--- a/crates/bevy_render/src/renderer/render_context.rs
+++ b/crates/bevy_render/src/renderer/render_context.rs
@@ -53,6 +53,6 @@ pub trait RenderContext {
         &mut self,
         pass_descriptor: &PassDescriptor,
         render_resource_bindings: &RenderResourceBindings,
-        run_pass: &mut dyn Fn(&mut dyn RenderPass),
+        run_pass: &mut dyn FnMut(&mut dyn RenderPass),
     );
 }
diff --git a/crates/bevy_render/src/renderer/render_resource/shared_buffers.rs b/crates/bevy_render/src/renderer/render_resource/shared_buffers.rs
index 82dfc231bb800..1bfe06ff25f67 100644
--- a/crates/bevy_render/src/renderer/render_resource/shared_buffers.rs
+++ b/crates/bevy_render/src/renderer/render_resource/shared_buffers.rs
@@ -3,7 +3,7 @@ use crate::{
     render_graph::CommandQueue,
     renderer::{BufferMapMode, BufferUsage, RenderContext, RenderResourceContext},
 };
-use bevy_ecs::{Res, ResMut};
+use bevy_ecs::system::{Res, ResMut};
 
 pub struct SharedBuffers {
     staging_buffer: Option<BufferId>,
@@ -119,12 +119,15 @@ impl SharedBuffers {
         }
     }
 
-    pub fn apply(&mut self, render_context: &mut dyn RenderContext) {
+    pub fn apply(&self, render_context: &mut dyn RenderContext) {
         if let Some(staging_buffer) = self.staging_buffer {
             render_context.resources().unmap_buffer(staging_buffer);
         }
-        let mut command_queue = std::mem::take(&mut self.command_queue);
-        command_queue.execute(render_context);
+        self.command_queue.execute(render_context);
+    }
+
+    pub fn command_queue_mut(&mut self) -> &mut CommandQueue {
+        &mut self.command_queue
     }
 }
 
diff --git a/crates/bevy_render/src/shader/shader.rs b/crates/bevy_render/src/shader/shader.rs
index 7b6d686238aba..dc10ccff9514f 100644
--- a/crates/bevy_render/src/shader/shader.rs
+++ b/crates/bevy_render/src/shader/shader.rs
@@ -6,7 +6,7 @@ use crate::{
 use super::ShaderLayout;
 use bevy_app::EventReader;
 use bevy_asset::{AssetEvent, AssetLoader, Assets, Handle, LoadContext, LoadedAsset};
-use bevy_ecs::{Res, ResMut};
+use bevy_ecs::system::{Res, ResMut};
 use bevy_reflect::TypeUuid;
 use bevy_utils::{tracing::error, BoxedFuture};
 use std::marker::Copy;
diff --git a/crates/bevy_render/src/shader/shader_defs.rs b/crates/bevy_render/src/shader/shader_defs.rs
index 977872462732c..3076183c9df71 100644
--- a/crates/bevy_render/src/shader/shader_defs.rs
+++ b/crates/bevy_render/src/shader/shader_defs.rs
@@ -2,7 +2,7 @@ use bevy_asset::{Asset, Assets, Handle};
 
 use crate::{pipeline::RenderPipelines, Texture};
 pub use bevy_derive::ShaderDefs;
-use bevy_ecs::{Query, Res};
+use bevy_ecs::system::{Query, Res};
 
 /// Something that can either be "defined" or "not defined". This is used to determine if a "shader def" should be considered "defined"
 pub trait ShaderDef {
diff --git a/crates/bevy_render/src/texture/texture.rs b/crates/bevy_render/src/texture/texture.rs
index 20939fc068a2e..f7d6ea6ba2b2a 100644
--- a/crates/bevy_render/src/texture/texture.rs
+++ b/crates/bevy_render/src/texture/texture.rs
@@ -7,7 +7,7 @@ use crate::renderer::{
 };
 use bevy_app::prelude::EventReader;
 use bevy_asset::{AssetEvent, Assets, Handle};
-use bevy_ecs::Res;
+use bevy_ecs::system::Res;
 use bevy_reflect::TypeUuid;
 use bevy_utils::HashSet;
 use thiserror::Error;
diff --git a/crates/bevy_render/src/wireframe/mod.rs b/crates/bevy_render/src/wireframe/mod.rs
index 2194e56ed9544..4251fb44a8e5a 100644
--- a/crates/bevy_render/src/wireframe/mod.rs
+++ b/crates/bevy_render/src/wireframe/mod.rs
@@ -7,8 +7,13 @@ use crate::{
 };
 use bevy_app::prelude::*;
 use bevy_asset::{Assets, Handle, HandleUntyped};
-use bevy_ecs::{IntoSystem, Mut, Query, QuerySet, Res, With};
-use bevy_reflect::{Reflect, ReflectComponent, TypeUuid};
+use bevy_ecs::{
+    query::With,
+    reflect::ReflectComponent,
+    system::{IntoSystem, Query, QuerySet, Res},
+    world::Mut,
+};
+use bevy_reflect::{Reflect, TypeUuid};
 use bevy_utils::HashSet;
 
 mod pipeline;
@@ -23,9 +28,11 @@ impl Plugin for WireframePlugin {
     fn build(&self, app: &mut AppBuilder) {
         app.init_resource::<WireframeConfig>()
             .add_system_to_stage(crate::RenderStage::Draw, draw_wireframes_system.system());
-        let resources = app.resources();
-        let mut shaders = resources.get_mut::<Assets<Shader>>().unwrap();
-        let mut pipelines = resources.get_mut::<Assets<PipelineDescriptor>>().unwrap();
+        let world = app.world_mut().cell();
+        let mut shaders = world.get_resource_mut::<Assets<Shader>>().unwrap();
+        let mut pipelines = world
+            .get_resource_mut::<Assets<PipelineDescriptor>>()
+            .unwrap();
         pipelines.set(
             WIREFRAME_PIPELINE_HANDLE,
             pipeline::build_wireframe_pipeline(&mut shaders),
diff --git a/crates/bevy_scene/src/command.rs b/crates/bevy_scene/src/command.rs
index 54efbd552a12c..e92dcfd5145bb 100644
--- a/crates/bevy_scene/src/command.rs
+++ b/crates/bevy_scene/src/command.rs
@@ -1,5 +1,9 @@
 use bevy_asset::Handle;
-use bevy_ecs::{Command, Commands, Entity, Resources, World};
+use bevy_ecs::{
+    entity::Entity,
+    system::{Command, Commands},
+    world::World,
+};
 use bevy_transform::hierarchy::ChildBuilder;
 
 use crate::{Scene, SceneSpawner};
@@ -9,8 +13,8 @@ pub struct SpawnScene {
 }
 
 impl Command for SpawnScene {
-    fn write(self: Box<Self>, _world: &mut World, resources: &mut Resources) {
-        let mut spawner = resources.get_mut::<SceneSpawner>().unwrap();
+    fn write(self: Box<Self>, world: &mut World) {
+        let mut spawner = world.get_resource_mut::<SceneSpawner>().unwrap();
         spawner.spawn(self.scene_handle);
     }
 }
@@ -19,7 +23,7 @@ pub trait SpawnSceneCommands {
     fn spawn_scene(&mut self, scene: Handle<Scene>) -> &mut Self;
 }
 
-impl SpawnSceneCommands for Commands {
+impl<'a> SpawnSceneCommands for Commands<'a> {
     fn spawn_scene(&mut self, scene_handle: Handle<Scene>) -> &mut Self {
         self.add_command(SpawnScene { scene_handle })
     }
@@ -31,8 +35,8 @@ pub struct SpawnSceneAsChild {
 }
 
 impl Command for SpawnSceneAsChild {
-    fn write(self: Box<Self>, _world: &mut World, resources: &mut Resources) {
-        let mut spawner = resources.get_mut::<SceneSpawner>().unwrap();
+    fn write(self: Box<Self>, world: &mut World) {
+        let mut spawner = world.get_resource_mut::<SceneSpawner>().unwrap();
         spawner.spawn_as_child(self.scene_handle, self.parent);
     }
 }
@@ -41,7 +45,7 @@ pub trait SpawnSceneAsChildCommands {
     fn spawn_scene(&mut self, scene: Handle<Scene>) -> &mut Self;
 }
 
-impl<'a> SpawnSceneAsChildCommands for ChildBuilder<'a> {
+impl<'a, 'b> SpawnSceneAsChildCommands for ChildBuilder<'a, 'b> {
     fn spawn_scene(&mut self, scene_handle: Handle<Scene>) -> &mut Self {
         self.add_command(SpawnSceneAsChild {
             scene_handle,
diff --git a/crates/bevy_scene/src/dynamic_scene.rs b/crates/bevy_scene/src/dynamic_scene.rs
index da6b4915ba406..c77076171c8a4 100644
--- a/crates/bevy_scene/src/dynamic_scene.rs
+++ b/crates/bevy_scene/src/dynamic_scene.rs
@@ -1,15 +1,12 @@
-use crate::{serde::SceneSerializer, Scene};
+use crate::{serde::SceneSerializer, Scene, SceneSpawnError};
 use anyhow::Result;
-use bevy_ecs::{EntityMap, Resources, World};
-use bevy_reflect::{Reflect, ReflectComponent, ReflectMapEntities, TypeRegistryArc, TypeUuid};
+use bevy_ecs::{
+    entity::EntityMap,
+    reflect::{ReflectComponent, ReflectMapEntities},
+    world::World,
+};
+use bevy_reflect::{Reflect, TypeRegistryArc, TypeUuid};
 use serde::Serialize;
-use thiserror::Error;
-
-#[derive(Error, Debug)]
-pub enum DynamicSceneToWorldError {
-    #[error("scene contains an unregistered component")]
-    UnregisteredComponent { type_name: String },
-}
 
 #[derive(Default, TypeUuid)]
 #[uuid = "749479b1-fb8c-4ff8-a775-623aa76014f5"]
@@ -30,30 +27,32 @@ impl DynamicScene {
     pub fn from_world(world: &World, type_registry: &TypeRegistryArc) -> Self {
         let mut scene = DynamicScene::default();
         let type_registry = type_registry.read();
-        for archetype in world.archetypes() {
-            let mut entities = Vec::new();
-            for (index, entity) in archetype.iter_entities().enumerate() {
-                if index == entities.len() {
-                    entities.push(Entity {
-                        entity: entity.id(),
-                        components: Vec::new(),
-                    })
-                }
-                for type_info in archetype.types() {
-                    if let Some(registration) = type_registry.get(type_info.id()) {
-                        if let Some(reflect_component) = registration.data::<ReflectComponent>() {
-                            // SAFE: the index comes directly from a currently live component
-                            unsafe {
-                                let component =
-                                    reflect_component.reflect_component(&archetype, index);
-                                entities[index].components.push(component.clone_value());
-                            }
+        for archetype in world.archetypes().iter() {
+            let entities_offset = scene.entities.len();
+            for entity in archetype.entities() {
+                scene.entities.push(Entity {
+                    entity: entity.id(),
+                    components: Vec::new(),
+                });
+            }
+
+            for component_id in archetype.components() {
+                let reflect_component = world
+                    .components()
+                    .get_info(component_id)
+                    .and_then(|info| type_registry.get(info.type_id().unwrap()))
+                    .and_then(|registration| registration.data::<ReflectComponent>());
+                if let Some(reflect_component) = reflect_component {
+                    for (i, entity) in archetype.entities().iter().enumerate() {
+                        if let Some(component) = reflect_component.reflect_component(world, *entity)
+                        {
+                            scene.entities[entities_offset + i]
+                                .components
+                                .push(component.clone_value());
                         }
                     }
                 }
             }
-
-            scene.entities.extend(entities.drain(..));
         }
 
         scene
@@ -62,30 +61,33 @@ impl DynamicScene {
     pub fn write_to_world(
         &self,
         world: &mut World,
-        resources: &Resources,
-    ) -> Result<(), DynamicSceneToWorldError> {
-        let type_registry = resources.get::<TypeRegistryArc>().unwrap();
-        let type_registry = type_registry.read();
-        let mut entity_map = EntityMap::default();
+        entity_map: &mut EntityMap,
+    ) -> Result<(), SceneSpawnError> {
+        let registry = world.get_resource::<TypeRegistryArc>().unwrap().clone();
+        let type_registry = registry.read();
         for scene_entity in self.entities.iter() {
-            let new_entity = world.reserve_entity();
-            entity_map.insert(bevy_ecs::Entity::new(scene_entity.entity), new_entity);
+            let entity = *entity_map
+                .entry(bevy_ecs::entity::Entity::new(scene_entity.entity))
+                .or_insert_with(|| world.spawn().id());
             for component in scene_entity.components.iter() {
                 let registration = type_registry
                     .get_with_name(component.type_name())
-                    .ok_or_else(|| DynamicSceneToWorldError::UnregisteredComponent {
+                    .ok_or_else(|| SceneSpawnError::UnregisteredComponent {
                         type_name: component.type_name().to_string(),
                     })?;
                 let reflect_component =
                     registration.data::<ReflectComponent>().ok_or_else(|| {
-                        DynamicSceneToWorldError::UnregisteredComponent {
+                        SceneSpawnError::UnregisteredComponent {
                             type_name: component.type_name().to_string(),
                         }
                     })?;
-                if world.has_component_type(new_entity, registration.type_id()) {
-                    reflect_component.apply_component(world, new_entity, &**component);
+                if world
+                    .entity(entity)
+                    .contains_type_id(registration.type_id())
+                {
+                    reflect_component.apply_component(world, entity, &**component);
                 } else {
-                    reflect_component.add_component(world, resources, new_entity, &**component);
+                    reflect_component.add_component(world, entity, &**component);
                 }
             }
         }
@@ -105,12 +107,6 @@ impl DynamicScene {
     pub fn serialize_ron(&self, registry: &TypeRegistryArc) -> Result<String, ron::Error> {
         serialize_ron(SceneSerializer::new(self, registry))
     }
-
-    pub fn get_scene(&self, resources: &Resources) -> Result<Scene, DynamicSceneToWorldError> {
-        let mut world = World::default();
-        self.write_to_world(&mut world, resources)?;
-        Ok(Scene::new(world))
-    }
 }
 
 pub fn serialize_ron<S>(serialize: S) -> Result<String, ron::Error>
diff --git a/crates/bevy_scene/src/lib.rs b/crates/bevy_scene/src/lib.rs
index b6e6ffdd5f770..2c816227792ba 100644
--- a/crates/bevy_scene/src/lib.rs
+++ b/crates/bevy_scene/src/lib.rs
@@ -19,7 +19,10 @@ pub mod prelude {
 
 use bevy_app::prelude::*;
 use bevy_asset::AddAsset;
-use bevy_ecs::{IntoExclusiveSystem, StageLabel, SystemStage};
+use bevy_ecs::{
+    schedule::{StageLabel, SystemStage},
+    system::IntoExclusiveSystem,
+};
 
 #[derive(Default)]
 pub struct ScenePlugin;
diff --git a/crates/bevy_scene/src/scene.rs b/crates/bevy_scene/src/scene.rs
index 028ba75ad71fa..0a8bd50b82492 100644
--- a/crates/bevy_scene/src/scene.rs
+++ b/crates/bevy_scene/src/scene.rs
@@ -1,4 +1,4 @@
-use bevy_ecs::World;
+use bevy_ecs::world::World;
 use bevy_reflect::TypeUuid;
 
 #[derive(Debug, TypeUuid)]
diff --git a/crates/bevy_scene/src/scene_loader.rs b/crates/bevy_scene/src/scene_loader.rs
index 78f2942bd4fb6..72e5741cc113b 100644
--- a/crates/bevy_scene/src/scene_loader.rs
+++ b/crates/bevy_scene/src/scene_loader.rs
@@ -1,7 +1,7 @@
 use crate::serde::SceneDeserializer;
 use anyhow::Result;
 use bevy_asset::{AssetLoader, LoadContext, LoadedAsset};
-use bevy_ecs::{FromResources, Resources};
+use bevy_ecs::world::{FromWorld, World};
 use bevy_reflect::TypeRegistryArc;
 use bevy_utils::BoxedFuture;
 use serde::de::DeserializeSeed;
@@ -11,9 +11,9 @@ pub struct SceneLoader {
     type_registry: TypeRegistryArc,
 }
 
-impl FromResources for SceneLoader {
-    fn from_resources(resources: &Resources) -> Self {
-        let type_registry = resources.get::<TypeRegistryArc>().unwrap();
+impl FromWorld for SceneLoader {
+    fn from_world(world: &mut World) -> Self {
+        let type_registry = world.get_resource::<TypeRegistryArc>().unwrap();
         SceneLoader {
             type_registry: (&*type_registry).clone(),
         }
diff --git a/crates/bevy_scene/src/scene_spawner.rs b/crates/bevy_scene/src/scene_spawner.rs
index f3b47101092dc..a87ff130d35d1 100644
--- a/crates/bevy_scene/src/scene_spawner.rs
+++ b/crates/bevy_scene/src/scene_spawner.rs
@@ -1,10 +1,14 @@
 use crate::{DynamicScene, Scene};
 use bevy_app::{prelude::*, ManualEventReader};
 use bevy_asset::{AssetEvent, Assets, Handle};
-use bevy_ecs::{Entity, EntityMap, Resources, World};
-use bevy_reflect::{ReflectComponent, ReflectMapEntities, TypeRegistryArc};
+use bevy_ecs::{
+    entity::{Entity, EntityMap},
+    reflect::{ReflectComponent, ReflectMapEntities},
+    world::{Mut, World},
+};
+use bevy_reflect::TypeRegistryArc;
 use bevy_transform::prelude::Parent;
-use bevy_utils::HashMap;
+use bevy_utils::{tracing::error, HashMap};
 use thiserror::Error;
 use uuid::Uuid;
 
@@ -90,15 +94,13 @@ impl SceneSpawner {
     pub fn spawn_dynamic_sync(
         &mut self,
         world: &mut World,
-        resources: &Resources,
         scene_handle: &Handle<DynamicScene>,
     ) -> Result<(), SceneSpawnError> {
+        let mut entity_map = EntityMap::default();
+        Self::spawn_dynamic_internal(world, scene_handle, &mut entity_map)?;
         let instance_id = InstanceId::new();
-        let mut instance_info = InstanceInfo {
-            entity_map: EntityMap::default(),
-        };
-        Self::spawn_dynamic_internal(world, resources, scene_handle, &mut instance_info)?;
-        self.spawned_instances.insert(instance_id, instance_info);
+        self.spawned_instances
+            .insert(instance_id, InstanceInfo { entity_map });
         let spawned = self
             .spawned_dynamic_scenes
             .entry(scene_handle.clone())
@@ -109,126 +111,95 @@ impl SceneSpawner {
 
     fn spawn_dynamic_internal(
         world: &mut World,
-        resources: &Resources,
         scene_handle: &Handle<DynamicScene>,
-        instance_info: &mut InstanceInfo,
+        entity_map: &mut EntityMap,
     ) -> Result<(), SceneSpawnError> {
-        let type_registry = resources.get::<TypeRegistryArc>().unwrap();
-        let type_registry = type_registry.read();
-        let scenes = resources.get::<Assets<DynamicScene>>().unwrap();
-        let scene = scenes
-            .get(scene_handle)
-            .ok_or_else(|| SceneSpawnError::NonExistentScene {
-                handle: scene_handle.clone_weak(),
-            })?;
-
-        for scene_entity in scene.entities.iter() {
-            let entity = *instance_info
-                .entity_map
-                // TODO: use Entity type directly in scenes to properly encode generation / avoid the need to patch things up?
-                .entry(bevy_ecs::Entity::new(scene_entity.entity))
-                .or_insert_with(|| world.reserve_entity());
-            for component in scene_entity.components.iter() {
-                let registration = type_registry
-                    .get_with_name(component.type_name())
-                    .ok_or_else(|| SceneSpawnError::UnregisteredType {
-                        type_name: component.type_name().to_string(),
-                    })?;
-                let reflect_component =
-                    registration.data::<ReflectComponent>().ok_or_else(|| {
-                        SceneSpawnError::UnregisteredComponent {
-                            type_name: component.type_name().to_string(),
-                        }
+        world.resource_scope(|scenes: Mut<Assets<DynamicScene>>, world| {
+            let scene =
+                scenes
+                    .get(scene_handle)
+                    .ok_or_else(|| SceneSpawnError::NonExistentScene {
+                        handle: scene_handle.clone_weak(),
                     })?;
-                if world.has_component_type(entity, registration.type_id()) {
-                    if registration.short_name() != "Camera" {
-                        reflect_component.apply_component(world, entity, &**component);
-                    }
-                } else {
-                    reflect_component.add_component(world, resources, entity, &**component);
-                }
-            }
-        }
-        Ok(())
+            scene.write_to_world(world, entity_map)
+        })
     }
 
     pub fn spawn_sync(
         &mut self,
         world: &mut World,
-        resources: &Resources,
         scene_handle: Handle<Scene>,
     ) -> Result<InstanceId, SceneSpawnError> {
-        self.spawn_sync_internal(world, resources, scene_handle, InstanceId::new())
+        self.spawn_sync_internal(world, scene_handle, InstanceId::new())
     }
 
     fn spawn_sync_internal(
         &mut self,
         world: &mut World,
-        resources: &Resources,
         scene_handle: Handle<Scene>,
         instance_id: InstanceId,
     ) -> Result<InstanceId, SceneSpawnError> {
         let mut instance_info = InstanceInfo {
             entity_map: EntityMap::default(),
         };
-        let type_registry = resources.get::<TypeRegistryArc>().unwrap();
+        let type_registry = world.get_resource::<TypeRegistryArc>().unwrap().clone();
         let type_registry = type_registry.read();
-        let scenes = resources.get::<Assets<Scene>>().unwrap();
-        let scene =
-            scenes
-                .get(&scene_handle)
-                .ok_or_else(|| SceneSpawnError::NonExistentRealScene {
-                    handle: scene_handle.clone(),
-                })?;
-
-        for archetype in scene.world.archetypes() {
-            for scene_entity in archetype.iter_entities() {
-                let entity = *instance_info
-                    .entity_map
-                    .entry(*scene_entity)
-                    .or_insert_with(|| world.reserve_entity());
-                for type_info in archetype.types() {
-                    let registration = type_registry.get(type_info.id()).ok_or_else(|| {
-                        SceneSpawnError::UnregisteredType {
-                            type_name: type_info.type_name().to_string(),
-                        }
+        world.resource_scope(|scenes: Mut<Assets<Scene>>, world| {
+            let scene =
+                scenes
+                    .get(&scene_handle)
+                    .ok_or_else(|| SceneSpawnError::NonExistentRealScene {
+                        handle: scene_handle.clone(),
                     })?;
-                    let reflect_component =
-                        registration.data::<ReflectComponent>().ok_or_else(|| {
-                            SceneSpawnError::UnregisteredComponent {
-                                type_name: registration.name().to_string(),
-                            }
-                        })?;
-                    reflect_component.copy_component(
-                        &scene.world,
-                        world,
-                        resources,
-                        *scene_entity,
-                        entity,
-                    );
+
+            for archetype in scene.world.archetypes().iter() {
+                for scene_entity in archetype.entities() {
+                    let entity = *instance_info
+                        .entity_map
+                        .entry(*scene_entity)
+                        .or_insert_with(|| world.spawn().id());
+                    for component_id in archetype.components() {
+                        let component_info = scene
+                            .world
+                            .components()
+                            .get_info(component_id)
+                            .expect("component_ids in archetypes should have ComponentInfo");
+
+                        let reflect_component = type_registry
+                            .get(component_info.type_id().unwrap())
+                            .and_then(|registration| registration.data::<ReflectComponent>())
+                            .ok_or_else(|| SceneSpawnError::UnregisteredComponent {
+                                type_name: component_info.name().to_string(),
+                            })?;
+                        reflect_component.copy_component(
+                            &scene.world,
+                            world,
+                            *scene_entity,
+                            entity,
+                        );
+                    }
                 }
             }
-        }
-        for registration in type_registry.iter() {
-            if let Some(map_entities_reflect) = registration.data::<ReflectMapEntities>() {
-                map_entities_reflect
-                    .map_entities(world, &instance_info.entity_map)
-                    .unwrap();
+            for registration in type_registry.iter() {
+                if let Some(map_entities_reflect) = registration.data::<ReflectMapEntities>() {
+                    map_entities_reflect
+                        .map_entities(world, &instance_info.entity_map)
+                        .unwrap();
+                }
             }
-        }
-        self.spawned_instances.insert(instance_id, instance_info);
-        let spawned = self
-            .spawned_scenes
-            .entry(scene_handle)
-            .or_insert_with(Vec::new);
-        spawned.push(instance_id);
-        Ok(instance_id)
+            self.spawned_instances.insert(instance_id, instance_info);
+            let spawned = self
+                .spawned_scenes
+                .entry(scene_handle)
+                .or_insert_with(Vec::new);
+            spawned.push(instance_id);
+            Ok(instance_id)
+        })
     }
 
     pub fn update_spawned_scenes(
         &mut self,
         world: &mut World,
-        resources: &Resources,
         scene_handles: &[Handle<DynamicScene>],
     ) -> Result<(), SceneSpawnError> {
         for scene_handle in scene_handles {
@@ -237,9 +208,8 @@ impl SceneSpawner {
                     if let Some(instance_info) = self.spawned_instances.get_mut(instance_id) {
                         Self::spawn_dynamic_internal(
                             world,
-                            resources,
                             scene_handle,
-                            instance_info,
+                            &mut instance_info.entity_map,
                         )?;
                     }
                 }
@@ -257,15 +227,11 @@ impl SceneSpawner {
         Ok(())
     }
 
-    pub fn spawn_queued_scenes(
-        &mut self,
-        world: &mut World,
-        resources: &Resources,
-    ) -> Result<(), SceneSpawnError> {
+    pub fn spawn_queued_scenes(&mut self, world: &mut World) -> Result<(), SceneSpawnError> {
         let scenes_to_spawn = std::mem::take(&mut self.dynamic_scenes_to_spawn);
 
         for scene_handle in scenes_to_spawn {
-            match self.spawn_dynamic_sync(world, resources, &scene_handle) {
+            match self.spawn_dynamic_sync(world, &scene_handle) {
                 Ok(_) => {}
                 Err(SceneSpawnError::NonExistentScene { .. }) => {
                     self.dynamic_scenes_to_spawn.push(scene_handle)
@@ -277,7 +243,7 @@ impl SceneSpawner {
         let scenes_to_spawn = std::mem::take(&mut self.scenes_to_spawn);
 
         for (scene_handle, instance_id) in scenes_to_spawn {
-            match self.spawn_sync_internal(world, resources, scene_handle, instance_id) {
+            match self.spawn_sync_internal(world, scene_handle, instance_id) {
                 Ok(_) => {}
                 Err(SceneSpawnError::NonExistentRealScene { handle }) => {
                     self.scenes_to_spawn.push((handle, instance_id))
@@ -295,10 +261,10 @@ impl SceneSpawner {
         for (instance_id, parent) in scenes_with_parent {
             if let Some(instance) = self.spawned_instances.get(&instance_id) {
                 for entity in instance.entity_map.values() {
-                    if let Err(bevy_ecs::ComponentError::MissingComponent(_)) =
-                        world.get::<Parent>(entity)
-                    {
-                        let _ = world.insert_one(entity, Parent(parent));
+                    if let Some(mut entity_mut) = world.get_entity_mut(entity) {
+                        if !entity_mut.contains::<Parent>() {
+                            entity_mut.insert(Parent(parent));
+                        }
                     }
                 }
             } else {
@@ -323,28 +289,31 @@ impl SceneSpawner {
     }
 }
 
-pub fn scene_spawner_system(world: &mut World, resources: &mut Resources) {
-    let mut scene_spawner = resources.get_mut::<SceneSpawner>().unwrap();
-    let scene_asset_events = resources.get::<Events<AssetEvent<DynamicScene>>>().unwrap();
-
-    let mut updated_spawned_scenes = Vec::new();
-    for event in scene_spawner
-        .scene_asset_event_reader
-        .iter(&scene_asset_events)
-    {
-        if let AssetEvent::Modified { handle } = event {
-            if scene_spawner.spawned_dynamic_scenes.contains_key(handle) {
-                updated_spawned_scenes.push(handle.clone_weak());
+pub fn scene_spawner_system(world: &mut World) {
+    world.resource_scope(|mut scene_spawner: Mut<SceneSpawner>, world| {
+        let scene_asset_events = world
+            .get_resource::<Events<AssetEvent<DynamicScene>>>()
+            .unwrap();
+
+        let mut updated_spawned_scenes = Vec::new();
+        for event in scene_spawner
+            .scene_asset_event_reader
+            .iter(&scene_asset_events)
+        {
+            if let AssetEvent::Modified { handle } = event {
+                if scene_spawner.spawned_dynamic_scenes.contains_key(handle) {
+                    updated_spawned_scenes.push(handle.clone_weak());
+                }
             }
         }
-    }
 
-    scene_spawner.despawn_queued_scenes(world).unwrap();
-    scene_spawner
-        .spawn_queued_scenes(world, resources)
-        .unwrap_or_else(|err| panic!("{}", err));
-    scene_spawner
-        .update_spawned_scenes(world, resources, &updated_spawned_scenes)
-        .unwrap();
-    scene_spawner.set_scene_instance_parent_sync(world);
+        scene_spawner.despawn_queued_scenes(world).unwrap();
+        scene_spawner
+            .spawn_queued_scenes(world)
+            .unwrap_or_else(|err| panic!("{}", err));
+        scene_spawner
+            .update_spawned_scenes(world, &updated_spawned_scenes)
+            .unwrap();
+        scene_spawner.set_scene_instance_parent_sync(world);
+    });
 }
diff --git a/crates/bevy_sprite/src/entity.rs b/crates/bevy_sprite/src/entity.rs
index ca5bb47853cd9..70fd8d5699640 100644
--- a/crates/bevy_sprite/src/entity.rs
+++ b/crates/bevy_sprite/src/entity.rs
@@ -3,7 +3,7 @@ use crate::{
     TextureAtlasSprite, QUAD_HANDLE, SPRITE_SHEET_PIPELINE_HANDLE,
 };
 use bevy_asset::Handle;
-use bevy_ecs::Bundle;
+use bevy_ecs::bundle::Bundle;
 use bevy_render::{
     mesh::Mesh,
     pipeline::{RenderPipeline, RenderPipelines},
diff --git a/crates/bevy_sprite/src/lib.rs b/crates/bevy_sprite/src/lib.rs
index e0ea01cb2a1f3..3853604b71f5b 100644
--- a/crates/bevy_sprite/src/lib.rs
+++ b/crates/bevy_sprite/src/lib.rs
@@ -26,13 +26,14 @@ pub use texture_atlas_builder::*;
 
 use bevy_app::prelude::*;
 use bevy_asset::{AddAsset, Assets, Handle, HandleUntyped};
-use bevy_ecs::IntoSystem;
+use bevy_ecs::system::IntoSystem;
 use bevy_math::Vec2;
-use bevy_reflect::{RegisterTypeBuilder, TypeUuid};
+use bevy_reflect::TypeUuid;
 use bevy_render::{
     mesh::{shape, Mesh},
+    pipeline::PipelineDescriptor,
     render_graph::RenderGraph,
-    shader::asset_shader_defs_system,
+    shader::{asset_shader_defs_system, Shader},
 };
 use sprite::sprite_system;
 
@@ -53,13 +54,16 @@ impl Plugin for SpritePlugin {
                 asset_shader_defs_system::<ColorMaterial>.system(),
             );
 
-        let resources = app.resources_mut();
-        let mut render_graph = resources.get_mut::<RenderGraph>().unwrap();
-        render_graph.add_sprite_graph(resources);
+        let world = app.world_mut().cell();
+        let mut render_graph = world.get_resource_mut::<RenderGraph>().unwrap();
+        let mut pipelines = world
+            .get_resource_mut::<Assets<PipelineDescriptor>>()
+            .unwrap();
+        let mut shaders = world.get_resource_mut::<Assets<Shader>>().unwrap();
+        crate::render::add_sprite_graph(&mut render_graph, &mut pipelines, &mut shaders);
 
-        let mut meshes = resources.get_mut::<Assets<Mesh>>().unwrap();
-
-        let mut color_materials = resources.get_mut::<Assets<ColorMaterial>>().unwrap();
+        let mut meshes = world.get_resource_mut::<Assets<Mesh>>().unwrap();
+        let mut color_materials = world.get_resource_mut::<Assets<ColorMaterial>>().unwrap();
         color_materials.set_untracked(Handle::<ColorMaterial>::default(), ColorMaterial::default());
         meshes.set_untracked(
             QUAD_HANDLE,
diff --git a/crates/bevy_sprite/src/render/mod.rs b/crates/bevy_sprite/src/render/mod.rs
index f0a73d804e883..20e508b177e5b 100644
--- a/crates/bevy_sprite/src/render/mod.rs
+++ b/crates/bevy_sprite/src/render/mod.rs
@@ -1,6 +1,5 @@
 use crate::{ColorMaterial, Sprite, TextureAtlas, TextureAtlasSprite};
 use bevy_asset::{Assets, HandleUntyped};
-use bevy_ecs::Resources;
 use bevy_reflect::TypeUuid;
 use bevy_render::{
     pipeline::{
@@ -132,40 +131,37 @@ pub mod node {
     pub const SPRITE_SHEET_SPRITE: &str = "sprite_sheet_sprite";
 }
 
-pub trait SpriteRenderGraphBuilder {
-    fn add_sprite_graph(&mut self, resources: &Resources) -> &mut Self;
-}
-
-impl SpriteRenderGraphBuilder for RenderGraph {
-    fn add_sprite_graph(&mut self, resources: &Resources) -> &mut Self {
-        self.add_system_node(
-            node::COLOR_MATERIAL,
-            AssetRenderResourcesNode::<ColorMaterial>::new(false),
-        );
-        self.add_node_edge(node::COLOR_MATERIAL, base::node::MAIN_PASS)
-            .unwrap();
+pub(crate) fn add_sprite_graph(
+    graph: &mut RenderGraph,
+    pipelines: &mut Assets<PipelineDescriptor>,
+    shaders: &mut Assets<Shader>,
+) {
+    graph.add_system_node(
+        node::COLOR_MATERIAL,
+        AssetRenderResourcesNode::<ColorMaterial>::new(false),
+    );
+    graph
+        .add_node_edge(node::COLOR_MATERIAL, base::node::MAIN_PASS)
+        .unwrap();
 
-        self.add_system_node(node::SPRITE, RenderResourcesNode::<Sprite>::new(true));
-        self.add_node_edge(node::SPRITE, base::node::MAIN_PASS)
-            .unwrap();
+    graph.add_system_node(node::SPRITE, RenderResourcesNode::<Sprite>::new(true));
+    graph
+        .add_node_edge(node::SPRITE, base::node::MAIN_PASS)
+        .unwrap();
 
-        self.add_system_node(
-            node::SPRITE_SHEET,
-            AssetRenderResourcesNode::<TextureAtlas>::new(false),
-        );
+    graph.add_system_node(
+        node::SPRITE_SHEET,
+        AssetRenderResourcesNode::<TextureAtlas>::new(false),
+    );
 
-        self.add_system_node(
-            node::SPRITE_SHEET_SPRITE,
-            RenderResourcesNode::<TextureAtlasSprite>::new(true),
-        );
+    graph.add_system_node(
+        node::SPRITE_SHEET_SPRITE,
+        RenderResourcesNode::<TextureAtlasSprite>::new(true),
+    );
 
-        let mut pipelines = resources.get_mut::<Assets<PipelineDescriptor>>().unwrap();
-        let mut shaders = resources.get_mut::<Assets<Shader>>().unwrap();
-        pipelines.set_untracked(SPRITE_PIPELINE_HANDLE, build_sprite_pipeline(&mut shaders));
-        pipelines.set_untracked(
-            SPRITE_SHEET_PIPELINE_HANDLE,
-            build_sprite_sheet_pipeline(&mut shaders),
-        );
-        self
-    }
+    pipelines.set_untracked(SPRITE_PIPELINE_HANDLE, build_sprite_pipeline(shaders));
+    pipelines.set_untracked(
+        SPRITE_SHEET_PIPELINE_HANDLE,
+        build_sprite_sheet_pipeline(shaders),
+    );
 }
diff --git a/crates/bevy_sprite/src/sprite.rs b/crates/bevy_sprite/src/sprite.rs
index ceffd986e2f39..794efd4e2c3ba 100644
--- a/crates/bevy_sprite/src/sprite.rs
+++ b/crates/bevy_sprite/src/sprite.rs
@@ -1,7 +1,7 @@
 use crate::ColorMaterial;
 use bevy_asset::{Assets, Handle};
 use bevy_core::Bytes;
-use bevy_ecs::{Query, Res};
+use bevy_ecs::system::{Query, Res};
 use bevy_math::Vec2;
 use bevy_reflect::{Reflect, ReflectDeserialize, TypeUuid};
 use bevy_render::{
diff --git a/crates/bevy_text/src/lib.rs b/crates/bevy_text/src/lib.rs
index 166c80e1c7849..a9ffce5f6ddbf 100644
--- a/crates/bevy_text/src/lib.rs
+++ b/crates/bevy_text/src/lib.rs
@@ -27,7 +27,7 @@ pub mod prelude {
 
 use bevy_app::prelude::*;
 use bevy_asset::AddAsset;
-use bevy_ecs::{Entity, IntoSystem};
+use bevy_ecs::{entity::Entity, system::IntoSystem};
 use bevy_render::RenderStage;
 
 pub type DefaultTextPipeline = TextPipeline<Entity>;
diff --git a/crates/bevy_text/src/text2d.rs b/crates/bevy_text/src/text2d.rs
index 52b146b843078..5c9112181f5e3 100644
--- a/crates/bevy_text/src/text2d.rs
+++ b/crates/bevy_text/src/text2d.rs
@@ -1,5 +1,10 @@
 use bevy_asset::Assets;
-use bevy_ecs::{Bundle, Changed, Entity, Local, Query, QuerySet, Res, ResMut, With};
+use bevy_ecs::{
+    bundle::Bundle,
+    entity::Entity,
+    query::{Changed, With},
+    system::{Local, Query, QuerySet, Res, ResMut},
+};
 use bevy_math::{Size, Vec3};
 use bevy_render::{
     draw::{DrawContext, Drawable},
diff --git a/crates/bevy_transform/src/components/children.rs b/crates/bevy_transform/src/components/children.rs
index e3a0c380f68a5..c1bc5c317718d 100644
--- a/crates/bevy_transform/src/components/children.rs
+++ b/crates/bevy_transform/src/components/children.rs
@@ -1,5 +1,8 @@
-use bevy_ecs::{Entity, MapEntities};
-use bevy_reflect::{Reflect, ReflectComponent, ReflectMapEntities};
+use bevy_ecs::{
+    entity::{Entity, EntityMap, MapEntities, MapEntitiesError},
+    reflect::{ReflectComponent, ReflectMapEntities},
+};
+use bevy_reflect::Reflect;
 use smallvec::SmallVec;
 use std::ops::Deref;
 
@@ -8,10 +11,7 @@ use std::ops::Deref;
 pub struct Children(pub(crate) SmallVec<[Entity; 8]>);
 
 impl MapEntities for Children {
-    fn map_entities(
-        &mut self,
-        entity_map: &bevy_ecs::EntityMap,
-    ) -> Result<(), bevy_ecs::MapEntitiesError> {
+    fn map_entities(&mut self, entity_map: &EntityMap) -> Result<(), MapEntitiesError> {
         for entity in self.0.iter_mut() {
             *entity = entity_map.get(*entity)?;
         }
diff --git a/crates/bevy_transform/src/components/global_transform.rs b/crates/bevy_transform/src/components/global_transform.rs
index bb0d5b6105614..b232b45f4e5a6 100644
--- a/crates/bevy_transform/src/components/global_transform.rs
+++ b/crates/bevy_transform/src/components/global_transform.rs
@@ -1,6 +1,7 @@
 use super::Transform;
+use bevy_ecs::reflect::ReflectComponent;
 use bevy_math::{Mat3, Mat4, Quat, Vec3};
-use bevy_reflect::{Reflect, ReflectComponent};
+use bevy_reflect::Reflect;
 use std::ops::Mul;
 
 #[derive(Debug, PartialEq, Clone, Copy, Reflect)]
diff --git a/crates/bevy_transform/src/components/parent.rs b/crates/bevy_transform/src/components/parent.rs
index 3379988de426e..2018ef70381dc 100644
--- a/crates/bevy_transform/src/components/parent.rs
+++ b/crates/bevy_transform/src/components/parent.rs
@@ -1,26 +1,27 @@
-use bevy_ecs::{Entity, FromResources, MapEntities};
-use bevy_reflect::{Reflect, ReflectComponent, ReflectMapEntities};
+use bevy_ecs::{
+    entity::{Entity, EntityMap, MapEntities, MapEntitiesError},
+    reflect::{ReflectComponent, ReflectMapEntities},
+    world::{FromWorld, World},
+};
+use bevy_reflect::Reflect;
 use std::ops::{Deref, DerefMut};
 
 #[derive(Debug, Copy, Clone, Eq, PartialEq, Reflect)]
 #[reflect(Component, MapEntities)]
 pub struct Parent(pub Entity);
 
-// TODO: We need to impl either FromResources or Default so Parent can be registered as Properties.
+// TODO: We need to impl either FromWorld or Default so Parent can be registered as Properties.
 // This is because Properties deserialize by creating an instance and apply a patch on top.
 // However Parent should only ever be set with a real user-defined entity.  Its worth looking into better
 // ways to handle cases like this.
-impl FromResources for Parent {
-    fn from_resources(_resources: &bevy_ecs::Resources) -> Self {
+impl FromWorld for Parent {
+    fn from_world(_world: &mut World) -> Self {
         Parent(Entity::new(u32::MAX))
     }
 }
 
 impl MapEntities for Parent {
-    fn map_entities(
-        &mut self,
-        entity_map: &bevy_ecs::EntityMap,
-    ) -> Result<(), bevy_ecs::MapEntitiesError> {
+    fn map_entities(&mut self, entity_map: &EntityMap) -> Result<(), MapEntitiesError> {
         self.0 = entity_map.get(self.0)?;
         Ok(())
     }
@@ -45,18 +46,15 @@ impl DerefMut for Parent {
 pub struct PreviousParent(pub(crate) Entity);
 
 impl MapEntities for PreviousParent {
-    fn map_entities(
-        &mut self,
-        entity_map: &bevy_ecs::EntityMap,
-    ) -> Result<(), bevy_ecs::MapEntitiesError> {
+    fn map_entities(&mut self, entity_map: &EntityMap) -> Result<(), MapEntitiesError> {
         self.0 = entity_map.get(self.0)?;
         Ok(())
     }
 }
 
 // TODO: Better handle this case see `impl FromResources for Parent`
-impl FromResources for PreviousParent {
-    fn from_resources(_resources: &bevy_ecs::Resources) -> Self {
+impl FromWorld for PreviousParent {
+    fn from_world(_world: &mut World) -> Self {
         PreviousParent(Entity::new(u32::MAX))
     }
 }
diff --git a/crates/bevy_transform/src/components/transform.rs b/crates/bevy_transform/src/components/transform.rs
index d09c0bd247c82..731ef35cacafa 100644
--- a/crates/bevy_transform/src/components/transform.rs
+++ b/crates/bevy_transform/src/components/transform.rs
@@ -1,6 +1,7 @@
 use super::GlobalTransform;
+use bevy_ecs::reflect::ReflectComponent;
 use bevy_math::{Mat3, Mat4, Quat, Vec3};
-use bevy_reflect::{Reflect, ReflectComponent};
+use bevy_reflect::Reflect;
 use std::ops::Mul;
 
 #[derive(Debug, PartialEq, Clone, Copy, Reflect)]
diff --git a/crates/bevy_transform/src/hierarchy/child_builder.rs b/crates/bevy_transform/src/hierarchy/child_builder.rs
index ab1ce6216de35..8298049dc65b7 100644
--- a/crates/bevy_transform/src/hierarchy/child_builder.rs
+++ b/crates/bevy_transform/src/hierarchy/child_builder.rs
@@ -1,5 +1,11 @@
 use crate::prelude::{Children, Parent, PreviousParent};
-use bevy_ecs::{Command, Commands, Component, DynamicBundle, Entity, Resources, World};
+use bevy_ecs::{
+    bundle::Bundle,
+    component::Component,
+    entity::Entity,
+    system::{Command, Commands},
+    world::{EntityMut, World},
+};
 use smallvec::SmallVec;
 
 #[derive(Debug)]
@@ -10,15 +16,15 @@ pub struct InsertChildren {
 }
 
 impl Command for InsertChildren {
-    fn write(self: Box<Self>, world: &mut World, _resources: &mut Resources) {
+    fn write(self: Box<Self>, world: &mut World) {
         for child in self.children.iter() {
             world
-                .insert(*child, (Parent(self.parent), PreviousParent(self.parent)))
-                .unwrap();
+                .entity_mut(*child)
+                .insert_bundle((Parent(self.parent), PreviousParent(self.parent)));
         }
         {
             let mut added = false;
-            if let Ok(mut children) = world.get_mut::<Children>(self.parent) {
+            if let Some(mut children) = world.get_mut::<Children>(self.parent) {
                 children.0.insert_from_slice(self.index, &self.children);
                 added = true;
             }
@@ -26,8 +32,8 @@ impl Command for InsertChildren {
             // NOTE: ideally this is just an else statement, but currently that _incorrectly_ fails borrow-checking
             if !added {
                 world
-                    .insert_one(self.parent, Children(self.children))
-                    .unwrap();
+                    .entity_mut(self.parent)
+                    .insert(Children(self.children));
             }
         }
     }
@@ -39,21 +45,21 @@ pub struct PushChildren {
     children: SmallVec<[Entity; 8]>,
 }
 
-pub struct ChildBuilder<'a> {
-    commands: &'a mut Commands,
+pub struct ChildBuilder<'a, 'b> {
+    commands: &'a mut Commands<'b>,
     push_children: PushChildren,
 }
 
 impl Command for PushChildren {
-    fn write(self: Box<Self>, world: &mut World, _resources: &mut Resources) {
+    fn write(self: Box<Self>, world: &mut World) {
         for child in self.children.iter() {
             world
-                .insert(*child, (Parent(self.parent), PreviousParent(self.parent)))
-                .unwrap();
+                .entity_mut(*child)
+                .insert_bundle((Parent(self.parent), PreviousParent(self.parent)));
         }
         {
             let mut added = false;
-            if let Ok(mut children) = world.get_mut::<Children>(self.parent) {
+            if let Some(mut children) = world.get_mut::<Children>(self.parent) {
                 children.0.extend(self.children.iter().cloned());
                 added = true;
             }
@@ -61,15 +67,15 @@ impl Command for PushChildren {
             // NOTE: ideally this is just an else statement, but currently that _incorrectly_ fails borrow-checking
             if !added {
                 world
-                    .insert_one(self.parent, Children(self.children))
-                    .unwrap();
+                    .entity_mut(self.parent)
+                    .insert(Children(self.children));
             }
         }
     }
 }
 
-impl<'a> ChildBuilder<'a> {
-    pub fn spawn(&mut self, bundle: impl DynamicBundle + Send + Sync + 'static) -> &mut Self {
+impl<'a, 'b> ChildBuilder<'a, 'b> {
+    pub fn spawn(&mut self, bundle: impl Bundle) -> &mut Self {
         self.commands.spawn(bundle);
         self.push_children
             .children
@@ -85,7 +91,7 @@ impl<'a> ChildBuilder<'a> {
         self.push_children.parent
     }
 
-    pub fn with_bundle(&mut self, bundle: impl DynamicBundle + Send + Sync + 'static) -> &mut Self {
+    pub fn with_bundle(&mut self, bundle: impl Bundle) -> &mut Self {
         self.commands.with_bundle(bundle);
         self
     }
@@ -116,7 +122,7 @@ pub trait BuildChildren {
     fn insert_children(&mut self, parent: Entity, index: usize, children: &[Entity]) -> &mut Self;
 }
 
-impl BuildChildren for Commands {
+impl<'a> BuildChildren for Commands<'a> {
     fn with_children(&mut self, parent: impl FnOnce(&mut ChildBuilder)) -> &mut Self {
         let current_entity = self.current_entity().expect("Cannot add children because the 'current entity' is not set. You should spawn an entity first.");
         self.clear_current_entity();
@@ -155,7 +161,7 @@ impl BuildChildren for Commands {
     }
 }
 
-impl<'a> BuildChildren for ChildBuilder<'a> {
+impl<'a, 'b> BuildChildren for ChildBuilder<'a, 'b> {
     fn with_children(&mut self, spawn_children: impl FnOnce(&mut ChildBuilder)) -> &mut Self {
         let current_entity = self.commands.current_entity().expect("Cannot add children because the 'current entity' is not set. You should spawn an entity first.");
         self.commands.clear_current_entity();
@@ -195,19 +201,121 @@ impl<'a> BuildChildren for ChildBuilder<'a> {
     }
 }
 
+#[derive(Debug)]
+pub struct WorldChildBuilder<'w> {
+    world: &'w mut World,
+    current_entity: Option<Entity>,
+    parent_entities: Vec<Entity>,
+}
+
+impl<'w> WorldChildBuilder<'w> {
+    pub fn spawn(&mut self, bundle: impl Bundle + Send + Sync + 'static) -> &mut Self {
+        let parent_entity = self
+            .parent_entities
+            .last()
+            .cloned()
+            .expect("There should always be a parent at this point.");
+        let entity = self
+            .world
+            .spawn()
+            .insert_bundle(bundle)
+            .insert_bundle((Parent(parent_entity), PreviousParent(parent_entity)))
+            .id();
+        self.current_entity = Some(entity);
+        if let Some(mut parent) = self.world.get_entity_mut(parent_entity) {
+            if let Some(mut children) = parent.get_mut::<Children>() {
+                children.0.push(entity);
+            } else {
+                parent.insert(Children(smallvec::smallvec![entity]));
+            }
+        }
+        self
+    }
+
+    pub fn with_bundle(&mut self, bundle: impl Bundle + Send + Sync + 'static) -> &mut Self {
+        self.world
+            .entity_mut(self.current_entity.unwrap())
+            .insert_bundle(bundle);
+        self
+    }
+
+    pub fn with(&mut self, component: impl Component) -> &mut Self {
+        self.world
+            .entity_mut(self.current_entity.unwrap())
+            .insert(component);
+        self
+    }
+
+    pub fn current_entity(&self) -> Option<Entity> {
+        self.current_entity
+    }
+
+    pub fn for_current_entity(&mut self, func: impl FnOnce(Entity)) -> &mut Self {
+        let current_entity = self
+            .current_entity()
+            .expect("The 'current entity' is not set. You should spawn an entity first.");
+        func(current_entity);
+        self
+    }
+}
+
+pub trait BuildWorldChildren {
+    fn with_children(&mut self, spawn_children: impl FnOnce(&mut WorldChildBuilder)) -> &mut Self;
+}
+
+impl<'w> BuildWorldChildren for EntityMut<'w> {
+    fn with_children(&mut self, spawn_children: impl FnOnce(&mut WorldChildBuilder)) -> &mut Self {
+        {
+            let entity = self.id();
+            let mut builder = WorldChildBuilder {
+                current_entity: None,
+                parent_entities: vec![entity],
+                // SAFE: self.update_location() is called below. It is impossible to make EntityMut function calls on `self`
+                // within the scope defined here
+                world: unsafe { self.world_mut() },
+            };
+
+            spawn_children(&mut builder);
+        }
+        self.update_location();
+        self
+    }
+}
+
+impl<'w> BuildWorldChildren for WorldChildBuilder<'w> {
+    fn with_children(
+        &mut self,
+        spawn_children: impl FnOnce(&mut WorldChildBuilder<'w>),
+    ) -> &mut Self {
+        let current_entity = self
+            .current_entity
+            .expect("Cannot add children without a parent. Try creating an entity first.");
+        self.parent_entities.push(current_entity);
+        self.current_entity = None;
+
+        spawn_children(self);
+
+        self.current_entity = self.parent_entities.pop();
+        self
+    }
+}
+
 #[cfg(test)]
 mod tests {
     use super::BuildChildren;
     use crate::prelude::{Children, Parent, PreviousParent};
-    use bevy_ecs::{Commands, Entity, Resources, World};
+    use bevy_ecs::{
+        entity::Entity,
+        system::{CommandQueue, Commands},
+        world::World,
+    };
     use smallvec::{smallvec, SmallVec};
 
     #[test]
     fn build_children() {
         let mut world = World::default();
-        let mut resources = Resources::default();
-        let mut commands = Commands::default();
-        commands.set_entity_reserver(world.get_entity_reserver());
+        let mut queue = CommandQueue::default();
+        let mut commands = Commands::new(&mut queue, &world);
 
         let mut parent = None;
         let mut child1 = None;
@@ -228,7 +336,7 @@ mod tests {
                 child3 = parent.current_entity();
             });
 
-        commands.apply(&mut world, &mut resources);
+        queue.apply(&mut world);
         let parent = parent.expect("parent should exist");
         let child1 = child1.expect("child1 should exist");
         let child2 = child2.expect("child2 should exist");
@@ -255,14 +363,17 @@ mod tests {
     #[test]
     fn push_and_insert_children() {
         let mut world = World::default();
-        let mut resources = Resources::default();
-        let mut commands = Commands::default();
+
         let entities = world
             .spawn_batch(vec![(1,), (2,), (3,), (4,), (5,)])
             .collect::<Vec<Entity>>();
 
-        commands.push_children(entities[0], &entities[1..3]);
-        commands.apply(&mut world, &mut resources);
+        let mut queue = CommandQueue::default();
+        {
+            let mut commands = Commands::new(&mut queue, &world);
+            commands.push_children(entities[0], &entities[1..3]);
+        }
+        queue.apply(&mut world);
 
         let parent = entities[0];
         let child1 = entities[1];
@@ -287,8 +398,11 @@ mod tests {
             PreviousParent(parent)
         );
 
-        commands.insert_children(parent, 1, &entities[3..]);
-        commands.apply(&mut world, &mut resources);
+        {
+            let mut commands = Commands::new(&mut queue, &world);
+            commands.insert_children(parent, 1, &entities[3..]);
+        }
+        queue.apply(&mut world);
 
         let expected_children: SmallVec<[Entity; 8]> = smallvec![child1, child3, child4, child2];
         assert_eq!(
diff --git a/crates/bevy_transform/src/hierarchy/hierarchy.rs b/crates/bevy_transform/src/hierarchy/hierarchy.rs
index 85343d3f37c14..47f8db14b33a5 100644
--- a/crates/bevy_transform/src/hierarchy/hierarchy.rs
+++ b/crates/bevy_transform/src/hierarchy/hierarchy.rs
@@ -1,5 +1,9 @@
 use crate::components::{Children, Parent};
-use bevy_ecs::{Command, Commands, Entity, Resources, World};
+use bevy_ecs::{
+    entity::Entity,
+    system::{Command, Commands},
+    world::World,
+};
 use bevy_utils::tracing::debug;
 
 #[derive(Debug)]
@@ -9,8 +13,8 @@ pub struct DespawnRecursive {
 
 pub fn despawn_with_children_recursive(world: &mut World, entity: Entity) {
     // first, make the entity's own parent forget about it
-    if let Ok(parent) = world.get::<Parent>(entity).map(|parent| parent.0) {
-        if let Ok(mut children) = world.get_mut::<Children>(parent) {
+    if let Some(parent) = world.get::<Parent>(entity).map(|parent| parent.0) {
+        if let Some(mut children) = world.get_mut::<Children>(parent) {
             children.0.retain(|c| *c != entity);
         }
     }
@@ -21,19 +25,19 @@ pub fn despawn_with_children_recursive(world: &mut World, entity: Entity) {
 
 // Should only be called by `despawn_with_children_recursive`!
 fn despawn_with_children_recursive_inner(world: &mut World, entity: Entity) {
-    if let Ok(mut children) = world.get_mut::<Children>(entity) {
+    if let Some(mut children) = world.get_mut::<Children>(entity) {
         for e in std::mem::take(&mut children.0) {
             despawn_with_children_recursive(world, e);
         }
     }
 
-    if let Err(e) = world.despawn(entity) {
-        debug!("Failed to despawn entity {:?}: {}", entity, e);
+    if !world.despawn(entity) {
+        debug!("Failed to despawn entity {:?}", entity);
     }
 }
 
 impl Command for DespawnRecursive {
-    fn write(self: Box<Self>, world: &mut World, _resources: &mut Resources) {
+    fn write(self: Box<Self>, world: &mut World) {
         despawn_with_children_recursive(world, self.entity);
     }
 }
@@ -43,7 +47,7 @@ pub trait DespawnRecursiveExt {
     fn despawn_recursive(&mut self, entity: Entity) -> &mut Self;
 }
 
-impl DespawnRecursiveExt for Commands {
+impl<'a> DespawnRecursiveExt for Commands<'a> {
     /// Despawns the provided entity and its children.
     fn despawn_recursive(&mut self, entity: Entity) -> &mut Self {
         self.add_command(DespawnRecursive { entity })
@@ -52,53 +56,63 @@ impl DespawnRecursiveExt for Commands {
 
 #[cfg(test)]
 mod tests {
+    use bevy_ecs::{
+        system::{CommandQueue, Commands},
+        world::World,
+    };
+
     use super::DespawnRecursiveExt;
     use crate::{components::Children, hierarchy::BuildChildren};
-    use bevy_ecs::{Commands, Resources, World};
 
     #[test]
     fn despawn_recursive() {
         let mut world = World::default();
-        let mut resources = Resources::default();
-        let mut command_buffer = Commands::default();
-        command_buffer.set_entity_reserver(world.get_entity_reserver());
-
-        command_buffer
-            .spawn(("Another parent".to_owned(), 0u32))
-            .with_children(|parent| {
-                parent.spawn(("Another child".to_owned(), 1u32));
-            });
-
-        // Create a grandparent entity which will _not_ be deleted
-        command_buffer.spawn(("Grandparent".to_owned(), 2u32));
-        let grandparent_entity = command_buffer.current_entity().unwrap();
-
-        command_buffer.with_children(|parent| {
-            // Add a child to the grandparent (the "parent"), which will get deleted
-            parent.spawn(("Parent, to be deleted".to_owned(), 3u32));
-            // All descendents of the "parent" should also be deleted.
-            parent.with_children(|parent| {
-                parent
-                    .spawn(("First Child, to be deleted".to_owned(), 4u32))
-                    .with_children(|parent| {
-                        // child
-                        parent.spawn(("First grand child, to be deleted".to_owned(), 5u32));
-                    });
-                parent.spawn(("Second child, to be deleted".to_owned(), 6u32));
+        let mut queue = CommandQueue::default();
+        let grandparent_entity;
+        {
+            let mut commands = Commands::new(&mut queue, &world);
+
+            commands
+                .spawn(("Another parent".to_owned(), 0u32))
+                .with_children(|parent| {
+                    parent.spawn(("Another child".to_owned(), 1u32));
+                });
+
+            // Create a grandparent entity which will _not_ be deleted
+            commands.spawn(("Grandparent".to_owned(), 2u32));
+            grandparent_entity = commands.current_entity().unwrap();
+
+            commands.with_children(|parent| {
+                // Add a child to the grandparent (the "parent"), which will get deleted
+                parent.spawn(("Parent, to be deleted".to_owned(), 3u32));
+                // All descendents of the "parent" should also be deleted.
+                parent.with_children(|parent| {
+                    parent
+                        .spawn(("First Child, to be deleted".to_owned(), 4u32))
+                        .with_children(|parent| {
+                            // child
+                            parent.spawn(("First grand child, to be deleted".to_owned(), 5u32));
+                        });
+                    parent.spawn(("Second child, to be deleted".to_owned(), 6u32));
+                });
             });
-        });
 
-        command_buffer.spawn(("An innocent bystander".to_owned(), 7u32));
-        command_buffer.apply(&mut world, &mut resources);
+            commands.spawn(("An innocent bystander".to_owned(), 7u32));
+        }
+        queue.apply(&mut world);
 
         let parent_entity = world.get::<Children>(grandparent_entity).unwrap()[0];
 
-        command_buffer.despawn_recursive(parent_entity);
-        command_buffer.despawn_recursive(parent_entity); // despawning the same entity twice should not panic
-        command_buffer.apply(&mut world, &mut resources);
+        {
+            let mut commands = Commands::new(&mut queue, &world);
+            commands.despawn_recursive(parent_entity);
+            commands.despawn_recursive(parent_entity); // despawning the same entity twice should not panic
+        }
+        queue.apply(&mut world);
 
         let mut results = world
             .query::<(&String, &u32)>()
+            .iter(&world)
             .map(|(a, b)| (a.clone(), *b))
             .collect::<Vec<_>>();
         results.sort_unstable_by_key(|(_, index)| *index);
diff --git a/crates/bevy_transform/src/hierarchy/hierarchy_maintenance_system.rs b/crates/bevy_transform/src/hierarchy/hierarchy_maintenance_system.rs
index 468e624046bad..19f408d210243 100644
--- a/crates/bevy_transform/src/hierarchy/hierarchy_maintenance_system.rs
+++ b/crates/bevy_transform/src/hierarchy/hierarchy_maintenance_system.rs
@@ -1,10 +1,14 @@
 use crate::components::*;
-use bevy_ecs::{Commands, Entity, Query, Without};
+use bevy_ecs::{
+    entity::Entity,
+    query::Without,
+    system::{Commands, Query},
+};
 use bevy_utils::HashMap;
 use smallvec::SmallVec;
 
 pub fn parent_update_system(
-    commands: &mut Commands,
+    mut commands: Commands,
     removed_parent_query: Query<(Entity, &PreviousParent), Without<Parent>>,
     // The next query could be run with a Changed<Parent> filter. However, this would mean that modifications later in the frame are lost.
     // See issue 891: https://github.com/bevyengine/bevy/issues/891
@@ -16,7 +20,7 @@ pub fn parent_update_system(
     for (entity, previous_parent) in removed_parent_query.iter() {
         if let Ok(mut previous_parent_children) = children_query.get_mut(previous_parent.0) {
             previous_parent_children.0.retain(|e| *e != entity);
-            commands.remove_one::<PreviousParent>(entity);
+            commands.remove::<PreviousParent>(entity);
         }
     }
 
@@ -39,7 +43,7 @@ pub fn parent_update_system(
             // Set `PreviousParent = Parent`.
             *previous_parent = PreviousParent(parent.0);
         } else {
-            commands.insert_one(entity, PreviousParent(parent.0));
+            commands.insert(entity, PreviousParent(parent.0));
         };
 
         // Add to the parent's `Children` (either the real component, or
@@ -64,19 +68,23 @@ pub fn parent_update_system(
     // collect multiple new children that point to the same parent into the same
     // SmallVec, and to prevent redundant add+remove operations.
     children_additions.iter().for_each(|(k, v)| {
-        commands.insert_one(*k, Children::with(v));
+        commands.insert(*k, Children::with(v));
     });
 }
 #[cfg(test)]
 mod test {
+    use bevy_ecs::{
+        schedule::{Schedule, Stage, SystemStage},
+        system::{CommandQueue, IntoSystem},
+        world::World,
+    };
+
     use super::*;
     use crate::{hierarchy::BuildChildren, transform_propagate_system::transform_propagate_system};
-    use bevy_ecs::{IntoSystem, Resources, Schedule, Stage, SystemStage, World};
 
     #[test]
     fn correct_children() {
         let mut world = World::default();
-        let mut resources = Resources::default();
 
         let mut update_stage = SystemStage::parallel();
         update_stage.add_system(parent_update_system.system());
@@ -86,8 +94,8 @@ mod test {
         schedule.add_stage("update", update_stage);
 
         // Add parent entities
-        let mut commands = Commands::default();
-        commands.set_entity_reserver(world.get_entity_reserver());
+        let mut command_queue = CommandQueue::default();
+        let mut commands = Commands::new(&mut command_queue, &world);
         let mut parent = None;
         let mut children = Vec::new();
         commands
@@ -101,8 +109,8 @@ mod test {
                     .for_current_entity(|entity| children.push(entity));
             });
         let parent = parent.unwrap();
-        commands.apply(&mut world, &mut resources);
-        schedule.run(&mut world, &mut resources);
+        command_queue.apply(&mut world);
+        schedule.run(&mut world);
 
         assert_eq!(
             world
@@ -118,7 +126,7 @@ mod test {
         // Parent `e1` to `e2`.
         (*world.get_mut::<Parent>(children[0]).unwrap()).0 = children[1];
 
-        schedule.run(&mut world, &mut resources);
+        schedule.run(&mut world);
 
         assert_eq!(
             world
@@ -140,9 +148,9 @@ mod test {
             vec![children[0]]
         );
 
-        world.despawn(children[0]).unwrap();
+        assert!(world.despawn(children[0]));
 
-        schedule.run(&mut world, &mut resources);
+        schedule.run(&mut world);
 
         assert_eq!(
             world
diff --git a/crates/bevy_transform/src/hierarchy/mod.rs b/crates/bevy_transform/src/hierarchy/mod.rs
index 76d685a381d4f..23e9108e2dec2 100644
--- a/crates/bevy_transform/src/hierarchy/mod.rs
+++ b/crates/bevy_transform/src/hierarchy/mod.rs
@@ -2,9 +2,7 @@ mod child_builder;
 #[allow(clippy::module_inception)]
 mod hierarchy;
 mod hierarchy_maintenance_system;
-mod world_child_builder;
 
 pub use child_builder::*;
 pub use hierarchy::*;
 pub use hierarchy_maintenance_system::*;
-pub use world_child_builder::*;
diff --git a/crates/bevy_transform/src/hierarchy/world_child_builder.rs b/crates/bevy_transform/src/hierarchy/world_child_builder.rs
deleted file mode 100644
index 858532739d433..0000000000000
--- a/crates/bevy_transform/src/hierarchy/world_child_builder.rs
+++ /dev/null
@@ -1,96 +0,0 @@
-use crate::prelude::{Children, Parent, PreviousParent};
-use bevy_ecs::{Component, DynamicBundle, Entity, WorldBuilder};
-
-#[derive(Debug)]
-pub struct WorldChildBuilder<'a, 'b> {
-    world_builder: &'b mut WorldBuilder<'a>,
-    parent_entities: Vec<Entity>,
-}
-
-impl<'a, 'b> WorldChildBuilder<'a, 'b> {
-    pub fn spawn(&mut self, bundle: impl DynamicBundle + Send + Sync + 'static) -> &mut Self {
-        let parent_entity = self
-            .parent_entities
-            .last()
-            .cloned()
-            .expect("There should always be a parent at this point.");
-        self.world_builder
-            .spawn(bundle)
-            .with_bundle((Parent(parent_entity), PreviousParent(parent_entity)));
-        let entity = self.world_builder.current_entity.unwrap();
-        {
-            let world = &mut self.world_builder.world;
-            let mut added = false;
-            if let Ok(mut children) = world.get_mut::<Children>(parent_entity) {
-                children.0.push(entity);
-                added = true;
-            }
-
-            // NOTE: ideally this is just an else statement, but currently that _incorrectly_ fails borrow-checking
-            if !added {
-                world
-                    .insert_one(parent_entity, Children(smallvec::smallvec![entity]))
-                    .unwrap();
-            }
-        }
-        self
-    }
-
-    pub fn with_bundle(&mut self, bundle: impl DynamicBundle + Send + Sync + 'static) -> &mut Self {
-        self.world_builder.with_bundle(bundle);
-        self
-    }
-
-    pub fn with(&mut self, component: impl Component) -> &mut Self {
-        self.world_builder.with(component);
-        self
-    }
-
-    pub fn current_entity(&self) -> Option<Entity> {
-        self.world_builder.current_entity
-    }
-
-    pub fn for_current_entity(&mut self, f: impl FnOnce(Entity)) -> &mut Self {
-        let current_entity = self
-            .world_builder
-            .current_entity
-            .expect("The 'current entity' is not set. You should spawn an entity first.");
-        f(current_entity);
-        self
-    }
-}
-
-pub trait BuildWorldChildren {
-    fn with_children(&mut self, spawn_children: impl FnOnce(&mut WorldChildBuilder)) -> &mut Self;
-}
-
-impl<'a> BuildWorldChildren for WorldBuilder<'a> {
-    fn with_children(&mut self, spawn_children: impl FnOnce(&mut WorldChildBuilder)) -> &mut Self {
-        {
-            let current_entity = self.current_entity.expect("Cannot add children because the 'current entity' is not set. You should spawn an entity first.");
-            let mut builder = WorldChildBuilder {
-                world_builder: self,
-                parent_entities: vec![current_entity],
-            };
-
-            spawn_children(&mut builder);
-        }
-        self
-    }
-}
-
-impl<'a, 'b> BuildWorldChildren for WorldChildBuilder<'a, 'b> {
-    fn with_children(&mut self, spawn_children: impl FnOnce(&mut WorldChildBuilder)) -> &mut Self {
-        let current_entity = self
-            .world_builder
-            .current_entity
-            .expect("Cannot add children without a parent. Try creating an entity first.");
-        self.parent_entities.push(current_entity);
-        self.world_builder.current_entity = None;
-
-        spawn_children(self);
-
-        self.world_builder.current_entity = self.parent_entities.pop();
-        self
-    }
-}
diff --git a/crates/bevy_transform/src/lib.rs b/crates/bevy_transform/src/lib.rs
index 2b23d25eb7b86..3efc6d0a20eea 100644
--- a/crates/bevy_transform/src/lib.rs
+++ b/crates/bevy_transform/src/lib.rs
@@ -7,8 +7,10 @@ pub mod prelude {
 }
 
 use bevy_app::prelude::*;
-use bevy_ecs::{IntoSystem, ParallelSystemDescriptorCoercion, SystemLabel};
-use bevy_reflect::RegisterTypeBuilder;
+use bevy_ecs::{
+    schedule::{ParallelSystemDescriptorCoercion, SystemLabel},
+    system::IntoSystem,
+};
 use prelude::{parent_update_system, Children, GlobalTransform, Parent, PreviousParent, Transform};
 
 #[derive(Default)]
diff --git a/crates/bevy_transform/src/transform_propagate_system.rs b/crates/bevy_transform/src/transform_propagate_system.rs
index 219f2e6c59ee9..a3fbebd27df39 100644
--- a/crates/bevy_transform/src/transform_propagate_system.rs
+++ b/crates/bevy_transform/src/transform_propagate_system.rs
@@ -1,10 +1,14 @@
-use crate::components::*;
-use bevy_ecs::prelude::*;
+use crate::components::{Children, GlobalTransform, Parent, Transform};
+use bevy_ecs::{
+    entity::Entity,
+    query::{Changed, With, Without},
+    system::Query,
+};
 
 pub fn transform_propagate_system(
     mut root_query: Query<
         (Entity, Option<&Children>, &Transform, &mut GlobalTransform),
-        (Without<Parent>, With<GlobalTransform>),
+        Without<Parent>,
     >,
     mut transform_query: Query<(&Transform, &mut GlobalTransform), With<Parent>>,
     changed_transform_query: Query<Entity, Changed<Transform>>,
@@ -69,14 +73,18 @@ fn propagate_recursive(
 
 #[cfg(test)]
 mod test {
+    use bevy_ecs::{
+        schedule::{Schedule, Stage, SystemStage},
+        system::{CommandQueue, Commands, IntoSystem},
+        world::World,
+    };
+
     use super::*;
     use crate::hierarchy::{parent_update_system, BuildChildren, BuildWorldChildren};
-    use bevy_ecs::{Resources, Schedule, Stage, SystemStage, World};
 
     #[test]
     fn did_propagate() {
         let mut world = World::default();
-        let mut resources = Resources::default();
 
         let mut update_stage = SystemStage::parallel();
         update_stage.add_system(parent_update_system.system());
@@ -86,15 +94,15 @@ mod test {
         schedule.add_stage("update", update_stage);
 
         // Root entity
-        world.spawn((
+        world.spawn().insert_bundle((
             Transform::from_xyz(1.0, 0.0, 0.0),
             GlobalTransform::identity(),
         ));
 
         let mut children = Vec::new();
         world
-            .build()
-            .spawn((
+            .spawn()
+            .insert_bundle((
                 Transform::from_xyz(1.0, 0.0, 0.0),
                 GlobalTransform::identity(),
             ))
@@ -111,7 +119,7 @@ mod test {
                     ))
                     .for_current_entity(|entity| children.push(entity));
             });
-        schedule.run(&mut world, &mut resources);
+        schedule.run(&mut world);
 
         assert_eq!(
             *world.get::<GlobalTransform>(children[0]).unwrap(),
@@ -127,7 +135,6 @@ mod test {
     #[test]
     fn did_propagate_command_buffer() {
         let mut world = World::default();
-        let mut resources = Resources::default();
 
         let mut update_stage = SystemStage::parallel();
         update_stage.add_system(parent_update_system.system());
@@ -137,8 +144,8 @@ mod test {
         schedule.add_stage("update", update_stage);
 
         // Root entity
-        let mut commands = Commands::default();
-        commands.set_entity_reserver(world.get_entity_reserver());
+        let mut queue = CommandQueue::default();
+        let mut commands = Commands::new(&mut queue, &world);
         let mut children = Vec::new();
         commands
             .spawn((
@@ -158,8 +165,8 @@ mod test {
                     ))
                     .for_current_entity(|entity| children.push(entity));
             });
-        commands.apply(&mut world, &mut resources);
-        schedule.run(&mut world, &mut resources);
+        queue.apply(&mut world);
+        schedule.run(&mut world);
 
         assert_eq!(
             *world.get::<GlobalTransform>(children[0]).unwrap(),
diff --git a/crates/bevy_ui/src/entity.rs b/crates/bevy_ui/src/entity.rs
index 7e31c3e2b699e..e5a45118fd77c 100644
--- a/crates/bevy_ui/src/entity.rs
+++ b/crates/bevy_ui/src/entity.rs
@@ -5,7 +5,7 @@ use crate::{
     FocusPolicy, Interaction, Style,
 };
 use bevy_asset::Handle;
-use bevy_ecs::Bundle;
+use bevy_ecs::bundle::Bundle;
 use bevy_render::{
     camera::{Camera, DepthCalculation, OrthographicProjection, VisibleEntities, WindowOrigin},
     draw::Draw,
diff --git a/crates/bevy_ui/src/flex/convert.rs b/crates/bevy_ui/src/flex/convert.rs
index 43bb7c839c0cb..4335ca4306b2b 100644
--- a/crates/bevy_ui/src/flex/convert.rs
+++ b/crates/bevy_ui/src/flex/convert.rs
@@ -114,8 +114,8 @@ impl From<Direction> for stretch::style::Direction {
     fn from(value: Direction) -> Self {
         match value {
             Direction::Inherit => stretch::style::Direction::Inherit,
-            Direction::LTR => stretch::style::Direction::LTR,
-            Direction::RTL => stretch::style::Direction::RTL,
+            Direction::Ltr => stretch::style::Direction::LTR,
+            Direction::Rtl => stretch::style::Direction::RTL,
         }
     }
 }
diff --git a/crates/bevy_ui/src/flex/mod.rs b/crates/bevy_ui/src/flex/mod.rs
index b32675534eb78..87aa13f3c768a 100644
--- a/crates/bevy_ui/src/flex/mod.rs
+++ b/crates/bevy_ui/src/flex/mod.rs
@@ -2,7 +2,11 @@ mod convert;
 
 use crate::{Node, Style};
 use bevy_app::EventReader;
-use bevy_ecs::{Changed, Entity, Flags, Query, QueryFilter, Res, ResMut, With, Without};
+use bevy_ecs::{
+    entity::Entity,
+    query::{Changed, FilterFetch, Flags, With, Without, WorldQuery},
+    system::{Query, Res, ResMut},
+};
 use bevy_log::warn;
 use bevy_math::Vec2;
 use bevy_text::CalculatedSize;
@@ -201,8 +205,7 @@ pub fn flex_node_system(
         Entity,
         &mut Node,
         &mut Transform,
-        Option<&Parent>,
-        Flags<Parent>,
+        Option<(&Parent, Flags<Parent>)>,
         Flags<Transform>,
     )>,
 ) {
@@ -228,12 +231,12 @@ pub fn flex_node_system(
         update_changed(&mut *flex_surface, logical_to_physical_factor, node_query);
     }
 
-    fn update_changed<F>(
+    fn update_changed<F: WorldQuery>(
         flex_surface: &mut FlexSurface,
         scaling_factor: f64,
         query: Query<(Entity, &Style, Option<&CalculatedSize>), F>,
     ) where
-        F: QueryFilter,
+        F::Fetch: FilterFetch,
     {
         // update changed nodes
         for (entity, style, calculated_size) in query.iter() {
@@ -269,7 +272,7 @@ pub fn flex_node_system(
 
     let to_logical = |v| (physical_to_logical_factor * v as f64) as f32;
 
-    for (entity, mut node, mut transform, parent, parent_flags, transform_flags) in
+    for (entity, mut node, mut transform, parent, transform_flags) in
         node_transform_query.iter_mut()
     {
         let layout = flex_surface.get_layout(entity).unwrap();
@@ -280,8 +283,8 @@ pub fn flex_node_system(
         let position = &mut transform.translation;
         position.x = to_logical(layout.location.x + layout.size.width / 2.0);
         position.y = to_logical(layout.location.y + layout.size.height / 2.0);
-        if parent_flags.changed() || transform_flags.changed() {
-            if let Some(parent) = parent {
+        if let Some((parent, parent_flags)) = parent {
+            if parent_flags.changed() || transform_flags.changed() {
                 if let Ok(parent_layout) = flex_surface.get_layout(parent.0) {
                     position.x -= to_logical(parent_layout.size.width / 2.0);
                     position.y -= to_logical(parent_layout.size.height / 2.0);
diff --git a/crates/bevy_ui/src/focus.rs b/crates/bevy_ui/src/focus.rs
index 5774a6a6772e0..0924e4e5305bd 100644
--- a/crates/bevy_ui/src/focus.rs
+++ b/crates/bevy_ui/src/focus.rs
@@ -1,6 +1,9 @@
 use crate::Node;
 use bevy_core::FloatOrd;
-use bevy_ecs::prelude::*;
+use bevy_ecs::{
+    entity::Entity,
+    system::{Local, Query, Res},
+};
 use bevy_input::{mouse::MouseButton, touch::Touches, Input};
 use bevy_transform::components::GlobalTransform;
 use bevy_window::Windows;
diff --git a/crates/bevy_ui/src/lib.rs b/crates/bevy_ui/src/lib.rs
index 803287d5dea3b..6f7c97537d187 100644
--- a/crates/bevy_ui/src/lib.rs
+++ b/crates/bevy_ui/src/lib.rs
@@ -9,6 +9,7 @@ pub mod update;
 pub mod widget;
 
 pub use anchors::*;
+use bevy_render::RenderStage;
 pub use flex::*;
 pub use focus::*;
 pub use margins::*;
@@ -21,9 +22,9 @@ pub mod prelude {
 
 use bevy_app::prelude::*;
 use bevy_ecs::{
-    IntoSystem, ParallelSystemDescriptorCoercion, StageLabel, SystemLabel, SystemStage,
+    schedule::{ParallelSystemDescriptorCoercion, StageLabel, SystemLabel, SystemStage},
+    system::IntoSystem,
 };
-use bevy_render::{render_graph::RenderGraph, RenderStage};
 use update::ui_z_system;
 
 #[derive(Default)]
@@ -61,8 +62,6 @@ impl Plugin for UiPlugin {
             .add_system_to_stage(UiStage::Ui, ui_z_system.system())
             .add_system_to_stage(RenderStage::Draw, widget::draw_text_system.system());
 
-        let resources = app.resources();
-        let mut render_graph = resources.get_mut::<RenderGraph>().unwrap();
-        render_graph.add_ui_graph(resources);
+        crate::render::add_ui_graph(app.world_mut());
     }
 }
diff --git a/crates/bevy_ui/src/render/mod.rs b/crates/bevy_ui/src/render/mod.rs
index 50e92d883d899..b1f9f814a4f85 100644
--- a/crates/bevy_ui/src/render/mod.rs
+++ b/crates/bevy_ui/src/render/mod.rs
@@ -1,6 +1,6 @@
 use crate::Node;
 use bevy_asset::{Assets, HandleUntyped};
-use bevy_ecs::Resources;
+use bevy_ecs::world::World;
 use bevy_reflect::TypeUuid;
 use bevy_render::{
     camera::ActiveCameras,
@@ -77,41 +77,43 @@ pub mod camera {
     pub const CAMERA_UI: &str = "CameraUi";
 }
 
-pub trait UiRenderGraphBuilder {
-    fn add_ui_graph(&mut self, resources: &Resources) -> &mut Self;
-}
+pub(crate) fn add_ui_graph(world: &mut World) {
+    let world = world.cell();
+    let mut graph = world.get_resource_mut::<RenderGraph>().unwrap();
+    let mut pipelines = world
+        .get_resource_mut::<Assets<PipelineDescriptor>>()
+        .unwrap();
+    let mut shaders = world.get_resource_mut::<Assets<Shader>>().unwrap();
+    let mut active_cameras = world.get_resource_mut::<ActiveCameras>().unwrap();
+    let msaa = world.get_resource::<Msaa>().unwrap();
 
-impl UiRenderGraphBuilder for RenderGraph {
-    fn add_ui_graph(&mut self, resources: &Resources) -> &mut Self {
-        let mut pipelines = resources.get_mut::<Assets<PipelineDescriptor>>().unwrap();
-        let mut shaders = resources.get_mut::<Assets<Shader>>().unwrap();
-        let msaa = resources.get::<Msaa>().unwrap();
-        pipelines.set_untracked(UI_PIPELINE_HANDLE, build_ui_pipeline(&mut shaders));
+    pipelines.set_untracked(UI_PIPELINE_HANDLE, build_ui_pipeline(&mut shaders));
 
-        let mut ui_pass_node = PassNode::<&Node>::new(PassDescriptor {
-            color_attachments: vec![msaa.color_attachment_descriptor(
-                TextureAttachment::Input("color_attachment".to_string()),
-                TextureAttachment::Input("color_resolve_target".to_string()),
-                Operations {
-                    load: LoadOp::Load,
-                    store: true,
-                },
-            )],
-            depth_stencil_attachment: Some(RenderPassDepthStencilAttachmentDescriptor {
-                attachment: TextureAttachment::Input("depth".to_string()),
-                depth_ops: Some(Operations {
-                    load: LoadOp::Clear(1.0),
-                    store: true,
-                }),
-                stencil_ops: None,
+    let mut ui_pass_node = PassNode::<&Node>::new(PassDescriptor {
+        color_attachments: vec![msaa.color_attachment_descriptor(
+            TextureAttachment::Input("color_attachment".to_string()),
+            TextureAttachment::Input("color_resolve_target".to_string()),
+            Operations {
+                load: LoadOp::Load,
+                store: true,
+            },
+        )],
+        depth_stencil_attachment: Some(RenderPassDepthStencilAttachmentDescriptor {
+            attachment: TextureAttachment::Input("depth".to_string()),
+            depth_ops: Some(Operations {
+                load: LoadOp::Clear(1.0),
+                store: true,
             }),
-            sample_count: msaa.samples,
-        });
+            stencil_ops: None,
+        }),
+        sample_count: msaa.samples,
+    });
 
-        ui_pass_node.add_camera(camera::CAMERA_UI);
-        self.add_node(node::UI_PASS, ui_pass_node);
+    ui_pass_node.add_camera(camera::CAMERA_UI);
+    graph.add_node(node::UI_PASS, ui_pass_node);
 
-        self.add_slot_edge(
+    graph
+        .add_slot_edge(
             base::node::PRIMARY_SWAP_CHAIN,
             WindowSwapChainNode::OUT_TEXTURE,
             node::UI_PASS,
@@ -123,7 +125,8 @@ impl UiRenderGraphBuilder for RenderGraph {
         )
         .unwrap();
 
-        self.add_slot_edge(
+    graph
+        .add_slot_edge(
             base::node::MAIN_DEPTH_TEXTURE,
             WindowTextureNode::OUT_TEXTURE,
             node::UI_PASS,
@@ -131,27 +134,26 @@ impl UiRenderGraphBuilder for RenderGraph {
         )
         .unwrap();
 
-        if msaa.samples > 1 {
-            self.add_slot_edge(
+    if msaa.samples > 1 {
+        graph
+            .add_slot_edge(
                 base::node::MAIN_SAMPLED_COLOR_ATTACHMENT,
                 WindowSwapChainNode::OUT_TEXTURE,
                 node::UI_PASS,
                 "color_attachment",
             )
             .unwrap();
-        }
+    }
 
-        // ensure ui pass runs after main pass
-        self.add_node_edge(base::node::MAIN_PASS, node::UI_PASS)
-            .unwrap();
+    // ensure ui pass runs after main pass
+    graph
+        .add_node_edge(base::node::MAIN_PASS, node::UI_PASS)
+        .unwrap();
 
-        // setup ui camera
-        self.add_system_node(node::CAMERA_UI, CameraNode::new(camera::CAMERA_UI));
-        self.add_node_edge(node::CAMERA_UI, node::UI_PASS).unwrap();
-        self.add_system_node(node::NODE, RenderResourcesNode::<Node>::new(true));
-        self.add_node_edge(node::NODE, node::UI_PASS).unwrap();
-        let mut active_cameras = resources.get_mut::<ActiveCameras>().unwrap();
-        active_cameras.add(camera::CAMERA_UI);
-        self
-    }
+    // setup ui camera
+    graph.add_system_node(node::CAMERA_UI, CameraNode::new(camera::CAMERA_UI));
+    graph.add_node_edge(node::CAMERA_UI, node::UI_PASS).unwrap();
+    graph.add_system_node(node::NODE, RenderResourcesNode::<Node>::new(true));
+    graph.add_node_edge(node::NODE, node::UI_PASS).unwrap();
+    active_cameras.add(camera::CAMERA_UI);
 }
diff --git a/crates/bevy_ui/src/ui_node.rs b/crates/bevy_ui/src/ui_node.rs
index fc9c4824413ee..af3525027e680 100644
--- a/crates/bevy_ui/src/ui_node.rs
+++ b/crates/bevy_ui/src/ui_node.rs
@@ -1,5 +1,6 @@
+use bevy_ecs::reflect::ReflectComponent;
 use bevy_math::{Rect, Size, Vec2};
-use bevy_reflect::{Reflect, ReflectComponent, ReflectDeserialize};
+use bevy_reflect::{Reflect, ReflectDeserialize};
 use bevy_render::renderer::RenderResources;
 use serde::{Deserialize, Serialize};
 use std::ops::{Add, AddAssign};
@@ -153,8 +154,8 @@ impl Default for AlignContent {
 #[reflect_value(PartialEq, Serialize, Deserialize)]
 pub enum Direction {
     Inherit,
-    LTR,
-    RTL,
+    Ltr,
+    Rtl,
 }
 
 impl Default for Direction {
diff --git a/crates/bevy_ui/src/update.rs b/crates/bevy_ui/src/update.rs
index 1d3df0972b743..d478f8b13bd4d 100644
--- a/crates/bevy_ui/src/update.rs
+++ b/crates/bevy_ui/src/update.rs
@@ -1,5 +1,9 @@
 use super::Node;
-use bevy_ecs::{Entity, Query, With, Without};
+use bevy_ecs::{
+    entity::Entity,
+    query::{With, Without},
+    system::Query,
+};
 use bevy_transform::prelude::{Children, Parent, Transform};
 
 pub const UI_Z_STEP: f32 = 0.001;
@@ -48,7 +52,11 @@ fn update_hierarchy(
 }
 #[cfg(test)]
 mod tests {
-    use bevy_ecs::{Commands, IntoSystem, Resources, Schedule, Stage, SystemStage, World};
+    use bevy_ecs::{
+        schedule::{Schedule, Stage, SystemStage},
+        system::{CommandQueue, Commands, IntoSystem},
+        world::World,
+    };
     use bevy_transform::{components::Transform, hierarchy::BuildChildren};
 
     use crate::Node;
@@ -70,10 +78,8 @@ mod tests {
     #[test]
     fn test_ui_z_system() {
         let mut world = World::default();
-        let mut resources = Resources::default();
-        let mut commands = Commands::default();
-        commands.set_entity_reserver(world.get_entity_reserver());
-
+        let mut queue = CommandQueue::default();
+        let mut commands = Commands::new(&mut queue, &world);
         commands.spawn(node_with_transform("0"));
 
         commands
@@ -112,16 +118,17 @@ mod tests {
                         parent.spawn(node_with_transform("2-1-0"));
                     });
             });
-        commands.apply(&mut world, &mut resources);
+        queue.apply(&mut world);
 
         let mut schedule = Schedule::default();
         let mut update_stage = SystemStage::parallel();
         update_stage.add_system(ui_z_system.system());
         schedule.add_stage("update", update_stage);
-        schedule.run(&mut world, &mut resources);
+        schedule.run(&mut world);
 
         let mut actual_result = world
             .query::<(&String, &Transform)>()
+            .iter(&world)
             .map(|(name, transform)| (name.clone(), get_steps(transform)))
             .collect::<Vec<(String, u32)>>();
         actual_result.sort_unstable_by_key(|(name, _)| name.clone());
diff --git a/crates/bevy_ui/src/widget/image.rs b/crates/bevy_ui/src/widget/image.rs
index 14a84484fb18b..74e664e9b5576 100644
--- a/crates/bevy_ui/src/widget/image.rs
+++ b/crates/bevy_ui/src/widget/image.rs
@@ -1,5 +1,8 @@
 use bevy_asset::{Assets, Handle};
-use bevy_ecs::{Query, Res, With};
+use bevy_ecs::{
+    query::With,
+    system::{Query, Res},
+};
 use bevy_math::Size;
 use bevy_render::texture::Texture;
 use bevy_sprite::ColorMaterial;
diff --git a/crates/bevy_ui/src/widget/text.rs b/crates/bevy_ui/src/widget/text.rs
index 97d4850d3fcf6..6ab82f22e1e2e 100644
--- a/crates/bevy_ui/src/widget/text.rs
+++ b/crates/bevy_ui/src/widget/text.rs
@@ -1,6 +1,10 @@
 use crate::{Node, Style, Val};
 use bevy_asset::Assets;
-use bevy_ecs::{Changed, Entity, Local, Or, Query, QuerySet, Res, ResMut};
+use bevy_ecs::{
+    entity::Entity,
+    query::{Changed, Or},
+    system::{Local, Query, QuerySet, Res, ResMut},
+};
 use bevy_math::Size;
 use bevy_render::{
     draw::{Draw, DrawContext, Drawable},
diff --git a/crates/bevy_wgpu/src/diagnostic/wgpu_resource_diagnostics_plugin.rs b/crates/bevy_wgpu/src/diagnostic/wgpu_resource_diagnostics_plugin.rs
index 079332c93cf89..4184966cc0c7a 100644
--- a/crates/bevy_wgpu/src/diagnostic/wgpu_resource_diagnostics_plugin.rs
+++ b/crates/bevy_wgpu/src/diagnostic/wgpu_resource_diagnostics_plugin.rs
@@ -1,7 +1,7 @@
 use crate::renderer::WgpuRenderResourceContext;
 use bevy_app::prelude::*;
 use bevy_diagnostic::{Diagnostic, DiagnosticId, Diagnostics};
-use bevy_ecs::{IntoSystem, Res, ResMut};
+use bevy_ecs::system::{IntoSystem, Res, ResMut};
 use bevy_render::renderer::RenderResourceContext;
 
 #[derive(Default)]
diff --git a/crates/bevy_wgpu/src/lib.rs b/crates/bevy_wgpu/src/lib.rs
index 6f6e8c17d1c2c..dd078890ef151 100644
--- a/crates/bevy_wgpu/src/lib.rs
+++ b/crates/bevy_wgpu/src/lib.rs
@@ -10,7 +10,10 @@ pub use wgpu_renderer::*;
 pub use wgpu_resources::*;
 
 use bevy_app::prelude::*;
-use bevy_ecs::{IntoExclusiveSystem, IntoSystem, Resources, World};
+use bevy_ecs::{
+    system::{IntoExclusiveSystem, IntoSystem},
+    world::World,
+};
 use bevy_render::{
     renderer::{shared_buffers_update_system, RenderResourceContext, SharedBuffers},
     RenderStage,
@@ -86,7 +89,7 @@ pub struct WgpuPlugin;
 
 impl Plugin for WgpuPlugin {
     fn build(&self, app: &mut AppBuilder) {
-        let render_system = get_wgpu_render_system(app.resources_mut());
+        let render_system = get_wgpu_render_system(app.world_mut());
         app.add_system_to_stage(RenderStage::Render, render_system.exclusive_system())
             .add_system_to_stage(
                 RenderStage::PostRender,
@@ -94,17 +97,19 @@ impl Plugin for WgpuPlugin {
             );
     }
 }
-pub fn get_wgpu_render_system(resources: &mut Resources) -> impl FnMut(&mut World, &mut Resources) {
-    let options = resources
-        .get_cloned::<WgpuOptions>()
+
+pub fn get_wgpu_render_system(world: &mut World) -> impl FnMut(&mut World) {
+    let options = world
+        .get_resource::<WgpuOptions>()
+        .cloned()
         .unwrap_or_else(WgpuOptions::default);
     let mut wgpu_renderer = future::block_on(WgpuRenderer::new(options));
 
     let resource_context = WgpuRenderResourceContext::new(wgpu_renderer.device.clone());
-    resources.insert::<Box<dyn RenderResourceContext>>(Box::new(resource_context));
-    resources.insert(SharedBuffers::new(4096));
-    move |world, resources| {
-        wgpu_renderer.update(world, resources);
+    world.insert_resource::<Box<dyn RenderResourceContext>>(Box::new(resource_context));
+    world.insert_resource(SharedBuffers::new(4096));
+    move |world| {
+        wgpu_renderer.update(world);
     }
 }
 
@@ -124,7 +129,7 @@ pub enum WgpuBackend {
     Metal,
     Dx12,
     Dx11,
-    GL,
+    Gl,
     BrowserWgpu,
 }
 
@@ -136,7 +141,7 @@ impl WgpuBackend {
                 "metal" => WgpuBackend::Metal,
                 "dx12" => WgpuBackend::Dx12,
                 "dx11" => WgpuBackend::Dx11,
-                "gl" => WgpuBackend::GL,
+                "gl" => WgpuBackend::Gl,
                 "webgpu" => WgpuBackend::BrowserWgpu,
                 other => panic!("Unknown backend: {}", other),
             }
diff --git a/crates/bevy_wgpu/src/renderer/wgpu_render_context.rs b/crates/bevy_wgpu/src/renderer/wgpu_render_context.rs
index 6a061a8148801..6bed9a3095791 100644
--- a/crates/bevy_wgpu/src/renderer/wgpu_render_context.rs
+++ b/crates/bevy_wgpu/src/renderer/wgpu_render_context.rs
@@ -170,7 +170,7 @@ impl RenderContext for WgpuRenderContext {
         &mut self,
         pass_descriptor: &PassDescriptor,
         render_resource_bindings: &RenderResourceBindings,
-        run_pass: &mut dyn Fn(&mut dyn RenderPass),
+        run_pass: &mut dyn FnMut(&mut dyn RenderPass),
     ) {
         if !self.command_encoder.is_some() {
             self.command_encoder.create(&self.device);
diff --git a/crates/bevy_wgpu/src/renderer/wgpu_render_graph_executor.rs b/crates/bevy_wgpu/src/renderer/wgpu_render_graph_executor.rs
index b1fe146cfee74..afc007f3e660a 100644
--- a/crates/bevy_wgpu/src/renderer/wgpu_render_graph_executor.rs
+++ b/crates/bevy_wgpu/src/renderer/wgpu_render_graph_executor.rs
@@ -1,5 +1,5 @@
 use super::{WgpuRenderContext, WgpuRenderResourceContext};
-use bevy_ecs::{Resources, World};
+use bevy_ecs::world::World;
 use bevy_render::{
     render_graph::{Edge, NodeId, ResourceSlots, StageBorrow},
     renderer::RenderResourceContext,
@@ -17,17 +17,19 @@ impl WgpuRenderGraphExecutor {
     pub fn execute(
         &self,
         world: &World,
-        resources: &Resources,
         device: Arc<wgpu::Device>,
         queue: &mut wgpu::Queue,
         stages: &mut [StageBorrow],
     ) {
-        let mut render_resource_context = resources
-            .get_mut::<Box<dyn RenderResourceContext>>()
-            .unwrap();
-        let render_resource_context = render_resource_context
-            .downcast_mut::<WgpuRenderResourceContext>()
-            .unwrap();
+        let render_resource_context = {
+            let context = world
+                .get_resource::<Box<dyn RenderResourceContext>>()
+                .unwrap();
+            context
+                .downcast_ref::<WgpuRenderResourceContext>()
+                .unwrap()
+                .clone()
+        };
         let node_outputs: Arc<RwLock<HashMap<NodeId, ResourceSlots>>> = Default::default();
         for stage in stages.iter_mut() {
             // TODO: sort jobs and slice by "amount of work" / weights
@@ -72,7 +74,6 @@ impl WgpuRenderGraphExecutor {
                         }
                         node_state.node.update(
                             world,
-                            resources,
                             &mut render_context,
                             &node_state.input_slots,
                             &mut node_state.output_slots,
diff --git a/crates/bevy_wgpu/src/wgpu_renderer.rs b/crates/bevy_wgpu/src/wgpu_renderer.rs
index b86746558b269..702d8d487317c 100644
--- a/crates/bevy_wgpu/src/wgpu_renderer.rs
+++ b/crates/bevy_wgpu/src/wgpu_renderer.rs
@@ -4,7 +4,7 @@ use crate::{
     WgpuBackend, WgpuOptions, WgpuPowerOptions,
 };
 use bevy_app::{prelude::*, ManualEventReader};
-use bevy_ecs::{Resources, World};
+use bevy_ecs::world::{Mut, World};
 use bevy_render::{
     render_graph::{DependentNodeStager, RenderGraph, RenderGraphStager},
     renderer::RenderResourceContext,
@@ -29,7 +29,7 @@ impl WgpuRenderer {
             WgpuBackend::Metal => wgpu::BackendBit::METAL,
             WgpuBackend::Dx12 => wgpu::BackendBit::DX12,
             WgpuBackend::Dx11 => wgpu::BackendBit::DX11,
-            WgpuBackend::GL => wgpu::BackendBit::GL,
+            WgpuBackend::Gl => wgpu::BackendBit::GL,
             WgpuBackend::BrowserWgpu => wgpu::BackendBit::BROWSER_WEBGPU,
         };
         let instance = wgpu::Instance::new(backend);
@@ -73,15 +73,16 @@ impl WgpuRenderer {
         }
     }
 
-    pub fn handle_window_created_events(&mut self, resources: &Resources) {
-        let mut render_resource_context = resources
-            .get_mut::<Box<dyn RenderResourceContext>>()
+    pub fn handle_window_created_events(&mut self, world: &mut World) {
+        let world = world.cell();
+        let mut render_resource_context = world
+            .get_resource_mut::<Box<dyn RenderResourceContext>>()
             .unwrap();
         let render_resource_context = render_resource_context
             .downcast_mut::<WgpuRenderResourceContext>()
             .unwrap();
-        let windows = resources.get::<Windows>().unwrap();
-        let window_created_events = resources.get::<Events<WindowCreated>>().unwrap();
+        let windows = world.get_resource::<Windows>().unwrap();
+        let window_created_events = world.get_resource::<Events<WindowCreated>>().unwrap();
         for window_created_event in self
             .window_created_event_reader
             .iter(&window_created_events)
@@ -91,7 +92,7 @@ impl WgpuRenderer {
                 .expect("Received window created event for non-existent window.");
             #[cfg(feature = "bevy_winit")]
             {
-                let winit_windows = resources.get::<bevy_winit::WinitWindows>().unwrap();
+                let winit_windows = world.get_resource::<bevy_winit::WinitWindows>().unwrap();
                 let winit_window = winit_windows.get_window(window.id()).unwrap();
                 let surface = unsafe { self.instance.create_surface(winit_window.deref()) };
                 render_resource_context.set_window_surface(window.id(), surface);
@@ -99,31 +100,29 @@ impl WgpuRenderer {
         }
     }
 
-    pub fn run_graph(&mut self, world: &mut World, resources: &mut Resources) {
-        let mut render_graph = resources.get_mut::<RenderGraph>().unwrap();
-        // stage nodes
-        let mut stager = DependentNodeStager::loose_grouping();
-        let stages = stager.get_stages(&render_graph).unwrap();
-        let mut borrowed = stages.borrow(&mut render_graph);
+    pub fn run_graph(&mut self, world: &mut World) {
+        world.resource_scope(|mut render_graph: Mut<RenderGraph>, world| {
+            render_graph.prepare(world);
+            // stage nodes
+            let mut stager = DependentNodeStager::loose_grouping();
+            let stages = stager.get_stages(&render_graph).unwrap();
+            let mut borrowed = stages.borrow(&mut render_graph);
 
-        // execute stages
-        let graph_executor = WgpuRenderGraphExecutor {
-            max_thread_count: 2,
-        };
-        graph_executor.execute(
-            world,
-            resources,
-            self.device.clone(),
-            &mut self.queue,
-            &mut borrowed,
-        );
+            // execute stages
+            let graph_executor = WgpuRenderGraphExecutor {
+                max_thread_count: 2,
+            };
+            graph_executor.execute(world, self.device.clone(), &mut self.queue, &mut borrowed);
+        })
     }
 
-    pub fn update(&mut self, world: &mut World, resources: &mut Resources) {
-        self.handle_window_created_events(resources);
-        self.run_graph(world, resources);
+    pub fn update(&mut self, world: &mut World) {
+        self.handle_window_created_events(world);
+        self.run_graph(world);
 
-        let render_resource_context = resources.get::<Box<dyn RenderResourceContext>>().unwrap();
+        let render_resource_context = world
+            .get_resource::<Box<dyn RenderResourceContext>>()
+            .unwrap();
         render_resource_context.drop_all_swap_chain_textures();
         render_resource_context.remove_stale_bind_groups();
     }
diff --git a/crates/bevy_window/src/lib.rs b/crates/bevy_window/src/lib.rs
index d01b5f751e640..2df043ac163fa 100644
--- a/crates/bevy_window/src/lib.rs
+++ b/crates/bevy_window/src/lib.rs
@@ -3,7 +3,7 @@ mod system;
 mod window;
 mod windows;
 
-use bevy_ecs::IntoSystem;
+use bevy_ecs::system::IntoSystem;
 pub use event::*;
 pub use system::*;
 pub use window::*;
@@ -51,12 +51,12 @@ impl Plugin for WindowPlugin {
             .init_resource::<Windows>();
 
         if self.add_primary_window {
-            let resources = app.resources();
-            let window_descriptor = resources
-                .get::<WindowDescriptor>()
+            let world = app.world_mut();
+            let window_descriptor = world
+                .get_resource::<WindowDescriptor>()
                 .map(|descriptor| (*descriptor).clone())
                 .unwrap_or_else(WindowDescriptor::default);
-            let mut create_window_event = resources.get_mut::<Events<CreateWindow>>().unwrap();
+            let mut create_window_event = world.get_resource_mut::<Events<CreateWindow>>().unwrap();
             create_window_event.send(CreateWindow {
                 id: WindowId::primary(),
                 descriptor: window_descriptor,
diff --git a/crates/bevy_window/src/system.rs b/crates/bevy_window/src/system.rs
index da857bfe5eebf..900d04e4cb289 100644
--- a/crates/bevy_window/src/system.rs
+++ b/crates/bevy_window/src/system.rs
@@ -3,7 +3,7 @@ use bevy_app::{
     prelude::{EventReader, Events},
     AppExit,
 };
-use bevy_ecs::ResMut;
+use bevy_ecs::system::ResMut;
 
 pub fn exit_on_window_close_system(
     mut app_exit_events: ResMut<Events<AppExit>>,
diff --git a/crates/bevy_winit/src/converters.rs b/crates/bevy_winit/src/converters.rs
index 19d6ed903be5d..9ccdca17f9df7 100644
--- a/crates/bevy_winit/src/converters.rs
+++ b/crates/bevy_winit/src/converters.rs
@@ -190,7 +190,7 @@ pub fn convert_virtual_key_code(virtual_key_code: winit::event::VirtualKeyCode)
         winit::event::VirtualKeyCode::NumpadComma => KeyCode::NumpadComma,
         winit::event::VirtualKeyCode::NumpadEnter => KeyCode::NumpadEnter,
         winit::event::VirtualKeyCode::NumpadEquals => KeyCode::NumpadEquals,
-        winit::event::VirtualKeyCode::OEM102 => KeyCode::OEM102,
+        winit::event::VirtualKeyCode::OEM102 => KeyCode::Oem102,
         winit::event::VirtualKeyCode::Period => KeyCode::Period,
         winit::event::VirtualKeyCode::PlayPause => KeyCode::PlayPause,
         winit::event::VirtualKeyCode::Power => KeyCode::Power,
diff --git a/crates/bevy_winit/src/lib.rs b/crates/bevy_winit/src/lib.rs
index 645b64b1c55dd..47a6e695899e0 100644
--- a/crates/bevy_winit/src/lib.rs
+++ b/crates/bevy_winit/src/lib.rs
@@ -10,8 +10,8 @@ use bevy_input::{
 pub use winit_config::*;
 pub use winit_windows::*;
 
-use bevy_app::{prelude::*, AppExit, ManualEventReader};
-use bevy_ecs::{IntoExclusiveSystem, Resources, World};
+use bevy_app::{App, AppBuilder, AppExit, Events, ManualEventReader, Plugin};
+use bevy_ecs::{system::IntoExclusiveSystem, world::World};
 use bevy_math::{ivec2, Vec2};
 use bevy_utils::tracing::{error, trace, warn};
 use bevy_window::{
@@ -46,9 +46,10 @@ impl Plugin for WinitPlugin {
     }
 }
 
-fn change_window(_: &mut World, resources: &mut Resources) {
-    let winit_windows = resources.get::<WinitWindows>().unwrap();
-    let mut windows = resources.get_mut::<Windows>().unwrap();
+fn change_window(world: &mut World) {
+    let world = world.cell();
+    let winit_windows = world.get_resource::<WinitWindows>().unwrap();
+    let mut windows = world.get_resource_mut::<Windows>().unwrap();
 
     for bevy_window in windows.iter_mut() {
         let id = bevy_window.id();
@@ -81,8 +82,8 @@ fn change_window(_: &mut World, resources: &mut Resources) {
                     window.set_title(&title);
                 }
                 bevy_window::WindowCommand::SetScaleFactor { scale_factor } => {
-                    let mut window_dpi_changed_events = resources
-                        .get_mut::<Events<WindowScaleFactorChanged>>()
+                    let mut window_dpi_changed_events = world
+                        .get_resource_mut::<Events<WindowScaleFactorChanged>>()
                         .unwrap();
                     window_dpi_changed_events.send(WindowScaleFactorChanged { id, scale_factor });
                 }
@@ -224,14 +225,13 @@ pub fn winit_runner_any_thread(app: App) {
 pub fn winit_runner_with(mut app: App, mut event_loop: EventLoop<()>) {
     let mut create_window_event_reader = ManualEventReader::<CreateWindow>::default();
     let mut app_exit_event_reader = ManualEventReader::<AppExit>::default();
-
-    app.resources.insert_non_send(event_loop.create_proxy());
+    app.world.insert_non_send(event_loop.create_proxy());
 
     trace!("Entering winit event loop");
 
     let should_return_from_run = app
-        .resources
-        .get::<WinitConfig>()
+        .world
+        .get_resource::<WinitConfig>()
         .map_or(false, |config| config.return_from_run);
 
     let event_handler = move |event: Event<()>,
@@ -239,7 +239,7 @@ pub fn winit_runner_with(mut app: App, mut event_loop: EventLoop<()>) {
                               control_flow: &mut ControlFlow| {
         *control_flow = ControlFlow::Poll;
 
-        if let Some(app_exit_events) = app.resources.get_mut::<Events<AppExit>>() {
+        if let Some(app_exit_events) = app.world.get_resource_mut::<Events<AppExit>>() {
             if app_exit_event_reader
                 .iter(&app_exit_events)
                 .next_back()
@@ -255,8 +255,9 @@ pub fn winit_runner_with(mut app: App, mut event_loop: EventLoop<()>) {
                 window_id: winit_window_id,
                 ..
             } => {
-                let winit_windows = app.resources.get_mut::<WinitWindows>().unwrap();
-                let mut windows = app.resources.get_mut::<Windows>().unwrap();
+                let world = app.world.cell();
+                let winit_windows = world.get_resource_mut::<WinitWindows>().unwrap();
+                let mut windows = world.get_resource_mut::<Windows>().unwrap();
                 let window_id =
                     if let Some(window_id) = winit_windows.get_window_id(winit_window_id) {
                         window_id
@@ -279,7 +280,7 @@ pub fn winit_runner_with(mut app: App, mut event_loop: EventLoop<()>) {
                     WindowEvent::Resized(size) => {
                         window.update_actual_size_from_backend(size.width, size.height);
                         let mut resize_events =
-                            app.resources.get_mut::<Events<WindowResized>>().unwrap();
+                            world.get_resource_mut::<Events<WindowResized>>().unwrap();
                         resize_events.send(WindowResized {
                             id: window_id,
                             width: window.width(),
@@ -287,20 +288,19 @@ pub fn winit_runner_with(mut app: App, mut event_loop: EventLoop<()>) {
                         });
                     }
                     WindowEvent::CloseRequested => {
-                        let mut window_close_requested_events = app
-                            .resources
-                            .get_mut::<Events<WindowCloseRequested>>()
+                        let mut window_close_requested_events = world
+                            .get_resource_mut::<Events<WindowCloseRequested>>()
                             .unwrap();
                         window_close_requested_events.send(WindowCloseRequested { id: window_id });
                     }
                     WindowEvent::KeyboardInput { ref input, .. } => {
                         let mut keyboard_input_events =
-                            app.resources.get_mut::<Events<KeyboardInput>>().unwrap();
+                            world.get_resource_mut::<Events<KeyboardInput>>().unwrap();
                         keyboard_input_events.send(converters::convert_keyboard_input(input));
                     }
                     WindowEvent::CursorMoved { position, .. } => {
                         let mut cursor_moved_events =
-                            app.resources.get_mut::<Events<CursorMoved>>().unwrap();
+                            world.get_resource_mut::<Events<CursorMoved>>().unwrap();
                         let winit_window = winit_windows.get_window(window_id).unwrap();
                         let position = position.to_logical(winit_window.scale_factor());
                         let inner_size = winit_window
@@ -320,18 +320,19 @@ pub fn winit_runner_with(mut app: App, mut event_loop: EventLoop<()>) {
                     }
                     WindowEvent::CursorEntered { .. } => {
                         let mut cursor_entered_events =
-                            app.resources.get_mut::<Events<CursorEntered>>().unwrap();
+                            world.get_resource_mut::<Events<CursorEntered>>().unwrap();
                         cursor_entered_events.send(CursorEntered { id: window_id });
                     }
                     WindowEvent::CursorLeft { .. } => {
                         let mut cursor_left_events =
-                            app.resources.get_mut::<Events<CursorLeft>>().unwrap();
+                            world.get_resource_mut::<Events<CursorLeft>>().unwrap();
                         window.update_cursor_position_from_backend(None);
                         cursor_left_events.send(CursorLeft { id: window_id });
                     }
                     WindowEvent::MouseInput { state, button, .. } => {
-                        let mut mouse_button_input_events =
-                            app.resources.get_mut::<Events<MouseButtonInput>>().unwrap();
+                        let mut mouse_button_input_events = world
+                            .get_resource_mut::<Events<MouseButtonInput>>()
+                            .unwrap();
                         mouse_button_input_events.send(MouseButtonInput {
                             button: converters::convert_mouse_button(button),
                             state: converters::convert_element_state(state),
@@ -340,7 +341,7 @@ pub fn winit_runner_with(mut app: App, mut event_loop: EventLoop<()>) {
                     WindowEvent::MouseWheel { delta, .. } => match delta {
                         event::MouseScrollDelta::LineDelta(x, y) => {
                             let mut mouse_wheel_input_events =
-                                app.resources.get_mut::<Events<MouseWheel>>().unwrap();
+                                world.get_resource_mut::<Events<MouseWheel>>().unwrap();
                             mouse_wheel_input_events.send(MouseWheel {
                                 unit: MouseScrollUnit::Line,
                                 x,
@@ -349,7 +350,7 @@ pub fn winit_runner_with(mut app: App, mut event_loop: EventLoop<()>) {
                         }
                         event::MouseScrollDelta::PixelDelta(p) => {
                             let mut mouse_wheel_input_events =
-                                app.resources.get_mut::<Events<MouseWheel>>().unwrap();
+                                world.get_resource_mut::<Events<MouseWheel>>().unwrap();
                             mouse_wheel_input_events.send(MouseWheel {
                                 unit: MouseScrollUnit::Pixel,
                                 x: p.x as f32,
@@ -359,7 +360,7 @@ pub fn winit_runner_with(mut app: App, mut event_loop: EventLoop<()>) {
                     },
                     WindowEvent::Touch(touch) => {
                         let mut touch_input_events =
-                            app.resources.get_mut::<Events<TouchInput>>().unwrap();
+                            world.get_resource_mut::<Events<TouchInput>>().unwrap();
 
                         let winit_window = winit_windows.get_window(window_id).unwrap();
                         let mut location = touch.location.to_logical(winit_window.scale_factor());
@@ -372,9 +373,8 @@ pub fn winit_runner_with(mut app: App, mut event_loop: EventLoop<()>) {
                         touch_input_events.send(converters::convert_touch_input(touch, location));
                     }
                     WindowEvent::ReceivedCharacter(c) => {
-                        let mut char_input_events = app
-                            .resources
-                            .get_mut::<Events<ReceivedCharacter>>()
+                        let mut char_input_events = world
+                            .get_resource_mut::<Events<ReceivedCharacter>>()
                             .unwrap();
 
                         char_input_events.send(ReceivedCharacter {
@@ -386,9 +386,8 @@ pub fn winit_runner_with(mut app: App, mut event_loop: EventLoop<()>) {
                         scale_factor,
                         new_inner_size,
                     } => {
-                        let mut backend_scale_factor_change_events = app
-                            .resources
-                            .get_mut::<Events<WindowBackendScaleFactorChanged>>()
+                        let mut backend_scale_factor_change_events = world
+                            .get_resource_mut::<Events<WindowBackendScaleFactorChanged>>()
                             .unwrap();
                         backend_scale_factor_change_events.send(WindowBackendScaleFactorChanged {
                             id: window_id,
@@ -396,9 +395,8 @@ pub fn winit_runner_with(mut app: App, mut event_loop: EventLoop<()>) {
                         });
                         #[allow(clippy::float_cmp)]
                         if window.scale_factor() != scale_factor {
-                            let mut scale_factor_change_events = app
-                                .resources
-                                .get_mut::<Events<WindowScaleFactorChanged>>()
+                            let mut scale_factor_change_events = world
+                                .get_resource_mut::<Events<WindowScaleFactorChanged>>()
                                 .unwrap();
 
                             scale_factor_change_events.send(WindowScaleFactorChanged {
@@ -413,7 +411,7 @@ pub fn winit_runner_with(mut app: App, mut event_loop: EventLoop<()>) {
                             || window.physical_height() != new_inner_size.height
                         {
                             let mut resize_events =
-                                app.resources.get_mut::<Events<WindowResized>>().unwrap();
+                                world.get_resource_mut::<Events<WindowResized>>().unwrap();
                             resize_events.send(WindowResized {
                                 id: window_id,
                                 width: window.width(),
@@ -428,7 +426,7 @@ pub fn winit_runner_with(mut app: App, mut event_loop: EventLoop<()>) {
                     WindowEvent::Focused(focused) => {
                         window.update_focused_status_from_backend(focused);
                         let mut focused_events =
-                            app.resources.get_mut::<Events<WindowFocused>>().unwrap();
+                            world.get_resource_mut::<Events<WindowFocused>>().unwrap();
                         focused_events.send(WindowFocused {
                             id: window_id,
                             focused,
@@ -436,7 +434,7 @@ pub fn winit_runner_with(mut app: App, mut event_loop: EventLoop<()>) {
                     }
                     WindowEvent::DroppedFile(path_buf) => {
                         let mut events =
-                            app.resources.get_mut::<Events<FileDragAndDrop>>().unwrap();
+                            world.get_resource_mut::<Events<FileDragAndDrop>>().unwrap();
                         events.send(FileDragAndDrop::DroppedFile {
                             id: window_id,
                             path_buf,
@@ -444,7 +442,7 @@ pub fn winit_runner_with(mut app: App, mut event_loop: EventLoop<()>) {
                     }
                     WindowEvent::HoveredFile(path_buf) => {
                         let mut events =
-                            app.resources.get_mut::<Events<FileDragAndDrop>>().unwrap();
+                            world.get_resource_mut::<Events<FileDragAndDrop>>().unwrap();
                         events.send(FileDragAndDrop::HoveredFile {
                             id: window_id,
                             path_buf,
@@ -452,13 +450,13 @@ pub fn winit_runner_with(mut app: App, mut event_loop: EventLoop<()>) {
                     }
                     WindowEvent::HoveredFileCancelled => {
                         let mut events =
-                            app.resources.get_mut::<Events<FileDragAndDrop>>().unwrap();
+                            world.get_resource_mut::<Events<FileDragAndDrop>>().unwrap();
                         events.send(FileDragAndDrop::HoveredFileCancelled { id: window_id });
                     }
                     WindowEvent::Moved(position) => {
                         let position = ivec2(position.x, position.y);
                         window.update_actual_position_from_backend(position);
-                        let mut events = app.resources.get_mut::<Events<WindowMoved>>().unwrap();
+                        let mut events = world.get_resource_mut::<Events<WindowMoved>>().unwrap();
                         events.send(WindowMoved {
                             id: window_id,
                             position,
@@ -472,14 +470,14 @@ pub fn winit_runner_with(mut app: App, mut event_loop: EventLoop<()>) {
                 ..
             } => {
                 let mut mouse_motion_events =
-                    app.resources.get_mut::<Events<MouseMotion>>().unwrap();
+                    app.world.get_resource_mut::<Events<MouseMotion>>().unwrap();
                 mouse_motion_events.send(MouseMotion {
                     delta: Vec2::new(delta.0 as f32, delta.1 as f32),
                 });
             }
             event::Event::MainEventsCleared => {
                 handle_create_window_events(
-                    &mut app.resources,
+                    &mut app.world,
                     event_loop,
                     &mut create_window_event_reader,
                 );
@@ -496,14 +494,15 @@ pub fn winit_runner_with(mut app: App, mut event_loop: EventLoop<()>) {
 }
 
 fn handle_create_window_events(
-    resources: &mut Resources,
+    world: &mut World,
     event_loop: &EventLoopWindowTarget<()>,
     create_window_event_reader: &mut ManualEventReader<CreateWindow>,
 ) {
-    let mut winit_windows = resources.get_mut::<WinitWindows>().unwrap();
-    let mut windows = resources.get_mut::<Windows>().unwrap();
-    let create_window_events = resources.get::<Events<CreateWindow>>().unwrap();
-    let mut window_created_events = resources.get_mut::<Events<WindowCreated>>().unwrap();
+    let world = world.cell();
+    let mut winit_windows = world.get_resource_mut::<WinitWindows>().unwrap();
+    let mut windows = world.get_resource_mut::<Windows>().unwrap();
+    let create_window_events = world.get_resource::<Events<CreateWindow>>().unwrap();
+    let mut window_created_events = world.get_resource_mut::<Events<WindowCreated>>().unwrap();
     for create_window_event in create_window_event_reader.iter(&create_window_events) {
         let window = winit_windows.create_window(
             event_loop,
diff --git a/examples/2d/contributors.rs b/examples/2d/contributors.rs
index 041feff06ef10..c5471bf3dfc5e 100644
--- a/examples/2d/contributors.rs
+++ b/examples/2d/contributors.rs
@@ -46,7 +46,7 @@ const COL_SELECTED: Color = Color::WHITE;
 const SHOWCASE_TIMER_SECS: f32 = 3.0;
 
 fn setup(
-    commands: &mut Commands,
+    mut commands: Commands,
     asset_server: Res<AssetServer>,
     mut materials: ResMut<Assets<ColorMaterial>>,
 ) {
@@ -144,8 +144,8 @@ fn setup(
 fn select_system(
     mut materials: ResMut<Assets<ColorMaterial>>,
     mut sel: ResMut<ContributorSelection>,
-    mut dq: Query<Mut<Text>, With<ContributorDisplay>>,
-    mut tq: Query<Mut<Timer>, With<SelectTimer>>,
+    mut dq: Query<&mut Text, With<ContributorDisplay>>,
+    mut tq: Query<&mut Timer, With<SelectTimer>>,
     mut q: Query<(&Contributor, &Handle<ColorMaterial>, &mut Transform)>,
     time: Res<Time>,
 ) {
@@ -232,7 +232,7 @@ fn deselect(
 }
 
 /// Applies gravity to all entities with velocity
-fn velocity_system(time: Res<Time>, mut q: Query<Mut<Velocity>>) {
+fn velocity_system(time: Res<Time>, mut q: Query<&mut Velocity>) {
     let delta = time.delta_seconds();
 
     for mut v in q.iter_mut() {
@@ -247,7 +247,7 @@ fn velocity_system(time: Res<Time>, mut q: Query<Mut<Velocity>>) {
 /// force.
 fn collision_system(
     wins: Res<Windows>,
-    mut q: Query<(Mut<Velocity>, Mut<Transform>), With<Contributor>>,
+    mut q: Query<(&mut Velocity, &mut Transform), With<Contributor>>,
 ) {
     let mut rnd = rand::thread_rng();
 
@@ -289,7 +289,7 @@ fn collision_system(
 }
 
 /// Apply velocity to positions and rotations.
-fn move_system(time: Res<Time>, mut q: Query<(&Velocity, Mut<Transform>)>) {
+fn move_system(time: Res<Time>, mut q: Query<(&Velocity, &mut Transform)>) {
     let delta = time.delta_seconds();
 
     for (v, mut t) in q.iter_mut() {
diff --git a/examples/2d/sprite.rs b/examples/2d/sprite.rs
index 6392ce606d69d..c2bbe4ebfe4a1 100644
--- a/examples/2d/sprite.rs
+++ b/examples/2d/sprite.rs
@@ -8,7 +8,7 @@ fn main() {
 }
 
 fn setup(
-    commands: &mut Commands,
+    mut commands: Commands,
     asset_server: Res<AssetServer>,
     mut materials: ResMut<Assets<ColorMaterial>>,
 ) {
diff --git a/examples/2d/sprite_flipping.rs b/examples/2d/sprite_flipping.rs
index 3f382f36bba6f..6db1c759f1164 100644
--- a/examples/2d/sprite_flipping.rs
+++ b/examples/2d/sprite_flipping.rs
@@ -8,7 +8,7 @@ fn main() {
 }
 
 fn setup(
-    commands: &mut Commands,
+    mut commands: Commands,
     asset_server: Res<AssetServer>,
     mut materials: ResMut<Assets<ColorMaterial>>,
 ) {
diff --git a/examples/2d/sprite_sheet.rs b/examples/2d/sprite_sheet.rs
index 155401cc120d7..ca72ab3566c90 100644
--- a/examples/2d/sprite_sheet.rs
+++ b/examples/2d/sprite_sheet.rs
@@ -23,7 +23,7 @@ fn animate_sprite_system(
 }
 
 fn setup(
-    commands: &mut Commands,
+    mut commands: Commands,
     asset_server: Res<AssetServer>,
     mut texture_atlases: ResMut<Assets<TextureAtlas>>,
 ) {
diff --git a/examples/2d/text2d.rs b/examples/2d/text2d.rs
index f5d91c8a5172f..22c9f156e7361 100644
--- a/examples/2d/text2d.rs
+++ b/examples/2d/text2d.rs
@@ -8,7 +8,7 @@ fn main() {
         .run();
 }
 
-fn setup(commands: &mut Commands, asset_server: Res<AssetServer>) {
+fn setup(mut commands: Commands, asset_server: Res<AssetServer>) {
     commands
         // 2d camera
         .spawn(OrthographicCameraBundle::new_2d())
diff --git a/examples/2d/texture_atlas.rs b/examples/2d/texture_atlas.rs
index ed5bdd1ea00fa..6220f0722ed9b 100644
--- a/examples/2d/texture_atlas.rs
+++ b/examples/2d/texture_atlas.rs
@@ -44,7 +44,7 @@ fn check_textures(
 }
 
 fn setup(
-    commands: &mut Commands,
+    mut commands: Commands,
     rpg_sprite_handles: Res<RpgSpriteHandles>,
     asset_server: Res<AssetServer>,
     mut texture_atlases: ResMut<Assets<TextureAtlas>>,
diff --git a/examples/3d/3d_scene.rs b/examples/3d/3d_scene.rs
index 0d90a55ada4bf..7567dc4cc9538 100644
--- a/examples/3d/3d_scene.rs
+++ b/examples/3d/3d_scene.rs
@@ -10,7 +10,7 @@ fn main() {
 
 /// set up a simple 3D scene
 fn setup(
-    commands: &mut Commands,
+    mut commands: Commands,
     mut meshes: ResMut<Assets<Mesh>>,
     mut materials: ResMut<Assets<StandardMaterial>>,
 ) {
diff --git a/examples/3d/load_gltf.rs b/examples/3d/load_gltf.rs
index de2539c49e6ba..71e1631627938 100644
--- a/examples/3d/load_gltf.rs
+++ b/examples/3d/load_gltf.rs
@@ -8,7 +8,7 @@ fn main() {
         .run();
 }
 
-fn setup(commands: &mut Commands, asset_server: Res<AssetServer>) {
+fn setup(mut commands: Commands, asset_server: Res<AssetServer>) {
     commands
         .spawn_scene(asset_server.load("models/FlightHelmet/FlightHelmet.gltf#Scene0"))
         .spawn(LightBundle {
diff --git a/examples/3d/msaa.rs b/examples/3d/msaa.rs
index 3df110f66cd16..d0c97441f049b 100644
--- a/examples/3d/msaa.rs
+++ b/examples/3d/msaa.rs
@@ -13,7 +13,7 @@ fn main() {
 
 /// set up a simple 3D scene
 fn setup(
-    commands: &mut Commands,
+    mut commands: Commands,
     mut meshes: ResMut<Assets<Mesh>>,
     mut materials: ResMut<Assets<StandardMaterial>>,
 ) {
diff --git a/examples/3d/orthographic.rs b/examples/3d/orthographic.rs
index 82c3ee09d3245..c609b5d024030 100644
--- a/examples/3d/orthographic.rs
+++ b/examples/3d/orthographic.rs
@@ -10,7 +10,7 @@ fn main() {
 
 /// set up a simple 3D scene
 fn setup(
-    commands: &mut Commands,
+    mut commands: Commands,
     mut meshes: ResMut<Assets<Mesh>>,
     mut materials: ResMut<Assets<StandardMaterial>>,
 ) {
diff --git a/examples/3d/parenting.rs b/examples/3d/parenting.rs
index 76bc9ec918791..11cc023bf3ee0 100644
--- a/examples/3d/parenting.rs
+++ b/examples/3d/parenting.rs
@@ -23,7 +23,7 @@ fn rotator_system(time: Res<Time>, mut query: Query<&mut Transform, With<Rotator
 
 /// set up a simple scene with a "parent" cube and a "child" cube
 fn setup(
-    commands: &mut Commands,
+    mut commands: Commands,
     mut meshes: ResMut<Assets<Mesh>>,
     mut materials: ResMut<Assets<StandardMaterial>>,
 ) {
diff --git a/examples/3d/spawner.rs b/examples/3d/spawner.rs
index 978aaec3663c5..1433abb984ed3 100644
--- a/examples/3d/spawner.rs
+++ b/examples/3d/spawner.rs
@@ -32,7 +32,7 @@ fn move_cubes(
 }
 
 fn setup(
-    commands: &mut Commands,
+    mut commands: Commands,
     mut meshes: ResMut<Assets<Mesh>>,
     mut materials: ResMut<Assets<StandardMaterial>>,
 ) {
diff --git a/examples/3d/texture.rs b/examples/3d/texture.rs
index 32d0a929d9073..008ee92a748b1 100644
--- a/examples/3d/texture.rs
+++ b/examples/3d/texture.rs
@@ -10,7 +10,7 @@ fn main() {
 
 /// sets up a scene with textured entities
 fn setup(
-    commands: &mut Commands,
+    mut commands: Commands,
     asset_server: Res<AssetServer>,
     mut meshes: ResMut<Assets<Mesh>>,
     mut materials: ResMut<Assets<StandardMaterial>>,
diff --git a/examples/3d/update_gltf_scene.rs b/examples/3d/update_gltf_scene.rs
index e8d37707fcf2e..fd04e60e3bd50 100644
--- a/examples/3d/update_gltf_scene.rs
+++ b/examples/3d/update_gltf_scene.rs
@@ -19,7 +19,7 @@ struct SceneInstance(Option<InstanceId>);
 struct EntityInMyScene;
 
 fn setup(
-    commands: &mut Commands,
+    mut commands: Commands,
     asset_server: Res<AssetServer>,
     mut scene_spawner: ResMut<SceneSpawner>,
     mut scene_instance: ResMut<SceneInstance>,
@@ -56,7 +56,7 @@ fn setup(
 // the scene with `EntityInMyScene`. All entities from the second scene will be
 // tagged
 fn scene_update(
-    commands: &mut Commands,
+    mut commands: Commands,
     scene_spawner: Res<SceneSpawner>,
     scene_instance: Res<SceneInstance>,
     mut done: Local<bool>,
@@ -65,7 +65,7 @@ fn scene_update(
         if let Some(instance_id) = scene_instance.0 {
             if let Some(entity_iter) = scene_spawner.iter_instance_entities(instance_id) {
                 entity_iter.for_each(|entity| {
-                    commands.insert_one(entity, EntityInMyScene);
+                    commands.insert(entity, EntityInMyScene);
                 });
                 *done = true;
             }
diff --git a/examples/3d/wireframe.rs b/examples/3d/wireframe.rs
index 51e9e8c292014..be0b554dae124 100644
--- a/examples/3d/wireframe.rs
+++ b/examples/3d/wireframe.rs
@@ -22,7 +22,7 @@ fn main() {
 
 /// set up a simple 3D scene
 fn setup(
-    commands: &mut Commands,
+    mut commands: Commands,
     mut wireframe_config: ResMut<WireframeConfig>,
     mut meshes: ResMut<Assets<Mesh>>,
     mut materials: ResMut<Assets<StandardMaterial>>,
diff --git a/examples/3d/z_sort_debug.rs b/examples/3d/z_sort_debug.rs
index dc72199bba8de..0abc3000947db 100644
--- a/examples/3d/z_sort_debug.rs
+++ b/examples/3d/z_sort_debug.rs
@@ -42,7 +42,7 @@ fn camera_order_color_system(
 }
 
 fn setup(
-    commands: &mut Commands,
+    mut commands: Commands,
     mut meshes: ResMut<Assets<Mesh>>,
     mut materials: ResMut<Assets<StandardMaterial>>,
 ) {
diff --git a/examples/android/android.rs b/examples/android/android.rs
index 51af3e855bd6b..b04045497f0c4 100644
--- a/examples/android/android.rs
+++ b/examples/android/android.rs
@@ -12,7 +12,7 @@ fn main() {
 
 /// set up a simple 3D scene
 fn setup(
-    commands: &mut Commands,
+    mut commands: Commands,
     mut meshes: ResMut<Assets<Mesh>>,
     mut materials: ResMut<Assets<StandardMaterial>>,
 ) {
diff --git a/examples/app/custom_loop.rs b/examples/app/custom_loop.rs
index 008e0933c2792..a210140365f4d 100644
--- a/examples/app/custom_loop.rs
+++ b/examples/app/custom_loop.rs
@@ -9,7 +9,7 @@ fn my_runner(mut app: App) {
     println!("Type stuff into the console");
     for line in io::stdin().lock().lines() {
         {
-            let mut input = app.resources.get_mut::<Input>().unwrap();
+            let mut input = app.world.get_resource_mut::<Input>().unwrap();
             input.0 = line.unwrap();
         }
         app.update();
diff --git a/examples/asset/asset_loading.rs b/examples/asset/asset_loading.rs
index 3f8407ca6a5ca..25fe86c2597b1 100644
--- a/examples/asset/asset_loading.rs
+++ b/examples/asset/asset_loading.rs
@@ -10,7 +10,7 @@ fn main() {
 }
 
 fn setup(
-    commands: &mut Commands,
+    mut commands: Commands,
     asset_server: Res<AssetServer>,
     meshes: Res<Assets<Mesh>>,
     mut materials: ResMut<Assets<StandardMaterial>>,
diff --git a/examples/asset/custom_asset_io.rs b/examples/asset/custom_asset_io.rs
index bd2e472ff7065..729e81b833a4d 100644
--- a/examples/asset/custom_asset_io.rs
+++ b/examples/asset/custom_asset_io.rs
@@ -50,8 +50,8 @@ impl Plugin for CustomAssetIoPlugin {
         // must get a hold of the task pool in order to create the asset server
 
         let task_pool = app
-            .resources()
-            .get::<bevy::tasks::IoTaskPool>()
+            .world()
+            .get_resource::<bevy::tasks::IoTaskPool>()
             .expect("`IoTaskPool` resource not found.")
             .0
             .clone();
@@ -90,7 +90,7 @@ fn main() {
 }
 
 fn setup(
-    commands: &mut Commands,
+    mut commands: Commands,
     asset_server: Res<AssetServer>,
     mut materials: ResMut<Assets<ColorMaterial>>,
 ) {
diff --git a/examples/asset/hot_asset_reloading.rs b/examples/asset/hot_asset_reloading.rs
index b27ba6de82106..e80d365296c71 100644
--- a/examples/asset/hot_asset_reloading.rs
+++ b/examples/asset/hot_asset_reloading.rs
@@ -10,7 +10,7 @@ fn main() {
         .run();
 }
 
-fn setup(commands: &mut Commands, asset_server: Res<AssetServer>) {
+fn setup(mut commands: Commands, asset_server: Res<AssetServer>) {
     // Load our mesh:
     let scene_handle = asset_server.load("models/monkey/Monkey.gltf#Scene0");
 
diff --git a/examples/ecs/change_detection.rs b/examples/ecs/change_detection.rs
index 9a2a06e709f62..2e2f40478869a 100644
--- a/examples/ecs/change_detection.rs
+++ b/examples/ecs/change_detection.rs
@@ -15,7 +15,7 @@ fn main() {
 #[derive(Debug)]
 struct MyComponent(f64);
 
-fn setup(commands: &mut Commands) {
+fn setup(mut commands: Commands) {
     commands.spawn((MyComponent(0.),));
     commands.spawn((Transform::default(),));
 }
@@ -38,16 +38,8 @@ fn change_detection(query: Query<(Entity, &MyComponent), Changed<MyComponent>>)
 }
 
 // By looking at flags, the query is not filtered but the information is available
-fn flags_monitoring(query: Query<(Entity, Option<&MyComponent>, Flags<MyComponent>)>) {
+fn flags_monitoring(query: Query<(Entity, Option<&MyComponent>, Option<Flags<MyComponent>>)>) {
     for (entity, component, flags) in query.iter() {
-        info!(
-            "{:?}: {:?} -> with: {:?} - added: {:?} - mutated: {:?} - changed: {:?}",
-            entity,
-            component,
-            flags.with(),
-            flags.added(),
-            flags.mutated(),
-            flags.changed()
-        );
+        info!("{:?}: {:?} -> {:?}", entity, component, flags,);
     }
 }
diff --git a/examples/ecs/ecs_guide.rs b/examples/ecs/ecs_guide.rs
index 030bcf0c6d1fe..44096dedd65f4 100644
--- a/examples/ecs/ecs_guide.rs
+++ b/examples/ecs/ecs_guide.rs
@@ -1,6 +1,6 @@
 use bevy::{
     app::{AppExit, ScheduleRunnerPlugin, ScheduleRunnerSettings},
-    ecs::SystemStage,
+    ecs::schedule::ReportExecutionOrderAmbiguities,
     prelude::*,
     utils::Duration,
 };
@@ -141,7 +141,7 @@ fn game_over_system(
 // the initial "state" of our game. The only thing that distinguishes a "startup" system from a "normal" system is how it is registered:
 //      Startup: app.add_startup_system(startup_system)
 //      Normal:  app.add_system(normal_system)
-fn startup_system(commands: &mut Commands, mut game_state: ResMut<GameState>) {
+fn startup_system(mut commands: Commands, mut game_state: ResMut<GameState>) {
     // Create our game rules resource
     commands.insert_resource(GameRules {
         max_rounds: 10,
@@ -174,7 +174,7 @@ fn startup_system(commands: &mut Commands, mut game_state: ResMut<GameState>) {
 // Our World contains all of our components, so mutating arbitrary parts of it in parallel is not thread safe.
 // Command buffers give us the ability to queue up changes to our World without directly accessing it
 fn new_player_system(
-    commands: &mut Commands,
+    mut commands: Commands,
     game_rules: Res<GameRules>,
     mut game_state: ResMut<GameState>,
 ) {
@@ -198,20 +198,24 @@ fn new_player_system(
 // WARNING: These will block all parallel execution of other systems until they finish, so they should generally be avoided if you
 // care about performance
 #[allow(dead_code)]
-fn thread_local_system(world: &mut World, resources: &mut Resources) {
+fn thread_local_system(world: &mut World) {
     // this does the same thing as "new_player_system"
-    let mut game_state = resources.get_mut::<GameState>().unwrap();
-    let game_rules = resources.get::<GameRules>().unwrap();
+    let total_players = world.get_resource_mut::<GameState>().unwrap().total_players;
+    let should_add_player = {
+        let game_rules = world.get_resource::<GameRules>().unwrap();
+        let add_new_player = random::<bool>();
+        add_new_player && total_players < game_rules.max_players
+    };
     // Randomly add a new player
-    let add_new_player = random::<bool>();
-    if add_new_player && game_state.total_players < game_rules.max_players {
-        world.spawn((
+    if should_add_player {
+        world.spawn().insert_bundle((
             Player {
-                name: format!("Player {}", game_state.total_players),
+                name: format!("Player {}", total_players),
             },
             Score { value: 0 },
         ));
 
+        let mut game_state = world.get_resource_mut::<GameState>().unwrap();
         game_state.total_players += 1;
     }
 }
diff --git a/examples/ecs/hierarchy.rs b/examples/ecs/hierarchy.rs
index 875bd7a9cd32d..48edf2cda5c1b 100644
--- a/examples/ecs/hierarchy.rs
+++ b/examples/ecs/hierarchy.rs
@@ -9,7 +9,7 @@ fn main() {
 }
 
 fn setup(
-    commands: &mut Commands,
+    mut commands: Commands,
     asset_server: Res<AssetServer>,
     mut materials: ResMut<Assets<ColorMaterial>>,
 ) {
@@ -89,7 +89,7 @@ fn setup(
 
 // A simple system to rotate the root entity, and rotate all its children separately
 fn rotate(
-    commands: &mut Commands,
+    mut commands: Commands,
     time: Res<Time>,
     mut parents_query: Query<(Entity, &Children), With<Sprite>>,
     mut transform_query: Query<&mut Transform, With<Sprite>>,
diff --git a/examples/ecs/parallel_query.rs b/examples/ecs/parallel_query.rs
index 17296707cd871..e9c526810ced2 100644
--- a/examples/ecs/parallel_query.rs
+++ b/examples/ecs/parallel_query.rs
@@ -4,7 +4,7 @@ use rand::random;
 struct Velocity(Vec2);
 
 fn spawn_system(
-    commands: &mut Commands,
+    mut commands: Commands,
     asset_server: Res<AssetServer>,
     mut materials: ResMut<Assets<ColorMaterial>>,
 ) {
@@ -34,11 +34,9 @@ fn move_system(pool: Res<ComputeTaskPool>, mut sprites: Query<(&mut Transform, &
     // elements will not typically be faster than just using a normal Iterator.
     // See the ParallelIterator documentation for more information on when
     // to use or not use ParallelIterator over a normal Iterator.
-    sprites
-        .par_iter_mut(32)
-        .for_each(&pool, |(mut transform, velocity)| {
-            transform.translation += velocity.0.extend(0.0);
-        });
+    sprites.par_for_each_mut(&pool, 32, |(mut transform, velocity)| {
+        transform.translation += velocity.0.extend(0.0);
+    });
 }
 
 // Bounce sprites outside the window
@@ -57,17 +55,15 @@ fn bounce_system(
     sprites
         // Batch size of 32 is chosen to limit the overhead of
         // ParallelIterator, since negating a vector is very inexpensive.
-        .par_iter_mut(32)
-        // Filter out sprites that don't need to be bounced
-        .filter(|(transform, _)| {
-            !(left < transform.translation.x
+        .par_for_each_mut(&pool, 32, |(transform, mut v)| {
+            if !(left < transform.translation.x
                 && transform.translation.x < right
                 && bottom < transform.translation.y
                 && transform.translation.y < top)
-        })
-        // For simplicity, just reverse the velocity; don't use realistic bounces
-        .for_each(&pool, |(_, mut v)| {
-            v.0 = -v.0;
+            {
+                // For simplicity, just reverse the velocity; don't use realistic bounces
+                v.0 = -v.0;
+            }
         });
 }
 
diff --git a/examples/ecs/removal_detection.rs b/examples/ecs/removal_detection.rs
index 4a329ce42642e..2692a27534ed6 100644
--- a/examples/ecs/removal_detection.rs
+++ b/examples/ecs/removal_detection.rs
@@ -26,7 +26,7 @@ fn main() {
 struct MyComponent;
 
 fn setup(
-    commands: &mut Commands,
+    mut commands: Commands,
     asset_server: Res<AssetServer>,
     mut materials: ResMut<Assets<ColorMaterial>>,
 ) {
@@ -43,31 +43,32 @@ fn setup(
 
 fn remove_component(
     time: Res<Time>,
-    commands: &mut Commands,
+    mut commands: Commands,
     query: Query<Entity, With<MyComponent>>,
 ) {
     // After two seconds have passed the `Component` is removed.
     if time.seconds_since_startup() > 2.0 {
         if let Some(entity) = query.iter().next() {
-            commands.remove_one::<MyComponent>(entity);
+            commands.remove::<MyComponent>(entity);
         }
     }
 }
 
 fn react_on_removal(
     mut materials: ResMut<Assets<ColorMaterial>>,
+    removed: RemovedComponents<MyComponent>,
     query: Query<(Entity, &Handle<ColorMaterial>)>,
 ) {
     // Note: usually this isn't how you would handle a `Query`. In this example it makes things
     // a bit easier to read.
     let (query_entity, material) = query.iter().next().unwrap();
 
-    // `Query.removed<T>` returns an array with the `Entity`s in the `Query` that had its
+    // `RemovedComponents<T>::iter()` returns an interator with the `Entity`s that had their
     // `Component` `T` (in this case `MyComponent`) removed at some point earlier during the frame.
-    for entity in query.removed::<MyComponent>() {
+    for entity in removed.iter() {
         // We compare the `Entity` that had its `MyComponent` `Component` removed with the `Entity`
         // in the current `Query`. If they match all red is removed from the material.
-        if query_entity == *entity {
+        if query_entity == entity {
             materials.get_mut(material).unwrap().color.set_r(0.0);
         }
     }
diff --git a/examples/ecs/state.rs b/examples/ecs/state.rs
index e3124f7b5dbf9..2a7dec07b6f39 100644
--- a/examples/ecs/state.rs
+++ b/examples/ecs/state.rs
@@ -30,7 +30,7 @@ struct MenuData {
 }
 
 fn setup_menu(
-    commands: &mut Commands,
+    mut commands: Commands,
     asset_server: Res<AssetServer>,
     button_materials: Res<ButtonMaterials>,
 ) {
@@ -94,12 +94,12 @@ fn menu(
     }
 }
 
-fn cleanup_menu(commands: &mut Commands, menu_data: Res<MenuData>) {
+fn cleanup_menu(mut commands: Commands, menu_data: Res<MenuData>) {
     commands.despawn_recursive(menu_data.button_entity);
 }
 
 fn setup_game(
-    commands: &mut Commands,
+    mut commands: Commands,
     asset_server: Res<AssetServer>,
     mut materials: ResMut<Assets<ColorMaterial>>,
 ) {
@@ -158,9 +158,9 @@ struct ButtonMaterials {
     pressed: Handle<ColorMaterial>,
 }
 
-impl FromResources for ButtonMaterials {
-    fn from_resources(resources: &Resources) -> Self {
-        let mut materials = resources.get_mut::<Assets<ColorMaterial>>().unwrap();
+impl FromWorld for ButtonMaterials {
+    fn from_world(world: &mut World) -> Self {
+        let mut materials = world.get_resource_mut::<Assets<ColorMaterial>>().unwrap();
         ButtonMaterials {
             normal: materials.add(Color::rgb(0.15, 0.15, 0.15).into()),
             hovered: materials.add(Color::rgb(0.25, 0.25, 0.25).into()),
diff --git a/examples/ecs/system_param.rs b/examples/ecs/system_param.rs
index da69d25742366..aa6497dadbdbc 100644
--- a/examples/ecs/system_param.rs
+++ b/examples/ecs/system_param.rs
@@ -1,4 +1,4 @@
-use bevy::{ecs::SystemParam, prelude::*};
+use bevy::{ecs::system::SystemParam, prelude::*};
 
 /// This example creates a SystemParam struct that counts the number of players
 fn main() {
@@ -9,8 +9,8 @@ fn main() {
         .run();
 }
 
-struct Player;
-struct PlayerCount(usize);
+pub struct Player;
+pub struct PlayerCount(usize);
 
 /// The SystemParam struct can contain any types that can also be included in a
 /// system function signature.
@@ -18,7 +18,7 @@ struct PlayerCount(usize);
 /// In this example, it includes a query and a mutable resource.
 #[derive(SystemParam)]
 pub struct PlayerCounter<'a> {
-    players: Query<'a, &'a Player>,
+    players: Query<'a, &'static Player>,
     count: ResMut<'a, PlayerCount>,
 }
 
@@ -29,7 +29,7 @@ impl<'a> PlayerCounter<'a> {
 }
 
 /// Spawn some players to count
-fn spawn(commands: &mut Commands) {
+fn spawn(mut commands: Commands) {
     commands.spawn((Player,));
     commands.spawn((Player,));
     commands.spawn((Player,));
diff --git a/examples/ecs/timers.rs b/examples/ecs/timers.rs
index 11bba57db9b45..f27ae8fa571f2 100644
--- a/examples/ecs/timers.rs
+++ b/examples/ecs/timers.rs
@@ -30,7 +30,7 @@ impl Default for Countdown {
     }
 }
 
-fn setup_system(commands: &mut Commands) {
+fn setup_system(mut commands: Commands) {
     // Add an entity to the world with a timer
     commands.spawn((Timer::from_seconds(5.0, false),));
 }
diff --git a/examples/game/alien_cake_addict.rs b/examples/game/alien_cake_addict.rs
index dfa34bd448a18..1d1d306169aec 100644
--- a/examples/game/alien_cake_addict.rs
+++ b/examples/game/alien_cake_addict.rs
@@ -99,7 +99,7 @@ const RESET_FOCUS: [f32; 3] = [
     BOARD_SIZE_J as f32 / 2.0 - 0.5,
 ];
 
-fn setup_cameras(commands: &mut Commands, mut game: ResMut<Game>) {
+fn setup_cameras(mut commands: Commands, mut game: ResMut<Game>) {
     game.camera_should_focus = Vec3::from(RESET_FOCUS);
     game.camera_is_focus = game.camera_should_focus;
     commands
@@ -115,7 +115,7 @@ fn setup_cameras(commands: &mut Commands, mut game: ResMut<Game>) {
         .spawn(UiCameraBundle::default());
 }
 
-fn setup(commands: &mut Commands, asset_server: Res<AssetServer>, mut game: ResMut<Game>) {
+fn setup(mut commands: Commands, asset_server: Res<AssetServer>, mut game: ResMut<Game>) {
     // reset the game state
     game.cake_eaten = 0;
     game.score = 0;
@@ -195,7 +195,7 @@ fn setup(commands: &mut Commands, asset_server: Res<AssetServer>, mut game: ResM
 }
 
 // remove all entities that are not a camera
-fn teardown(commands: &mut Commands, entities: Query<Entity, Without<Camera>>) {
+fn teardown(mut commands: Commands, entities: Query<Entity, Without<Camera>>) {
     for entity in entities.iter() {
         commands.despawn_recursive(entity);
     }
@@ -203,7 +203,7 @@ fn teardown(commands: &mut Commands, entities: Query<Entity, Without<Camera>>) {
 
 // control the game character
 fn move_player(
-    commands: &mut Commands,
+    mut commands: Commands,
     keyboard_input: Res<Input<KeyCode>>,
     mut game: ResMut<Game>,
     mut transforms: Query<&mut Transform>,
@@ -309,7 +309,7 @@ fn focus_camera(
 // despawn the bonus if there is one, then spawn a new one at a random location
 fn spawn_bonus(
     mut state: ResMut<State<GameState>>,
-    commands: &mut Commands,
+    mut commands: Commands,
     mut game: ResMut<Game>,
 ) {
     if *state.current() != GameState::Playing {
@@ -371,7 +371,7 @@ fn gameover_keyboard(mut state: ResMut<State<GameState>>, keyboard_input: Res<In
 
 // display the number of cake eaten before losing
 fn display_score(
-    commands: &mut Commands,
+    mut commands: Commands,
     asset_server: Res<AssetServer>,
     game: Res<Game>,
     mut materials: ResMut<Assets<ColorMaterial>>,
diff --git a/examples/game/breakout.rs b/examples/game/breakout.rs
index 0ca195d602162..1cd312439a429 100644
--- a/examples/game/breakout.rs
+++ b/examples/game/breakout.rs
@@ -37,7 +37,7 @@ enum Collider {
 }
 
 fn setup(
-    commands: &mut Commands,
+    mut commands: Commands,
     mut materials: ResMut<Assets<ColorMaterial>>,
     asset_server: Res<AssetServer>,
 ) {
@@ -208,7 +208,7 @@ fn scoreboard_system(scoreboard: Res<Scoreboard>, mut query: Query<&mut Text>) {
 }
 
 fn ball_collision_system(
-    commands: &mut Commands,
+    mut commands: Commands,
     mut scoreboard: ResMut<Scoreboard>,
     mut ball_query: Query<(&mut Ball, &Transform, &Sprite)>,
     collider_query: Query<(Entity, &Collider, &Transform, &Sprite)>,
diff --git a/examples/ios/src/lib.rs b/examples/ios/src/lib.rs
index cbc8fe9b2ca1a..0f7aa3090e004 100644
--- a/examples/ios/src/lib.rs
+++ b/examples/ios/src/lib.rs
@@ -17,7 +17,7 @@ fn main() {
 }
 /// set up a simple 3D scene
 fn setup(
-    commands: &mut Commands,
+    mut commands: Commands,
     mut meshes: ResMut<Assets<Mesh>>,
     mut materials: ResMut<Assets<StandardMaterial>>,
 ) {
diff --git a/examples/scene/scene.rs b/examples/scene/scene.rs
index 48eaae999b533..e83cce9e32a15 100644
--- a/examples/scene/scene.rs
+++ b/examples/scene/scene.rs
@@ -37,9 +37,9 @@ struct ComponentB {
     pub time_since_startup: Duration,
 }
 
-impl FromResources for ComponentB {
-    fn from_resources(resources: &Resources) -> Self {
-        let time = resources.get::<Time>().unwrap();
+impl FromWorld for ComponentB {
+    fn from_world(world: &mut World) -> Self {
+        let time = world.get_resource::<Time>().unwrap();
         ComponentB {
             time_since_startup: time.time_since_startup(),
             value: "Default Value".to_string(),
@@ -72,22 +72,23 @@ fn print_system(query: Query<(Entity, &ComponentA), Changed<ComponentA>>) {
     }
 }
 
-fn save_scene_system(_world: &mut World, resources: &mut Resources) {
+fn save_scene_system(world: &mut World) {
     // Scenes can be created from any ECS World. You can either create a new one for the scene or use the current World.
-    let mut world = World::new();
-    world.spawn((
+    let mut scene_world = World::new();
+    let mut component_b = ComponentB::from_world(world);
+    component_b.value = "hello".to_string();
+    scene_world.spawn().insert_bundle((
+        component_b,
         ComponentA { x: 1.0, y: 2.0 },
-        ComponentB {
-            value: "hello".to_string(),
-            ..ComponentB::from_resources(resources)
-        },
         Transform::default(),
     ));
-    world.spawn((ComponentA { x: 3.0, y: 4.0 },));
+    scene_world
+        .spawn()
+        .insert_bundle((ComponentA { x: 3.0, y: 4.0 },));
 
     // The TypeRegistry resource contains information about all registered types (including components). This is used to construct scenes.
-    let type_registry = resources.get::<TypeRegistry>().unwrap();
-    let scene = DynamicScene::from_world(&world, &type_registry);
+    let type_registry = world.get_resource::<TypeRegistry>().unwrap();
+    let scene = DynamicScene::from_world(&scene_world, &type_registry);
 
     // Scenes can be serialized like this:
     println!("{}", scene.serialize_ron(&type_registry).unwrap());
@@ -96,7 +97,7 @@ fn save_scene_system(_world: &mut World, resources: &mut Resources) {
 }
 
 // This is only necessary for the info message in the UI. See examples/ui/text.rs for a standalone text example.
-fn infotext_system(commands: &mut Commands, asset_server: Res<AssetServer>) {
+fn infotext_system(mut commands: Commands, asset_server: Res<AssetServer>) {
     commands.spawn(UiCameraBundle::default()).spawn(TextBundle {
         style: Style {
             align_self: AlignSelf::FlexEnd,
diff --git a/examples/shader/array_texture.rs b/examples/shader/array_texture.rs
index 43912ab0853fb..cd639971fdb32 100644
--- a/examples/shader/array_texture.rs
+++ b/examples/shader/array_texture.rs
@@ -80,7 +80,7 @@ struct LoadingTexture(Option<Handle<Texture>>);
 struct MyPipeline(Handle<PipelineDescriptor>);
 
 fn setup(
-    commands: &mut Commands,
+    mut commands: Commands,
     asset_server: Res<AssetServer>,
     mut pipelines: ResMut<Assets<PipelineDescriptor>>,
     mut shaders: ResMut<Assets<Shader>>,
@@ -116,7 +116,7 @@ fn setup(
 }
 
 fn create_array_texture(
-    commands: &mut Commands,
+    mut commands: Commands,
     my_pipeline: Res<MyPipeline>,
     mut loading_texture: ResMut<LoadingTexture>,
     mut textures: ResMut<Assets<Texture>>,
diff --git a/examples/shader/hot_shader_reloading.rs b/examples/shader/hot_shader_reloading.rs
index 6f675224a4a9e..e878ded13b1c5 100644
--- a/examples/shader/hot_shader_reloading.rs
+++ b/examples/shader/hot_shader_reloading.rs
@@ -27,7 +27,7 @@ struct MyMaterial {
 }
 
 fn setup(
-    commands: &mut Commands,
+    mut commands: Commands,
     asset_server: ResMut<AssetServer>,
     mut pipelines: ResMut<Assets<PipelineDescriptor>>,
     mut meshes: ResMut<Assets<Mesh>>,
diff --git a/examples/shader/mesh_custom_attribute.rs b/examples/shader/mesh_custom_attribute.rs
index 6d0d2ca09e295..d681feb30be0c 100644
--- a/examples/shader/mesh_custom_attribute.rs
+++ b/examples/shader/mesh_custom_attribute.rs
@@ -52,7 +52,7 @@ void main() {
 "#;
 
 fn setup(
-    commands: &mut Commands,
+    mut commands: Commands,
     mut pipelines: ResMut<Assets<PipelineDescriptor>>,
     mut shaders: ResMut<Assets<Shader>>,
     mut meshes: ResMut<Assets<Mesh>>,
diff --git a/examples/shader/shader_custom_material.rs b/examples/shader/shader_custom_material.rs
index dc02029f37709..92eb9383d033b 100644
--- a/examples/shader/shader_custom_material.rs
+++ b/examples/shader/shader_custom_material.rs
@@ -51,7 +51,7 @@ void main() {
 "#;
 
 fn setup(
-    commands: &mut Commands,
+    mut commands: Commands,
     mut pipelines: ResMut<Assets<PipelineDescriptor>>,
     mut shaders: ResMut<Assets<Shader>>,
     mut meshes: ResMut<Assets<Mesh>>,
diff --git a/examples/shader/shader_defs.rs b/examples/shader/shader_defs.rs
index 383ffd04e2229..9b1ee60bba56d 100644
--- a/examples/shader/shader_defs.rs
+++ b/examples/shader/shader_defs.rs
@@ -63,7 +63,7 @@ void main() {
 "#;
 
 fn setup(
-    commands: &mut Commands,
+    mut commands: Commands,
     mut pipelines: ResMut<Assets<PipelineDescriptor>>,
     mut shaders: ResMut<Assets<Shader>>,
     mut meshes: ResMut<Assets<Mesh>>,
diff --git a/examples/tools/bevymark.rs b/examples/tools/bevymark.rs
index 3c1ea8441311e..c00f257cdaf3a 100644
--- a/examples/tools/bevymark.rs
+++ b/examples/tools/bevymark.rs
@@ -21,10 +21,11 @@ struct Bird {
 
 struct BirdMaterial(Handle<ColorMaterial>);
 
-impl FromResources for BirdMaterial {
-    fn from_resources(resources: &Resources) -> Self {
-        let mut color_materials = resources.get_mut::<Assets<ColorMaterial>>().unwrap();
-        let asset_server = resources.get_mut::<AssetServer>().unwrap();
+impl FromWorld for BirdMaterial {
+    fn from_world(world: &mut World) -> Self {
+        let world = world.cell();
+        let mut color_materials = world.get_resource_mut::<Assets<ColorMaterial>>().unwrap();
+        let asset_server = world.get_resource_mut::<AssetServer>().unwrap();
         BirdMaterial(color_materials.add(asset_server.load("branding/icon.png").into()))
     }
 }
@@ -51,7 +52,7 @@ fn main() {
         .run();
 }
 
-fn setup(commands: &mut Commands, asset_server: Res<AssetServer>) {
+fn setup(mut commands: Commands, asset_server: Res<AssetServer>) {
     commands
         .spawn(OrthographicCameraBundle::new_2d())
         .spawn(UiCameraBundle::default())
@@ -108,7 +109,7 @@ fn setup(commands: &mut Commands, asset_server: Res<AssetServer>) {
 
 #[allow(clippy::too_many_arguments)]
 fn mouse_handler(
-    commands: &mut Commands,
+    mut commands: Commands,
     asset_server: Res<AssetServer>,
     time: Res<Time>,
     mouse_button_input: Res<Input<MouseButton>>,
diff --git a/examples/ui/button.rs b/examples/ui/button.rs
index 119234a5cf464..ac9b4e8f008df 100644
--- a/examples/ui/button.rs
+++ b/examples/ui/button.rs
@@ -16,9 +16,9 @@ struct ButtonMaterials {
     pressed: Handle<ColorMaterial>,
 }
 
-impl FromResources for ButtonMaterials {
-    fn from_resources(resources: &Resources) -> Self {
-        let mut materials = resources.get_mut::<Assets<ColorMaterial>>().unwrap();
+impl FromWorld for ButtonMaterials {
+    fn from_world(world: &mut World) -> Self {
+        let mut materials = world.get_resource_mut::<Assets<ColorMaterial>>().unwrap();
         ButtonMaterials {
             normal: materials.add(Color::rgb(0.15, 0.15, 0.15).into()),
             hovered: materials.add(Color::rgb(0.25, 0.25, 0.25).into()),
@@ -55,7 +55,7 @@ fn button_system(
 }
 
 fn setup(
-    commands: &mut Commands,
+    mut commands: Commands,
     asset_server: Res<AssetServer>,
     button_materials: Res<ButtonMaterials>,
 ) {
diff --git a/examples/ui/font_atlas_debug.rs b/examples/ui/font_atlas_debug.rs
index 63fc3aa355046..0badf0972ffad 100644
--- a/examples/ui/font_atlas_debug.rs
+++ b/examples/ui/font_atlas_debug.rs
@@ -30,7 +30,7 @@ impl Default for State {
 }
 
 fn atlas_render_system(
-    commands: &mut Commands,
+    mut commands: Commands,
     mut state: ResMut<State>,
     mut materials: ResMut<Assets<ColorMaterial>>,
     font_atlas_sets: Res<Assets<FontAtlasSet>>,
@@ -76,7 +76,7 @@ fn text_update_system(mut state: ResMut<State>, time: Res<Time>, mut query: Quer
     }
 }
 
-fn setup(commands: &mut Commands, asset_server: Res<AssetServer>, mut state: ResMut<State>) {
+fn setup(mut commands: Commands, asset_server: Res<AssetServer>, mut state: ResMut<State>) {
     let font_handle = asset_server.load("fonts/FiraSans-Bold.ttf");
     state.handle = font_handle.clone();
     commands.spawn(UiCameraBundle::default()).spawn(TextBundle {
diff --git a/examples/ui/text.rs b/examples/ui/text.rs
index 9bddb821603eb..585819c24e655 100644
--- a/examples/ui/text.rs
+++ b/examples/ui/text.rs
@@ -22,7 +22,7 @@ struct FpsText;
 // A unit struct to help identify the color-changing Text component
 struct ColorText;
 
-fn setup(commands: &mut Commands, asset_server: Res<AssetServer>) {
+fn setup(mut commands: Commands, asset_server: Res<AssetServer>) {
     commands
         // UI camera
         .spawn(UiCameraBundle::default())
diff --git a/examples/ui/text_debug.rs b/examples/ui/text_debug.rs
index 770496942a57b..10423ae5bf4e9 100644
--- a/examples/ui/text_debug.rs
+++ b/examples/ui/text_debug.rs
@@ -19,7 +19,7 @@ fn main() {
 
 struct TextChanges;
 
-fn infotext_system(commands: &mut Commands, asset_server: Res<AssetServer>) {
+fn infotext_system(mut commands: Commands, asset_server: Res<AssetServer>) {
     let font = asset_server.load("fonts/FiraSans-Bold.ttf");
     commands.spawn(UiCameraBundle::default());
     commands.spawn(TextBundle {
diff --git a/examples/ui/ui.rs b/examples/ui/ui.rs
index 67183e6918332..2dfe63894ceaa 100644
--- a/examples/ui/ui.rs
+++ b/examples/ui/ui.rs
@@ -9,7 +9,7 @@ fn main() {
 }
 
 fn setup(
-    commands: &mut Commands,
+    mut commands: Commands,
     asset_server: Res<AssetServer>,
     mut materials: ResMut<Assets<ColorMaterial>>,
 ) {
diff --git a/examples/wasm/assets_wasm.rs b/examples/wasm/assets_wasm.rs
index d5f988838dbbd..f3fb2faa3548d 100644
--- a/examples/wasm/assets_wasm.rs
+++ b/examples/wasm/assets_wasm.rs
@@ -23,7 +23,7 @@ struct State {
     printed: bool,
 }
 
-fn load_asset(commands: &mut Commands, asset_server: Res<AssetServer>) {
+fn load_asset(mut commands: Commands, asset_server: Res<AssetServer>) {
     commands.insert_resource(State {
         handle: asset_server.load("assets_wasm.rs"),
         printed: false,
diff --git a/examples/window/multiple_windows.rs b/examples/window/multiple_windows.rs
index 34c868f128734..52e36d921a067 100644
--- a/examples/window/multiple_windows.rs
+++ b/examples/window/multiple_windows.rs
@@ -57,7 +57,7 @@ fn setup_window(
 }
 
 fn setup_pipeline(
-    commands: &mut Commands,
+    mut commands: Commands,
     windows: Res<Windows>,
     mut active_cameras: ResMut<ActiveCameras>,
     mut render_graph: ResMut<RenderGraph>,
diff --git a/examples/window/scale_factor_override.rs b/examples/window/scale_factor_override.rs
index 06f4a0ce8691c..810986b3ca966 100644
--- a/examples/window/scale_factor_override.rs
+++ b/examples/window/scale_factor_override.rs
@@ -16,7 +16,7 @@ fn main() {
 }
 
 fn setup(
-    commands: &mut Commands,
+    mut commands: Commands,
     asset_server: Res<AssetServer>,
     mut materials: ResMut<Assets<ColorMaterial>>,
 ) {